1
00:00:00,000 --> 00:00:12,350
>> [Muusika mängib]

2
00:00:12,350 --> 00:00:13,050
>> ROB BOWDEN: Hi.

3
00:00:13,050 --> 00:00:13,640
Olen Rob.

4
00:00:13,640 --> 00:00:16,210
Ja olgem seda lahendust.

5
00:00:16,210 --> 00:00:20,070
Nii et siin me läheme rakendada
üldine tabel.

6
00:00:20,070 --> 00:00:24,090
Me näeme, et struct tipp meie
tabel läheb välja nägema selline.

7
00:00:24,090 --> 00:00:28,710
Nii et see saab olema char sõna
massiivi suurus pikkus + 1.

8
00:00:28,710 --> 00:00:32,259
Ära unusta + 1, sest maksimaalne
sõna sõnastikus on 45

9
00:00:32,259 --> 00:00:33,130
tähemärki.

10
00:00:33,130 --> 00:00:37,070
Ja siis me peame ühe pildi
hieroglüüf kurakriips null.

11
00:00:37,070 --> 00:00:40,870
>> Ja siis meie Hashtable igas
kopp läheb salvestada

12
00:00:40,870 --> 00:00:42,320
seotud nimekirja sõlmed.

13
00:00:42,320 --> 00:00:44,420
Me ei tee lineaarse katsetamine siin.

14
00:00:44,420 --> 00:00:48,430
Ja nii, et siduda järgmise
element ämbrisse, peame

15
00:00:48,430 --> 00:00:50,390
struct tipp * järgmine.

16
00:00:50,390 --> 00:00:51,110
OK.

17
00:00:51,110 --> 00:00:53,090
Nii see on, mida sõlme välja näeb.

18
00:00:53,090 --> 00:00:56,180
>> Nüüd siin on avaldus
meie Hashtable.

19
00:00:56,180 --> 00:00:59,640
See saab olema 16834 ämbrid.

20
00:00:59,640 --> 00:01:01,910
Aga see number ei ole tegelikult küsimus.

21
00:01:01,910 --> 00:01:05,450
Ja lõpuks, me ei kavatse olla
globaalse muutuja Hashtable suurus, mis

22
00:01:05,450 --> 00:01:07,000
läheb alustad null.

23
00:01:07,000 --> 00:01:10,760
Ja see saab jälgida, kuidas
paljud sõnad on meie sõnastik.

24
00:01:10,760 --> 00:01:13,710
>> Võtame pilk koormus.

25
00:01:13,710 --> 00:01:16,390
Pange tähele, et koormus, tagastatakse tõeväärtus.

26
00:01:16,390 --> 00:01:20,530
Sa tagasi true, kui see oli edukalt
koormatud, ja vale teisiti.

27
00:01:20,530 --> 00:01:23,990
Ja see võtab const char * sõnastikku
mis on sõnastik

28
00:01:23,990 --> 00:01:25,280
et tahame avada.

29
00:01:25,280 --> 00:01:27,170
Nii et esimene asi,
me teeme.

30
00:01:27,170 --> 00:01:29,500
>> Me läheme fopen
sõnastik lugemiseks.

31
00:01:29,500 --> 00:01:31,680
Ja me peame tegema
kindel, et see õnnestus.

32
00:01:31,680 --> 00:01:35,920
Nii et kui see tagastatakse NULL, siis me ei
edukalt avada sõnaraamatut.

33
00:01:35,920 --> 00:01:37,440
Ja me peame tagasi false.

34
00:01:37,440 --> 00:01:41,580
Kuid kui eeldada, et ta seda tegi edukalt
avatud, siis tahame, et lugeda

35
00:01:41,580 --> 00:01:42,400
sõnastik.

36
00:01:42,400 --> 00:01:46,450
Nii et hoidke silmusega kuni leiame mõned
põhjus välja murda see ahel,

37
00:01:46,450 --> 00:01:47,570
mida me näeme.

38
00:01:47,570 --> 00:01:48,920
Nii et hoidke silmusega.

39
00:01:48,920 --> 00:01:51,780
>> Ja nüüd me läheme
malloc ühe sõlme.

40
00:01:51,780 --> 00:01:54,020
Ja muidugi me vajame
õhku kontrollige uuesti.

41
00:01:54,020 --> 00:01:58,680
Nii et kui mallocing ei õnnestu, siis
tahame lossida ühtegi sõlme, et me

42
00:01:58,680 --> 00:02:02,590
juhtus malloc enne, sulgege
sõnastik ja tagastab false.

43
00:02:02,590 --> 00:02:06,830
Aga tähelepanuta asjaolu, eeldades, et me
õnnestunud, siis tahame kasutada fscanf

44
00:02:06,830 --> 00:02:12,400
loe sõnagi meie
sõnastik meie sõlme.

45
00:02:12,400 --> 00:02:17,940
Seega pidage meeles, et entry> sõna on char
sõna puhverala suurus lenghth + 1

46
00:02:17,940 --> 00:02:20,300
et me salvestada sõna sisse

47
00:02:20,300 --> 00:02:25,070
>> Nii fscanf läheb tagasi 1, kui
kui see oli võimalik edukalt

48
00:02:25,070 --> 00:02:26,750
loe sõna failist.

49
00:02:26,750 --> 00:02:30,460
Kui üks viga juhtub, või me
jõuda lõpuks fail,

50
00:02:30,460 --> 00:02:31,950
ei naase 1.

51
00:02:31,950 --> 00:02:35,180
Sel juhul ei pöördu 1,
lõpuks ometi oleme välja murda

52
00:02:35,180 --> 00:02:37,280
see samas silmus.

53
00:02:37,280 --> 00:02:42,770
Nii me näeme, et kui meil on edukalt
loe sõna võtta

54
00:02:42,770 --> 00:02:48,270
entry> sõna, siis me läheme, et
sõna meie hash funktsiooni.

55
00:02:48,270 --> 00:02:49,580
>> Võtame pilk
hash funktsiooni.

56
00:02:49,580 --> 00:02:52,430

57
00:02:52,430 --> 00:02:55,610
Nii et sa tõesti ei pea
sellest aru saama.

58
00:02:55,610 --> 00:02:59,460
Ja tegelikult me ​​lihtsalt tõmmatakse see hash
toimida internetist.

59
00:02:59,460 --> 00:03:04,010
Ainuke asi, sa pead tunnistama, on
et see võtab const char * sõna.

60
00:03:04,010 --> 00:03:08,960
Nii et see võtab stringi sisendiks ja
tagastamise allkirjastamata int toodanguna.

61
00:03:08,960 --> 00:03:12,360
Nii et kõik on hash funktsiooni, on see
võtab sisendiks ja annab teile

62
00:03:12,360 --> 00:03:14,490
indeks Hashtable.

63
00:03:14,490 --> 00:03:18,530
>> Pange tähele, et me moding poolt NUM_BUCKETS,
et raha tagasi

64
00:03:18,530 --> 00:03:21,730
tegelikult on indeks Hashtable
ja ei indeks üle

65
00:03:21,730 --> 00:03:24,320
piire massiiv.

66
00:03:24,320 --> 00:03:28,060
Seega, arvestades, et funktsioon, me
hash sõna, et me lugeda

67
00:03:28,060 --> 00:03:29,390
sõnastik.

68
00:03:29,390 --> 00:03:31,700
Ja siis me ei kavatse kasutada
et hash sisestada

69
00:03:31,700 --> 00:03:33,750
sisenemise Hashtable.

70
00:03:33,750 --> 00:03:38,520
>> Nüüd Hashtable hash on praegune
seotud nimekirja tabelis.

71
00:03:38,520 --> 00:03:41,410
Ja see on väga võimalik,
et see on lihtsalt NULL.

72
00:03:41,410 --> 00:03:44,960
Me tahame, et lisada oma sisenemise
alguses see seotud nimekirja.

73
00:03:44,960 --> 00:03:48,600
Ja nii me lähed on meie praegune
sisenemispunkti mida Hashtable

74
00:03:48,600 --> 00:03:50,380
Praegu osutab.

75
00:03:50,380 --> 00:03:53,310
Ja siis me lähme salvestada,
aastal Hashtable juures

76
00:03:53,310 --> 00:03:55,350
hash praegune kanne.

77
00:03:55,350 --> 00:03:59,320
Nii et need kaks rida edukalt sisestada
kande alguses

78
00:03:59,320 --> 00:04:02,260
seotud nimekirja sel indeks
aastal Hashtable.

79
00:04:02,260 --> 00:04:04,900
>> Kui me teinud, et me teame
et me leidsime teise sõna

80
00:04:04,900 --> 00:04:07,790
sõnastikku ning me juurdekasvu uuesti.

81
00:04:07,790 --> 00:04:13,960
Nii me edasi teha kuni fscanf
lõpuks tagasi millegi mitte-1 juures

82
00:04:13,960 --> 00:04:16,950
mis punkt meeles pidada, et
peame sissepääs tasuta.

83
00:04:16,950 --> 00:04:19,459
Nii siin me malloced kanne.

84
00:04:19,459 --> 00:04:21,329
Ja me proovisime midagi lugeda
sõnaraamatust.

85
00:04:21,329 --> 00:04:23,910
Ja me ei ole suutnud lugeda
midagi sõnaraamatu

86
00:04:23,910 --> 00:04:26,650
mille puhul me peame vabastama kanne
et me ei ole kunagi tegelikult ellu

87
00:04:26,650 --> 00:04:29,140
Hashtable ja lõpuks murda.

88
00:04:29,140 --> 00:04:32,750
>> Kui me välja murda on vaja näha, noh,
me välja murda, sest seal

89
00:04:32,750 --> 00:04:34,360
oli viga lugemisel failist?

90
00:04:34,360 --> 00:04:37,120
Või kas me välja murda, sest me
jõudnud faili?

91
00:04:37,120 --> 00:04:39,480
Kui seal oli viga, siis
tahame tagasi false.

92
00:04:39,480 --> 00:04:40,930
Kuna koormus ei õnnestunud.

93
00:04:40,930 --> 00:04:43,890
Ja selles protsessis me tahame maha laadima
kõik sõnad, et me lugeda, ja

94
00:04:43,890 --> 00:04:45,670
sulgeda sõnastik faili.

95
00:04:45,670 --> 00:04:48,740
>> Eeldades, et me ei õnnestu, siis me lihtsalt
ikka on vaja sulgeda sõnastik

96
00:04:48,740 --> 00:04:53,040
fail ning lõpuks tagasi true, sest me
edukalt laaditud sõnastik.

97
00:04:53,040 --> 00:04:54,420
Ja see on see koormus.

98
00:04:54,420 --> 00:04:59,020
Nüüd vaadake, arvestades koormatud Hashtable,
läheb välja nägema selline.

99
00:04:59,020 --> 00:05:03,140
Nii et vaadata, tagastatakse tõeväärtus, mis on
läheb, et näidata, kas möödunud

100
00:05:03,140 --> 00:05:07,530
Char * sõna, kas möödunud
string on meie sõnastik.

101
00:05:07,530 --> 00:05:09,890
Nii et kui see on sõnastikku
kui see on meie Hashtable,

102
00:05:09,890 --> 00:05:11,170
me tagasi tõsi.

103
00:05:11,170 --> 00:05:13,380
Ja kui see ei ole, siis me tagastame false.

104
00:05:13,380 --> 00:05:17,740
>> Arvestades seda möödus sõna, me oleme
läheb räsi sõna.

105
00:05:17,740 --> 00:05:22,110
Nüüd tähtsam tunnustada on
et koormuse teadsime et kõik

106
00:05:22,110 --> 00:05:23,820
sõnad me olema väiketähtedega.

107
00:05:23,820 --> 00:05:25,820
Aga siin me ei ole nii kindel.

108
00:05:25,820 --> 00:05:29,510
Kui me võtame pilk meie räsifunktsiooni,
meie räsifunktsiooni tegelikult

109
00:05:29,510 --> 00:05:32,700
on väiksem korpuse iga märk
sõna.

110
00:05:32,700 --> 00:05:37,940
Seega sõltumata kapitaliseerimine
Ühesõnaga, meie räsifunktsiooni jõutakse tagasi

111
00:05:37,940 --> 00:05:42,270
sama indeksit mingil
kapitalisatsioon on, nagu oleks ta

112
00:05:42,270 --> 00:05:45,280
tagastatud täielikult väiketähti
versioon sõna.

113
00:05:45,280 --> 00:05:46,600
Olgu.

114
00:05:46,600 --> 00:05:49,790
See on meie indeks on arvesse
Hashtable selle sõna.

115
00:05:49,790 --> 00:05:52,940
>> Nüüd on see loop läheb
Käi seotud nimekirja

116
00:05:52,940 --> 00:05:55,000
mis oli sel indeks.

117
00:05:55,000 --> 00:05:59,610
Nii märkate oleme algväärtustamisel kanne
osutada, et indeks.

118
00:05:59,610 --> 00:06:02,750
Me kavatseme jätkata
kui kanne! = NULL.

119
00:06:02,750 --> 00:06:07,770
Ja pidage meeles, et ajakohastada pointer
Meie seotud nimekirja kandmise = entry> kõrval.

120
00:06:07,770 --> 00:06:14,400
Nii on meie praegune sisendkoht
Järgmine punkt on seotud nimekirja.

121
00:06:14,400 --> 00:06:19,250
>> Nii iga kande seotud nimekirja,
Me ei kavatse kasutada strcasecmp.

122
00:06:19,250 --> 00:06:20,330
See ei ole strcomp.

123
00:06:20,330 --> 00:06:23,780
Sest taas tahame
asju juhul hoolimatult.

124
00:06:23,780 --> 00:06:27,870
Nii et me kasutame strcasecmp võrrelda
Sõna, mis läbis selle

125
00:06:27,870 --> 00:06:31,860
funktsiooni vastu sõna
mis on see kanne.

126
00:06:31,860 --> 00:06:35,570
Kui ta naaseb null, mis tähendab, et seal oli
mängu, mille puhul me tahame

127
00:06:35,570 --> 00:06:36,630
tagasi true.

128
00:06:36,630 --> 00:06:39,590
Oleme edukalt leitud
sõna meie Hashtable.

129
00:06:39,590 --> 00:06:43,040
>> Kui ei sobi, siis me oleme
läheb loop uuesti ja vaadata

130
00:06:43,040 --> 00:06:43,990
järgmine kanne.

131
00:06:43,990 --> 00:06:47,640
Ja me jätkame silmukoiminen samas
on sissekanded Selle seotud nimekirja.

132
00:06:47,640 --> 00:06:50,160
Mis juhtub, kui me murda
sellest loop?

133
00:06:50,160 --> 00:06:55,110
See tähendab, et me ei leia kirje,
sobitada see sõna, mille puhul

134
00:06:55,110 --> 00:07:00,220
me tagasi false näitab, et meie
Hashtable ei sisalda seda sõna.

135
00:07:00,220 --> 00:07:02,540
Ja see on kontrolli all.

136
00:07:02,540 --> 00:07:04,790
>> Võtame pilk suurus.

137
00:07:04,790 --> 00:07:06,970
Nüüd suurus saab olema üsna lihtne.

138
00:07:06,970 --> 00:07:11,080
Kuna mäleta koormus, iga sõna
leidsime me suurendatakse globaalset

139
00:07:11,080 --> 00:07:12,880
muutuja Hashtable suurus.

140
00:07:12,880 --> 00:07:16,480
Nii suuruse funktsioon on lihtsalt läheb
tagasi globaalse muutuja.

141
00:07:16,480 --> 00:07:18,150
Ja ongi kõik.

142
00:07:18,150 --> 00:07:22,300
>> Nüüd lõpuks on meil vaja maha laadida
sõnastik Kui kõik on tehtud.

143
00:07:22,300 --> 00:07:25,340
Niisiis, kuidas me saame seda teha?

144
00:07:25,340 --> 00:07:30,440
Siin me silmusega üle
kõik ämbrid meie lauale.

145
00:07:30,440 --> 00:07:33,240
Seega on NUM_BUCKETS ämbrid.

146
00:07:33,240 --> 00:07:37,410
Ja iga seotud nimekirja meie
Hashtable, me silmus üle

147
00:07:37,410 --> 00:07:41,070
kogu seotud nimekirja,
vabastades iga element.

148
00:07:41,070 --> 00:07:42,900
>> Nüüd me peame olema ettevaatlikud.

149
00:07:42,900 --> 00:07:47,910
Nii et siin on meil ajutise muutuja
mis on hoidmiseks kursor järgmisele

150
00:07:47,910 --> 00:07:49,730
element, mis on seotud nimekirja.

151
00:07:49,730 --> 00:07:52,140
Ja siis me tasuta
praegune element.

152
00:07:52,140 --> 00:07:55,990
Me peame olema kindlad, et me teeme seda, sest me
ei saa lihtsalt vaba praegune element

153
00:07:55,990 --> 00:07:59,180
ja seejärel üritada pääsu järgmise pointer,
sest kui oleme vabanenud see,

154
00:07:59,180 --> 00:08:00,870
mälu muutub kehtetuks.

155
00:08:00,870 --> 00:08:04,990
>> Seega on meil vaja, et hoida umbes viit
Järgmine element, siis saab tasuta

156
00:08:04,990 --> 00:08:08,360
praegune element, ja siis saame uuendada
meie praegune element osutada

157
00:08:08,360 --> 00:08:09,550
Järgmine element.

158
00:08:09,550 --> 00:08:12,800
Me loop kui ilmnevad asjaolud,
Selles seotud nimekirja.

159
00:08:12,800 --> 00:08:15,620
Me teeme, et kõik, mis on seotud
nimekirjade Hashtable.

160
00:08:15,620 --> 00:08:19,460
Ja kui me oleme teinud, et me oleme
täielikult maha laadida Hashtable ja

161
00:08:19,460 --> 00:08:20,190
me oleme valmis.

162
00:08:20,190 --> 00:08:23,200
Nii et see on võimatu unload
kunagi tagasi false.

163
00:08:23,200 --> 00:08:26,470
Ja kui me oleme valmis, me
lihtsalt tagasi tõsi.

164
00:08:26,470 --> 00:08:29,000
>> Anname sellele lahendus proovida.

165
00:08:29,000 --> 00:08:33,070
Võtame pilk meie
struct sõlme välja näeb.

166
00:08:33,070 --> 00:08:36,220
Siin näeme me lähed on bool
sõna ja struct tipp * lapsed

167
00:08:36,220 --> 00:08:37,470
sulg tähestikku.

168
00:08:37,470 --> 00:08:38,929

169
00:08:38,929 --> 00:08:42,020
Nii et esimene asi, mida võiks
tea, miks on tähestik

170
00:08:42,020 --> 00:08:44,660
väljaanne defineeritud 27?

171
00:08:44,660 --> 00:08:47,900
Noh, pea meeles, et me peame
tuleb käitlemise ülakoma.

172
00:08:47,900 --> 00:08:51,910
Nii et see saab olema mõnevõrra
erijuhtum kogu programmi.

173
00:08:51,910 --> 00:08:54,710
>> Pea meeles, kui Prefiksipuu
tegelikult toimib.

174
00:08:54,710 --> 00:08:59,380
Oletame, et me indekseerimise sõna
"Kassid". Siis juur Prefiksipuu,

175
00:08:59,380 --> 00:09:02,610
me vaatame lapsed
massiiv, ja me ei kavatse vaadata

176
00:09:02,610 --> 00:09:08,090
indeks, mis vastab kirjale
C. Nii et indekseeritakse 2.

177
00:09:08,090 --> 00:09:11,530
Seega, arvestades, et see tahe
anna meile uus sõlm.

178
00:09:11,530 --> 00:09:13,820
Ja siis me tööd, et sõlme.

179
00:09:13,820 --> 00:09:17,770
>> Seega, arvestades, et sõlm, me oleme taas
lähen vaatama laste massiivi.

180
00:09:17,770 --> 00:09:22,110
Ja me ei kavatse vaadata indeks nulli
vastama kassi.

181
00:09:22,110 --> 00:09:27,170
Siis me läheme selle sõlme
ning arvestades, et sõlm me

182
00:09:27,170 --> 00:09:31,090
pilk lõpuks see vastab
T. ja liigub edasi, et sõlm,

183
00:09:31,090 --> 00:09:35,530
Lõpuks oleme täiesti vaadanud
läbi meie sõna "kass". Ja nüüd bool

184
00:09:35,530 --> 00:09:40,960
sõna peaks näitama, kas
see antud sõna on tegelikult sõna.

185
00:09:40,960 --> 00:09:43,470
>> Nii et miks meil seda vaja on erijuhtum?

186
00:09:43,470 --> 00:09:47,700
Noh, mida sõna "katastroof"
on meie sõnastik, kuid

187
00:09:47,700 --> 00:09:50,150
sõna "kass" ei ole?

188
00:09:50,150 --> 00:09:54,580
Nii ja vaadates, kui sõna "kass"
on meie sõnastik, me oleme

189
00:09:54,580 --> 00:09:59,970
läheb edukalt läbi vaatama
indeksite C-A-T piirkonnas sõlme.

190
00:09:59,970 --> 00:10:04,290
Aga see on ainult sellepärast, et katastroofi
juhtus luua sõlmede tee

191
00:10:04,290 --> 00:10:07,190
C--T, kõik viis
lõpuks sõna.

192
00:10:07,190 --> 00:10:12,020
Nii bool sõna kasutatakse, et näidata, kas
see konkreetne asukoht

193
00:10:12,020 --> 00:10:14,310
tegelikult näitab sõna.

194
00:10:14,310 --> 00:10:15,140
>> Hea küll.

195
00:10:15,140 --> 00:10:19,310
Nüüd, et me teame, mida see Prefiksipuu on
hakkab välja nägema, vaatame

196
00:10:19,310 --> 00:10:20,730
avada funktsiooni.

197
00:10:20,730 --> 00:10:24,610
Nii koormus läheb tagasi bool
jaoks kas õnnestus või

198
00:10:24,610 --> 00:10:26,720
edutult koormatud sõnastik.

199
00:10:26,720 --> 00:10:30,460
Ja see saab olema sõnastik
et me tahame last.

200
00:10:30,460 --> 00:10:33,930
>> Nii et esimene asi, mida me teha, on avatud
up, et sõnastik lugemiseks.

201
00:10:33,930 --> 00:10:36,160
Ja me peame tagama,
me ei suuda.

202
00:10:36,160 --> 00:10:39,580
Nii et kui sõnastik ei olnud
avasid, siis pöördutakse

203
00:10:39,580 --> 00:10:42,400
null, mille puhul me oleme
läheb tagasi false.

204
00:10:42,400 --> 00:10:47,230
Kuid kui eeldada, et see edukalt
avatud, siis võib tegelikult lugeda

205
00:10:47,230 --> 00:10:48,220
läbi sõnastik.

206
00:10:48,220 --> 00:10:50,880
>> Nii et esimene asi, mida me ei kavatse
tahame teha, on meil see

207
00:10:50,880 --> 00:10:52,500
globaalse muutuja root.

208
00:10:52,500 --> 00:10:56,190
Nüüd root saab olema node *.

209
00:10:56,190 --> 00:10:59,760
See on top meie Prefiksipuu et me oleme
kavatse iterating kaudu.

210
00:10:59,760 --> 00:11:02,660
Nii et esimene asi, mida me ei kavatse
et tahad teha, on eraldada

211
00:11:02,660 --> 00:11:04,140
mälu meie juure.

212
00:11:04,140 --> 00:11:07,980
Pange tähele, et me kasutame calloc
funktsioon, mis on põhimõtteliselt sama

213
00:11:07,980 --> 00:11:11,500
kui malloc funktsioon, välja arvatud see
tagatud tagasi midagi, mis on

214
00:11:11,500 --> 00:11:13,180
täiesti nullida välja.

215
00:11:13,180 --> 00:11:17,290
Nii et kui me kasutasime malloc, meil oleks vaja
läbima kõik suunanäitajaks meie

216
00:11:17,290 --> 00:11:20,160
sõlme, ja veenduge, et
nad on kõik null.

217
00:11:20,160 --> 00:11:22,710
Nii calloc teeb seda meie eest.

218
00:11:22,710 --> 00:11:26,330
>> Nüüd nagu malloc, peame
Veenduge, et jaotus oli tegelikult

219
00:11:26,330 --> 00:11:27,520
edukas.

220
00:11:27,520 --> 00:11:29,990
Kui see tagastatakse null, siis
vaja sulgeda või sõnastik

221
00:11:29,990 --> 00:11:32,100
faili ja tagastab false.

222
00:11:32,100 --> 00:11:36,835
Seega eeldades, et eraldist
edukas, me ei kavatse kasutada sõlme *

223
00:11:36,835 --> 00:11:40,270
kursor itereerima meie Prefiksipuu.

224
00:11:40,270 --> 00:11:43,890
Nii et meie juured ei muutu,
kuid me ei kavatse kasutada kursori

225
00:11:43,890 --> 00:11:47,875
tegelikult lähevad sõlme sõlme.

226
00:11:47,875 --> 00:11:50,940
>> Nii et selles silmus me loevad
läbi sõnastik faili.

227
00:11:50,940 --> 00:11:53,670
Ja me kasutame fgetc.

228
00:11:53,670 --> 00:11:56,290
Fgetc läheb haarata ühe
tegelasele faili.

229
00:11:56,290 --> 00:11:59,370
Me läheme edasi haarates
märki, kui me ei jõua

230
00:11:59,370 --> 00:12:01,570
Faili lõpus.

231
00:12:01,570 --> 00:12:03,480
>> Kahel juhul peame hakkama.

232
00:12:03,480 --> 00:12:06,610
Esimene, kui märk
ei olnud uus liin.

233
00:12:06,610 --> 00:12:10,450
Seega me teame, kui see oli uus rida, siis
me parasjagu liikuda edasi uue sõna.

234
00:12:10,450 --> 00:12:15,240
Aga isegi kui see ei olnud uue raudteeliini, siis
siin me tahame teada,

235
00:12:15,240 --> 00:12:18,380
index me indeks
aastal laste massiivi

236
00:12:18,380 --> 00:12:19,810
me vaatasime enne.

237
00:12:19,810 --> 00:12:23,880
>> Nii, nagu ma enne ütlesin, on meil vaja
erijuhtum ülakoma.

238
00:12:23,880 --> 00:12:26,220
Pange tähele, me kasutame ternaarse
operaator siin.

239
00:12:26,220 --> 00:12:29,580
Nii et me ei kavatse lugeda seda, kui
iseloomu loeme oli

240
00:12:29,580 --> 00:12:35,330
ülakomaga, siis me läheme, et seada
index = "tähestik" -1, mis

241
00:12:35,330 --> 00:12:37,680
olema indeks 26.

242
00:12:37,680 --> 00:12:41,130
>> Sest kui ta ei ülakoma olemas
me seada indeks

243
00:12:41,130 --> 00:12:43,760
võrdne c -.

244
00:12:43,760 --> 00:12:49,030
Seega pidage meeles, tagasi varem p-komplektid,
c - läheb meile

245
00:12:49,030 --> 00:12:53,410
tähestiku positsiooni C. Seega, kui
C on kirjas, see

246
00:12:53,410 --> 00:12:54,700
meile indeks null.

247
00:12:54,700 --> 00:12:58,120
Tähe B, see annab
us indeks 1, ja nii edasi.

248
00:12:58,120 --> 00:13:03,010
>> Nii et see annab meile indeks
lapsed massiivi tahame.

249
00:13:03,010 --> 00:13:08,890
Nüüd, kui see indeks on praegu null sisse
lastele, see tähendab, et sõlm

250
00:13:08,890 --> 00:13:11,830
Praegu ei eksisteeri
selle tee.

251
00:13:11,830 --> 00:13:15,160
Nii et me peame eraldama
sõlm, mis teed.

252
00:13:15,160 --> 00:13:16,550
See on see, mida me teeme siin.

253
00:13:16,550 --> 00:13:20,690
>> Nii et me läheme uuesti kasutada calloc
funktsioon, nii et me ei pea

254
00:13:20,690 --> 00:13:22,880
null välja kõik suunanäitajaks.

255
00:13:22,880 --> 00:13:27,240
Ja me jälle vaja vaadata
et calloc ei õnnestu.

256
00:13:27,240 --> 00:13:30,700
Kui calloc ei suuda, siis on meil vaja
lossimiseks kõike, sulgeda

257
00:13:30,700 --> 00:13:32,820
sõnastikku ning tagastab false.

258
00:13:32,820 --> 00:13:40,050
Seega eeldades, et ta ei ole, siis
see loob uue lapse juures.

259
00:13:40,050 --> 00:13:41,930
Ja siis me läheme, et laps.

260
00:13:41,930 --> 00:13:44,960
Meie kursor itereerib
alla, et laps.

261
00:13:44,960 --> 00:13:49,330
>> Nüüd, kui see ei ole null alustada,
siis kursori lihtsalt kinnitada,

262
00:13:49,330 --> 00:13:52,590
alla, et laps ilma tegelikult
võttes eraldada midagi.

263
00:13:52,590 --> 00:13:56,730
Seda juhul, kui me esimest korda juhtus
eraldab sõna "kass". Ja

264
00:13:56,730 --> 00:14:00,330
see tähendab, et kui me läheme eraldada
"Katastroof", siis me ei pea looma

265
00:14:00,330 --> 00:14:01,680
sõlmpunktid C--T uuesti.

266
00:14:01,680 --> 00:14:04,830
Nad on juba olemas.

267
00:14:04,830 --> 00:14:06,080
>> Mis on see teine?

268
00:14:06,080 --> 00:14:10,480
See on seisund, kus c on
kurakriips n, kus c on uus liin.

269
00:14:10,480 --> 00:14:13,710
See tähendab, et meil on edukalt
lõpule sõna.

270
00:14:13,710 --> 00:14:16,860
Nüüd, mida me tahame teha, kui me
edukalt lõpule sõna?

271
00:14:16,860 --> 00:14:21,100
Me ei kavatse kasutada seda sõna valdkonnas
sees meie struct sõlme.

272
00:14:21,100 --> 00:14:23,390
Me tahame kehtestada, et tõsi.

273
00:14:23,390 --> 00:14:27,150
Niisiis, mis näitab, et see sõlm
näitab edukas

274
00:14:27,150 --> 00:14:29,250
Ühesõnaga, tegelik sõna.

275
00:14:29,250 --> 00:14:30,940
>> Nüüd sätestatud, et tõsi.

276
00:14:30,940 --> 00:14:35,150
Me tahame taastada oma kursor punkti
Lisa alguses Prefiksipuu uuesti.

277
00:14:35,150 --> 00:14:40,160
Ja lõpuks, juurdekasvu meie sõnastik
suurus, kuna me leidsime veel tööd.

278
00:14:40,160 --> 00:14:43,230
Nii et me ei kavatse seda enam teha, et
lugedes tähemärgi haaval

279
00:14:43,230 --> 00:14:49,150
ehitamise uue tippe meie Prefiksipuu ja
iga sõna sõnaraamatust, kuni

280
00:14:49,150 --> 00:14:54,020
me lõpuks jõuda C! = EOF, kus
juhul me välja murda faili.

281
00:14:54,020 --> 00:14:57,050
>> Nüüd on kaks juhtumit all
mis meil oleks tabanud EOF.

282
00:14:57,050 --> 00:15:00,980
Esimene neist on, kui seal oli viga
lugemine failist.

283
00:15:00,980 --> 00:15:03,470
Nii et kui seal oli viga, me
vaja teha, tüüpiline.

284
00:15:03,470 --> 00:15:06,460
Laadige kõik lähedal
fail, tagastab false.

285
00:15:06,460 --> 00:15:09,810
Eeldades, ei olnud viga, et
lihtsalt tähendab, et me tegelikult tabas lõpuks

286
00:15:09,810 --> 00:15:13,750
fail, mille puhul me sulgeda
faili ja tagastab tõsi, sest me

287
00:15:13,750 --> 00:15:17,330
edukalt laaditud sõnastik
meie Prefiksipuu.

288
00:15:17,330 --> 00:15:20,170
>> Nüüd vaatame läbi vaadata.

289
00:15:20,170 --> 00:15:25,156
Vaadates kontrolli funktsioon, näeme
et kontroll läheb tagasi bool.

290
00:15:25,156 --> 00:15:29,680
Ta naaseb tõsi, kui see sõna, mis ta on
möödutakse on meie Prefiksipuu.

291
00:15:29,680 --> 00:15:32,110
Ta naaseb vale teisiti.

292
00:15:32,110 --> 00:15:36,050
Niisiis, kuidas sa otsustada, kas
see sõna on meie Prefiksipuu?

293
00:15:36,050 --> 00:15:40,190
>> Me näeme siin, et nagu varem,
Me ei kavatse kasutada kursori itereerima

294
00:15:40,190 --> 00:15:41,970
meie Prefiksipuu.

295
00:15:41,970 --> 00:15:46,600
Nüüd siin me kinnitada,
üle kogu meie sõna.

296
00:15:46,600 --> 00:15:50,620
Nii iterating üle sõna oleme minevikus
me kindlaks

297
00:15:50,620 --> 00:15:56,400
indeks laste massiivi
vastab sõna sulg I. Nii et see

298
00:15:56,400 --> 00:15:59,670
läheb välja täpselt nagu
koormus, kus siis, kui sõna [i]

299
00:15:59,670 --> 00:16:03,310
on ülakomaga, siis me tahame
kasutada index "tähestik" - 1.

300
00:16:03,310 --> 00:16:05,350
Sest me kindlaks, et
on koht, kus me salvestada

301
00:16:05,350 --> 00:16:07,100
ülakomad.

302
00:16:07,100 --> 00:16:11,780
>> Else me kasutame kaks alumist sõna
sulg I. Seega pidage meeles, et sõna saab

303
00:16:11,780 --> 00:16:13,920
on meelevaldne kapitaliseeritust.

304
00:16:13,920 --> 00:16:17,540
Ja nii me tahame veenduda, et me oleme
kasutades väiketähti versiooni asju.

305
00:16:17,540 --> 00:16:21,920
Ja siis lahutama, et "" üks kord
jälle meile tähestikulises

306
00:16:21,920 --> 00:16:23,880
seisukohta, et märk.

307
00:16:23,880 --> 00:16:27,680
Nii et see saab olema meie indeks
arvesse laste massiivi.

308
00:16:27,680 --> 00:16:32,420
>> Ja nüüd, kui see indeks lapsed
massiiv on null, mis tähendab, et me

309
00:16:32,420 --> 00:16:34,990
ei saa enam jätkata iterating
alla meie Prefiksipuu.

310
00:16:34,990 --> 00:16:38,870
Kui see on nii, see sõna ei saa
võib-olla on meie Prefiksipuu.

311
00:16:38,870 --> 00:16:42,340
Kuna see oleks, et oleks
tähenda, et oleks tee

312
00:16:42,340 --> 00:16:43,510
alla, et sõna.

313
00:16:43,510 --> 00:16:45,290
Ja sa ei oleks kunagi tekib null.

314
00:16:45,290 --> 00:16:47,850
Nii tekib null, siis tagastab false.

315
00:16:47,850 --> 00:16:49,840
Sõna ei ole sõnastikus.

316
00:16:49,840 --> 00:16:53,660
Kui see ei oleks null, siis me oleme
jätkub iterating.

317
00:16:53,660 --> 00:16:57,220
>> Nii me seal kursori
osutada erilist

318
00:16:57,220 --> 00:16:59,760
sõlm, et indeks.

319
00:16:59,760 --> 00:17:03,150
Hoiame teed, et kogu
Kogu sõna eeldades

320
00:17:03,150 --> 00:17:03,950
me kunagi tabanud null.

321
00:17:03,950 --> 00:17:07,220
See tähendab, et me saime läbi
kogu sõna ning leida

322
00:17:07,220 --> 00:17:08,920
sõlme meie proovida.

323
00:17:08,920 --> 00:17:10,770
Aga me ei ole päris valmis veel.

324
00:17:10,770 --> 00:17:12,290
>> Me ei taha lihtsalt tagasi tõsi.

325
00:17:12,290 --> 00:17:14,770
Tahame tagasi kursor> sõna.

326
00:17:14,770 --> 00:17:18,980
Kuna mäletan veel, on "kass" ei ole
meie sõnastikku ja "katastroof"

327
00:17:18,980 --> 00:17:22,935
on, siis me edukalt saame
läbi sõna "kass". Aga kursor

328
00:17:22,935 --> 00:17:25,760
sõna on vale ja ei vasta tõele.

329
00:17:25,760 --> 00:17:30,930
Nii me tagasi kursor tähistavat sõna
kas see sõlm on tegelikult sõna.

330
00:17:30,930 --> 00:17:32,470
Ja see on seda kontrollida.

331
00:17:32,470 --> 00:17:34,250
>> Nii Vaatame suurus.

332
00:17:34,250 --> 00:17:37,350
Nii suurus saab olema üsna lihtne
sest mäletan koormus, me oleme

333
00:17:37,350 --> 00:17:41,430
incrementing sõnastik suurus
Iga sõna, mida me kohtame.

334
00:17:41,430 --> 00:17:45,350
Nii suurus on lihtsalt läheb
tagasi sõnastik suurus.

335
00:17:45,350 --> 00:17:47,390
Ja ongi kõik.

336
00:17:47,390 --> 00:17:50,590
>> Nii lõpuks oleme maha laadida.

337
00:17:50,590 --> 00:17:55,100
Nii lossimiseks, me ei kavatse kasutada
rekursiivne funktsioon tegelikult teha kõik

338
00:17:55,100 --> 00:17:56,530
töö meile.

339
00:17:56,530 --> 00:17:59,340
Nii et meie ülesanne läheb
kutsutakse unloader.

340
00:17:59,340 --> 00:18:01,650
Mida Tühjenduse teha kavatsed?

341
00:18:01,650 --> 00:18:06,580
Me näeme siin, et Tühjenduse läheb
Käi kõik lapsed

342
00:18:06,580 --> 00:18:08,410
selle konkreetse sõlme.

343
00:18:08,410 --> 00:18:11,750
Ja kui laps sõlme ei
null, siis me läheme

344
00:18:11,750 --> 00:18:13,730
lossimiseks laps sõlme.

345
00:18:13,730 --> 00:18:18,010
>> Nii et see on teile rekursiivselt mahalaadimiseks
kõik meie lapsed.

346
00:18:18,010 --> 00:18:21,080
Kui oleme kindlad, et kõik meie lapsed
on maha laaditud, siis me

347
00:18:21,080 --> 00:18:25,210
saab tasuta ise, nii
lossimiseks ise.

348
00:18:25,210 --> 00:18:29,460
See toimib rekursiivselt
lossida kogu Prefiksipuu.

349
00:18:29,460 --> 00:18:32,850
Ja siis, kui see on tehtud,
saame lihtsalt tagasi tõsi.

350
00:18:32,850 --> 00:18:34,210
Sulgeda ei saa jätta.

351
00:18:34,210 --> 00:18:35,710
Me lihtsalt vabastades asju.

352
00:18:35,710 --> 00:18:38,870
Nii et kui me teinud vabastades
kõik, tagastab true.

353
00:18:38,870 --> 00:18:40,320
Ja ongi kõik.

354
00:18:40,320 --> 00:18:41,080
Minu nimi on Rob.

355
00:18:41,080 --> 00:18:42,426
Ja see oli speller.

356
00:18:42,426 --> 00:18:47,830
>> [Muusika mängib]