1
00:00:00,000 --> 00:00:12,350
>> [MUSIC Playing]

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

3
00:00:13,050 --> 00:00:13,640
Én Rob.

4
00:00:13,640 --> 00:00:16,210
És nézzük ezt a megoldást ki.

5
00:00:16,210 --> 00:00:20,070
Tehát itt fogunk végrehajtani
általános asztalra.

6
00:00:20,070 --> 00:00:24,090
Látjuk, hogy a struktúra csomópont a mi
táblázat fog kinézni, mint ez.

7
00:00:24,090 --> 00:00:28,710
Ezért van, hogy a char szót
tömb mérete hossz + 1.

8
00:00:28,710 --> 00:00:32,259
Ne felejtsd el a + 1, mivel a maximális
szó a szótárban 45

9
00:00:32,259 --> 00:00:33,130
karaktereket.

10
00:00:33,130 --> 00:00:37,070
És akkor mi lesz, hogy szükség van egy extra
karakter a backslash nulla.

11
00:00:37,070 --> 00:00:40,870
>> És akkor a hash tábla minden
vödör fog tárolni a

12
00:00:40,870 --> 00:00:42,320
láncolt lista csomópontok.

13
00:00:42,320 --> 00:00:44,420
Nem tesszük lineáris szondázás itt.

14
00:00:44,420 --> 00:00:48,430
Így annak érdekében, hogy link a következő
elem a vödör, szükségünk van egy

15
00:00:48,430 --> 00:00:50,390
struct node * mellett.

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

17
00:00:51,110 --> 00:00:53,090
Szóval, ez az, amit a csomópont néz ki.

18
00:00:53,090 --> 00:00:56,180
>> Most itt van a nyilatkozat
a mi hash tábla.

19
00:00:56,180 --> 00:00:59,640
Úgy megy, hogy 16.834 vödör.

20
00:00:59,640 --> 00:01:01,910
De ez a szám nem igazán számít.

21
00:01:01,910 --> 00:01:05,450
És végül, mi lesz, hogy a
globális változó hash tábla mérete, ami

22
00:01:05,450 --> 00:01:07,000
fog elindul, mint nulla.

23
00:01:07,000 --> 00:01:10,760
És ez lesz nyomon követni, hogyan
sok szó van a szótár.

24
00:01:10,760 --> 00:01:13,710
>> Szóval vessünk egy pillantást a terhelés.

25
00:01:13,710 --> 00:01:16,390
Figyeljük meg, hogy terhelés, visszatér a bool.

26
00:01:16,390 --> 00:01:20,530
Visszatér igaz, ha sikeresen
betöltött, és hamis egyébként.

27
00:01:20,530 --> 00:01:23,990
És ez tart a const char * szótár,
amely a szótárban

28
00:01:23,990 --> 00:01:25,280
hogy meg akarjuk nyitni.

29
00:01:25,280 --> 00:01:27,170
Tehát ez az első dolog,
fogunk csinálni.

30
00:01:27,170 --> 00:01:29,500
>> Megyünk fopen a
szótár az olvasáshoz.

31
00:01:29,500 --> 00:01:31,680
És mi lesz, hogy, hogy a
arról, hogy ez sikerült.

32
00:01:31,680 --> 00:01:35,920
Tehát, ha vissza NULL, akkor nem
sikeresen nyitott a szótárban.

33
00:01:35,920 --> 00:01:37,440
És meg kell, hogy visszatérjen hamis.

34
00:01:37,440 --> 00:01:41,580
De feltételezve, hogy nem sikerült
nyitva van, akkor szeretnénk olvasni a

35
00:01:41,580 --> 00:01:42,400
szótárban.

36
00:01:42,400 --> 00:01:46,450
Maradjatok hurok amíg nem találunk valami
ok, hogy kitörjön erre a ciklusra,

37
00:01:46,450 --> 00:01:47,570
amely majd meglátjuk.

38
00:01:47,570 --> 00:01:48,920
Maradjatok hurok.

39
00:01:48,920 --> 00:01:51,780
>> És most mi lesz
malloc egy csomópont.

40
00:01:51,780 --> 00:01:54,020
És természetesen szükségünk van
a levegő ellenőrizze újra.

41
00:01:54,020 --> 00:01:58,680
Tehát, ha mallocing nem sikerült, akkor
azt akarjuk, hogy kirak olyan csomópont, hogy mi

42
00:01:58,680 --> 00:02:02,590
történt malloc előtt, zárja be a
szótárt, és vissza hamis.

43
00:02:02,590 --> 00:02:06,830
De figyelmen kívül hagyva, hogy feltételezve, hogy
sikerült, akkor szeretnénk használni fscanf

44
00:02:06,830 --> 00:02:12,400
olvasni egy szót a
szótárt a mi csomópontot.

45
00:02:12,400 --> 00:02:17,940
Úgy emlékszem, hogy a bejegyzés> szó a char
szó buffer méret lenghth + 1

46
00:02:17,940 --> 00:02:20,300
hogy fogjuk tárolni a szó be

47
00:02:20,300 --> 00:02:25,070
>> Tehát fscanf fog visszatérni 1., amennyiben
mint volt képes sikeresen

48
00:02:25,070 --> 00:02:26,750
olvasni egy szót a fájlt.

49
00:02:26,750 --> 00:02:30,460
Ha bármelyik hiba történik, vagy mi
éri el a végén a fájl, akkor

50
00:02:30,460 --> 00:02:31,950
nem tér vissza 1.

51
00:02:31,950 --> 00:02:35,180
Ebben az esetben nem tér vissza 1,
mi végre fog kitörni

52
00:02:35,180 --> 00:02:37,280
ez a while ciklus.

53
00:02:37,280 --> 00:02:42,770
Tehát azt látjuk, hogy ha már sikeresen
olvasni egy szót

54
00:02:42,770 --> 00:02:48,270
entry> szó, akkor fogjuk, hogy
szót a hash függvényt.

55
00:02:48,270 --> 00:02:49,580
>> Vessünk egy pillantást
a hash függvényt.

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

57
00:02:52,430 --> 00:02:55,610
Szóval nem igazán kell
megérteni ezt.

58
00:02:55,610 --> 00:02:59,460
És valójában mi csak húzta ezt a hash
működik az interneten.

59
00:02:59,460 --> 00:03:04,010
Az egyetlen dolog, amit meg kell, hogy ismerje el,
hogy ez eltart egy const char * szót.

60
00:03:04,010 --> 00:03:08,960
Szóval ez, hogy egy string bemenet, és
vissza az unsigned int a kibocsátás.

61
00:03:08,960 --> 00:03:12,360
Szóval ez az egész egy hash funkció, ez
vesz egy bemeneti és ad egy

62
00:03:12,360 --> 00:03:14,490
index a hash tábla.

63
00:03:14,490 --> 00:03:18,530
>> Figyeljük meg, hogy mi Moding által NUM_BUCKETS,
úgy, hogy a visszaadott érték

64
00:03:18,530 --> 00:03:21,730
valójában egy index a hash tábla
és nem indexeli túl

65
00:03:21,730 --> 00:03:24,320
határait a tömb.

66
00:03:24,320 --> 00:03:28,060
Tehát, mivel ezt a funkciót, megyünk
a hash a szót, hogy olvassa el a

67
00:03:28,060 --> 00:03:29,390
szótárban.

68
00:03:29,390 --> 00:03:31,700
És akkor fogjuk használni
hogy a hash beszúrni a

69
00:03:31,700 --> 00:03:33,750
belépés a hash tábla.

70
00:03:33,750 --> 00:03:38,520
>> Most hash tábla hash az aktuális
láncolt lista a táblázatban.

71
00:03:38,520 --> 00:03:41,410
És ez nagyon is lehetséges
hogy ez csak NULL.

72
00:03:41,410 --> 00:03:44,960
Azt szeretné szúrni a belépést a
elején ez a láncolt lista.

73
00:03:44,960 --> 00:03:48,600
És mi lesz, hogy a jelenlegi
belépési pont, amit a hash tábla

74
00:03:48,600 --> 00:03:50,380
Jelenleg mutat.

75
00:03:50,380 --> 00:03:53,310
Aztán megyünk tárolni,
a hash tábla, a

76
00:03:53,310 --> 00:03:55,350
hash, az aktuális bejegyzést.

77
00:03:55,350 --> 00:03:59,320
Tehát ez a két vonal sikeresen be
belépési elején a

78
00:03:59,320 --> 00:04:02,260
láncolt lista az adott index
a hash tábla.

79
00:04:02,260 --> 00:04:04,900
>> Miután végeztünk, hogy mi tudjuk,
hogy talált egy másik szót a

80
00:04:04,900 --> 00:04:07,790
szótár, és növelni újra.

81
00:04:07,790 --> 00:04:13,960
Így csinálom, hogy amíg fscanf
Végre visszatért valami non-1-es

82
00:04:13,960 --> 00:04:16,950
amely pont ne feledje, hogy
meg kell a belépés ingyenes.

83
00:04:16,950 --> 00:04:19,459
Tehát itt van malloced egy bejegyzést.

84
00:04:19,459 --> 00:04:21,329
És próbált olvasni valamit
a szótárban.

85
00:04:21,329 --> 00:04:23,910
És nem sikerült elolvasni
valamit a szótárban, a

86
00:04:23,910 --> 00:04:26,650
az esetben fel kell szabadítanunk a bejegyzést
hogy soha nem tesz a

87
00:04:26,650 --> 00:04:29,140
hash tábla, és végül megtörni.

88
00:04:29,140 --> 00:04:32,750
>> Amint kitörni meg kell látni, nos,
tudtunk kitörni, mert

89
00:04:32,750 --> 00:04:34,360
volt olvasási hiba a fájl?

90
00:04:34,360 --> 00:04:37,120
Vagy mi kitörni, mert
végére ért a fájl?

91
00:04:37,120 --> 00:04:39,480
Ha volt egy hiba, akkor
szeretnénk visszatérni hamis.

92
00:04:39,480 --> 00:04:40,930
Mivel a terhelés nem sikerült.

93
00:04:40,930 --> 00:04:43,890
És ebben a folyamatban szeretnénk, hogy kirak
minden szót, amit olvasott, és

94
00:04:43,890 --> 00:04:45,670
zárja be a szótárban fájlt.

95
00:04:45,670 --> 00:04:48,740
>> Feltéve, hogy nem sikerül, akkor már csak
továbbra is szükség van, hogy lezárja a szótárban

96
00:04:48,740 --> 00:04:53,040
fájlt, és végül visszatér igaz, mert mi
sikeresen betöltötte a szótárban.

97
00:04:53,040 --> 00:04:54,420
És ez a terhelés.

98
00:04:54,420 --> 00:04:59,020
Tehát most ellenőrizni, mivel a betöltött hash tábla,
fog kinézni.

99
00:04:59,020 --> 00:05:03,140
Így ellenőrizni, visszatér a bool, amely
majd arra vonatkozóan, hogy az átadott

100
00:05:03,140 --> 00:05:07,530
A char * szó, hogy az átadott
a string-ben a szótár.

101
00:05:07,530 --> 00:05:09,890
Tehát, ha a szótárban,
ha az a hash tábla,

102
00:05:09,890 --> 00:05:11,170
akkor vissza igaz.

103
00:05:11,170 --> 00:05:13,380
És ha nem, akkor vissza hamis.

104
00:05:13,380 --> 00:05:17,740
>> Mivel ez a telt szót, vagyunk
fogja hash szó.

105
00:05:17,740 --> 00:05:22,110
Most egy fontos dolog, hogy ismerje el,
hogy terhelés tudtuk, hogy az összes

106
00:05:22,110 --> 00:05:23,820
szóval mi lesz kisbetűs.

107
00:05:23,820 --> 00:05:25,820
De itt nem vagyunk olyan biztos.

108
00:05:25,820 --> 00:05:29,510
Ha veszünk egy pillantást a hash függvény
a hash függvény valójában

109
00:05:29,510 --> 00:05:32,700
alacsonyabb burkolat minden karakter
a szó.

110
00:05:32,700 --> 00:05:37,940
Tehát függetlenül attól, hogy a kapitalizációja
szó, a hash függvény visszatérési

111
00:05:37,940 --> 00:05:42,270
azonos index bármilyen
tőkésítés, mivel ez van

112
00:05:42,270 --> 00:05:45,280
visszatért egy teljesen kisbetűs
változata a szó.

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

114
00:05:46,600 --> 00:05:49,790
Ez az index is a
Hash tábla ezt a szót.

115
00:05:49,790 --> 00:05:52,940
>> Most ez a for ciklus fog
végighaladni a láncolt lista

116
00:05:52,940 --> 00:05:55,000
hogy abban az index.

117
00:05:55,000 --> 00:05:59,610
Így észre vagyunk inicializálás bejegyzés
hogy pont, hogy az index.

118
00:05:59,610 --> 00:06:02,750
Megyünk tovább
míg a belépés! = NULL.

119
00:06:02,750 --> 00:06:07,770
És ne feledjük, hogy frissíti a mutató
a mi láncolt lista entry = bejegyzés> mellett.

120
00:06:07,770 --> 00:06:14,400
Tehát van a jelenlegi belépési pont
A következő elem a láncolt lista.

121
00:06:14,400 --> 00:06:19,250
>> Tehát minden bejegyzést a láncolt lista,
fogunk használni strcasecmp.

122
00:06:19,250 --> 00:06:20,330
Ez nem StrComp.

123
00:06:20,330 --> 00:06:23,780
Mert még egyszer, azt akarjuk, hogy
dolgok esetében érzéketlenül.

124
00:06:23,780 --> 00:06:27,870
Így használjuk strcasecmp összehasonlítani a
szó, amit át ezt a

125
00:06:27,870 --> 00:06:31,860
funkció ellen szót
, ami ezt a bejegyzést.

126
00:06:31,860 --> 00:06:35,570
Ha visszatér a nulla, ami azt jelenti, nem volt
a meccs, ebben az esetben szeretnénk

127
00:06:35,570 --> 00:06:36,630
vissza igaz.

128
00:06:36,630 --> 00:06:39,590
Sikeresen megtaláltuk a
szó a mi hash tábla.

129
00:06:39,590 --> 00:06:43,040
>> Ha nem egyezik, akkor vagyunk
fog loop újra, és nézd meg a

130
00:06:43,040 --> 00:06:43,990
következő bejegyzés.

131
00:06:43,990 --> 00:06:47,640
És mi is loop míg
vannak bejegyzések ebben a láncolt lista.

132
00:06:47,640 --> 00:06:50,160
Mi történik, ha szünet
ki ez a for ciklus?

133
00:06:50,160 --> 00:06:55,110
Ez azt jelenti, hogy nem találtunk olyan bejegyzést, amely
párosított ezt a szót, amely esetben

134
00:06:55,110 --> 00:07:00,220
visszatérünk a hamis, jelezve, hogy a
hash tábla nem tartalmazza ezt a szót.

135
00:07:00,220 --> 00:07:02,540
És ez a csekk.

136
00:07:02,540 --> 00:07:04,790
>> Szóval vessünk egy pillantást méretben.

137
00:07:04,790 --> 00:07:06,970
Most méret lesz nagyon egyszerű.

138
00:07:06,970 --> 00:07:11,080
Mivel emlékszem terhelés, minden egyes szó
azt találtuk, hogy növekszik a globális

139
00:07:11,080 --> 00:07:12,880
változó hash tábla méretét.

140
00:07:12,880 --> 00:07:16,480
Tehát a méret funkció csak megy
vissza globális változót.

141
00:07:16,480 --> 00:07:18,150
És ennyi.

142
00:07:18,150 --> 00:07:22,300
>> Most végre, meg kell, hogy kirak az
szótár Amint minden kész.

143
00:07:22,300 --> 00:07:25,340
Szóval, hogyan fogjuk csinálni?

144
00:07:25,340 --> 00:07:30,440
Itt vagyunk loop vége
minden vödör asztalunk.

145
00:07:30,440 --> 00:07:33,240
Tehát vannak NUM_BUCKETS vödör.

146
00:07:33,240 --> 00:07:37,410
És minden egyes láncolt lista a mi
hash tábla, fogunk hurkot

147
00:07:37,410 --> 00:07:41,070
A teljes egészében a láncolt lista,
felszabadítása minden elem.

148
00:07:41,070 --> 00:07:42,900
>> Most arra van szükség, hogy legyen óvatos.

149
00:07:42,900 --> 00:07:47,910
Tehát itt van egy átmeneti változó
ez tárolja a mutató a következő

150
00:07:47,910 --> 00:07:49,730
elem a láncolt lista.

151
00:07:49,730 --> 00:07:52,140
És akkor mi lesz ingyenes
Az aktuális elem.

152
00:07:52,140 --> 00:07:55,990
Meg kell bizonyosodni arról, hogy ezt mivel
Nem lehet csak kiszabadítani az aktuális elem

153
00:07:55,990 --> 00:07:59,180
, majd próbálja meg elérni a következő mutató,
mert egyszer már megszabadította,

154
00:07:59,180 --> 00:08:00,870
A memória érvénytelenné válik.

155
00:08:00,870 --> 00:08:04,990
>> Tehát meg kell tartani körül egy mutatót
A következő elem, akkor mi is szabad a

156
00:08:04,990 --> 00:08:08,360
aktuális elem, és akkor frissíteni
a jelenlegi elem, hogy pont

157
00:08:08,360 --> 00:08:09,550
A következő elem.

158
00:08:09,550 --> 00:08:12,800
Majd loop, míg vannak olyan elemei
ebben a láncolt lista.

159
00:08:12,800 --> 00:08:15,620
Majd, hogy minden kapcsolt
listák a hash tábla.

160
00:08:15,620 --> 00:08:19,460
És ha végeztünk vele, most már
teljesen lemerülni a hash tábla, és a

161
00:08:19,460 --> 00:08:20,190
végeztünk.

162
00:08:20,190 --> 00:08:23,200
Tehát lehetetlen kirak
, hogy valaha is visszatér hamis.

163
00:08:23,200 --> 00:08:26,470
És amikor kész, akkor
csak vissza igaz.

164
00:08:26,470 --> 00:08:29,000
>> Adjunk ez a megoldás egy próbát.

165
00:08:29,000 --> 00:08:33,070
Szóval vessünk egy pillantást, amit a
struct csomópont fog kinézni.

166
00:08:33,070 --> 00:08:36,220
Itt látni fogunk egy bool
szó és egy struct csomópont * gyermekek

167
00:08:36,220 --> 00:08:37,470
konzol ábécét.

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

169
00:08:38,929 --> 00:08:42,020
Tehát az első dolog, amit lehet,
kíváncsi, miért ALPHABET

170
00:08:42,020 --> 00:08:44,660
ed definíció szerint 27?

171
00:08:44,660 --> 00:08:47,900
Nos, ne feledjük, hogy mi lesz szüksége
hogy kezelése az aposztróf.

172
00:08:47,900 --> 00:08:51,910
Annak érdekében, hogy lesz egyfajta
speciális eset az egész program.

173
00:08:51,910 --> 00:08:54,710
>> Ne feledd, hogy a trie
tényleg működik.

174
00:08:54,710 --> 00:08:59,380
Mondjuk mi indexelés szót
"Macskák". Ezután a gyökér trie,

175
00:08:59,380 --> 00:09:02,610
fogunk nézni a gyerekek
tömb, és meg fogjuk nézni a

176
00:09:02,610 --> 00:09:08,090
index, amely megfelel a levél
C. Hogy lesz indexelve 2..

177
00:09:08,090 --> 00:09:11,530
Így tekintettel arra, hogy az akarat
nekünk egy új csomópontot.

178
00:09:11,530 --> 00:09:13,820
És akkor fogunk dolgozni a csomópont.

179
00:09:13,820 --> 00:09:17,770
>> Tehát, mivel a csomópont vagyunk ismét
majd nézd meg a gyerekek tömb.

180
00:09:17,770 --> 00:09:22,110
És meg fogjuk nézni index nulla
hogy megfelelnek az A a macska.

181
00:09:22,110 --> 00:09:27,170
Akkor fogunk menni, hogy a csomópont,
és mivel a csomópont megyünk

182
00:09:27,170 --> 00:09:31,090
hogy nézd meg a végén, hogy ez egy megfelel
T. és áttérnek az, hogy a csomópont,

183
00:09:31,090 --> 00:09:35,530
Végül, már teljesen úgy nézett
a mi szó "cat". És most bool

184
00:09:35,530 --> 00:09:40,960
szó állítólag, hogy jelezze,
ez adott szó valójában egy szót sem.

185
00:09:40,960 --> 00:09:43,470
>> Akkor miért van szükségünk, hogy a különleges eset?

186
00:09:43,470 --> 00:09:47,700
Nos, mi a helyzet a "katasztrófa"
van a szótár, de a

187
00:09:47,700 --> 00:09:50,150
szó "cat", nem?

188
00:09:50,150 --> 00:09:54,580
Így, és keresi, hogy ha a "macska"
van a szótár, vagyunk

189
00:09:54,580 --> 00:09:59,970
majd sikeresen nézze át
Az indexek a C-A-T-csomópont a régióban.

190
00:09:59,970 --> 00:10:04,290
De ez csak azért, mert katasztrófa
történt létrehozása csomópontok az úton

191
00:10:04,290 --> 00:10:07,190
: C-A-T, egészen a
a végén a szót.

192
00:10:07,190 --> 00:10:12,020
Tehát bool szót használják annak jelzésére, hogy
ez adott helyen

193
00:10:12,020 --> 00:10:14,310
valójában azt a szót.

194
00:10:14,310 --> 00:10:15,140
>> Rendben van.

195
00:10:15,140 --> 00:10:19,310
Most, hogy tudjuk, mi az trie az
fog kinézni, nézzük meg a

196
00:10:19,310 --> 00:10:20,730
betölteni funkcióját.

197
00:10:20,730 --> 00:10:24,610
Tehát terhelést fog visszatérni a bool
mert akár sikeresen vagy

198
00:10:24,610 --> 00:10:26,720
sikertelenül betöltött a szótárban.

199
00:10:26,720 --> 00:10:30,460
És ez lesz a szótárban
hogy szeretnénk betölteni.

200
00:10:30,460 --> 00:10:33,930
>> Tehát az első dolog, amit mi a teendő nyitva
fel, hogy a szótár az olvasáshoz.

201
00:10:33,930 --> 00:10:36,160
És meg kell, hogy megbizonyosodjon arról,
nem buktunk.

202
00:10:36,160 --> 00:10:39,580
Tehát, ha a szótár nem
sikeresen kinyitotta, hogy vissza fog térni

203
00:10:39,580 --> 00:10:42,400
null, ebben az esetben mi vagyunk
majd vissza hamis.

204
00:10:42,400 --> 00:10:47,230
De feltételezve, hogy sikeresen
nyitott, akkor lehet olvasni

205
00:10:47,230 --> 00:10:48,220
a szótárban.

206
00:10:48,220 --> 00:10:50,880
>> Tehát az első dolog, amit meg fogunk
akarok, hogy itt van ez a

207
00:10:50,880 --> 00:10:52,500
globális változó gyökér.

208
00:10:52,500 --> 00:10:56,190
Most gyökér lesz egy csomópont *.

209
00:10:56,190 --> 00:10:59,760
Ez a tetején a trie, hogy mi vagyunk
fog iterációjával keresztül.

210
00:10:59,760 --> 00:11:02,660
Tehát az első dolog, hogy megyünk
hogy akarok a kiosztani

211
00:11:02,660 --> 00:11:04,140
memória a gyökér.

212
00:11:04,140 --> 00:11:07,980
Figyeljük meg, hogy mi a calloc
funkció, ami lényegében ugyanaz

213
00:11:07,980 --> 00:11:11,500
a malloc függvény, kivéve, hogy
biztos, hogy vissza valamit, ami

214
00:11:11,500 --> 00:11:13,180
teljesen nullázni ki.

215
00:11:13,180 --> 00:11:17,290
Tehát, ha használják malloc, meg kellene
megy át a mutató a mi

216
00:11:17,290 --> 00:11:20,160
csomópont, és győződjön meg arról, hogy
ők mind null.

217
00:11:20,160 --> 00:11:22,710
Így calloc fog tenni, hogy a számunkra.

218
00:11:22,710 --> 00:11:26,330
>> Most, mint malloc, meg kell, hogy
arról, hogy a kiosztás valójában

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

220
00:11:27,520 --> 00:11:29,990
Ha ez vissza null, akkor
kell zárni vagy szótár

221
00:11:29,990 --> 00:11:32,100
fájlt, és vissza hamis.

222
00:11:32,100 --> 00:11:36,835
Tehát, feltételezve, hogy a kiosztás volt
sikeres, fogunk egy node *

223
00:11:36,835 --> 00:11:40,270
kurzor halad végig a trie.

224
00:11:40,270 --> 00:11:43,890
Így a gyökerei soha nem fog változni,
de fogunk használni kurzort

225
00:11:43,890 --> 00:11:47,875
valóban megy csomópontok közötti.

226
00:11:47,875 --> 00:11:50,940
>> Tehát ez a for ciklus olvasunk
a szótár fájlt.

227
00:11:50,940 --> 00:11:53,670
És mi használ fgetc.

228
00:11:53,670 --> 00:11:56,290
Fgetc fog megragad egy
karaktert a fájlból.

229
00:11:56,290 --> 00:11:59,370
Megyünk is megragadta
karakter, amíg nem éri el a

230
00:11:59,370 --> 00:12:01,570
a fájl végén.

231
00:12:01,570 --> 00:12:03,480
>> Két esetben kell kezelni.

232
00:12:03,480 --> 00:12:06,610
Az első, ha a karakter
nem volt egy új sort.

233
00:12:06,610 --> 00:12:10,450
Tehát tudjuk, hogy ez egy új sort, majd a
vagyunk arról, hogy lépni egy új szót.

234
00:12:10,450 --> 00:12:15,240
De feltételezve, hogy ez nem egy új sort, majd a
Itt szeretnénk kitalálni, hogy a

235
00:12:15,240 --> 00:12:18,380
index fogunk index a
A gyerekek tömb

236
00:12:18,380 --> 00:12:19,810
néztük korábban.

237
00:12:19,810 --> 00:12:23,880
>> Szóval, mint már mondtam, meg kell
speciális eset az aposztróf.

238
00:12:23,880 --> 00:12:26,220
Figyeljük meg, mi a hármas
operátor itt.

239
00:12:26,220 --> 00:12:29,580
Így fogjuk olvasni ezt, ha a
a karakter olvassuk volt

240
00:12:29,580 --> 00:12:35,330
aposztróf, akkor megyünk be
index = "ABC" -1, ami

241
00:12:35,330 --> 00:12:37,680
az index 26.

242
00:12:37,680 --> 00:12:41,130
>> Különben, ha ez nem egy aposztróf, ott
megyünk be az index

243
00:12:41,130 --> 00:12:43,760
egyenlő c - a.

244
00:12:43,760 --> 00:12:49,030
Így emlékszik vissza a korábban p-készletek,
c - a fog adni nekünk a

245
00:12:49,030 --> 00:12:53,410
abc helyzete C. Tehát, ha
C a betű, így nehezebb

246
00:12:53,410 --> 00:12:54,700
nekünk index nulla.

247
00:12:54,700 --> 00:12:58,120
A B betű, ez ad
nekünk az 1-es index, és így tovább.

248
00:12:58,120 --> 00:13:03,010
>> Szóval ez ad nekünk az index a
gyerekek tömb, amit akarunk.

249
00:13:03,010 --> 00:13:08,890
Nos, ha ez a mutató jelenleg null
a gyerekeket, hogy az azt jelenti, hogy egy csomópont

250
00:13:08,890 --> 00:13:11,830
jelenleg nem létezik
erről az útról.

251
00:13:11,830 --> 00:13:15,160
Tehát meg kell kiosztani
a csomópont az úton.

252
00:13:15,160 --> 00:13:16,550
Ez az, amit mi itt csinálni.

253
00:13:16,550 --> 00:13:20,690
>> Így fogjuk újra használni a calloc
funkciót, így nem kell

254
00:13:20,690 --> 00:13:22,880
nulla ki az összes mutató.

255
00:13:22,880 --> 00:13:27,240
És ismét ellenőrizni kell
hogy calloc nem sikerül.

256
00:13:27,240 --> 00:13:30,700
Ha calloc nem sikerül, akkor meg kell
kirak mindent, zárja be a

257
00:13:30,700 --> 00:13:32,820
szótár és a return false.

258
00:13:32,820 --> 00:13:40,050
Tehát, feltételezve, hogy nem sikerül, akkor
Ez létrehoz egy új gyerek számunkra.

259
00:13:40,050 --> 00:13:41,930
És akkor majd megy, hogy a gyermek számára.

260
00:13:41,930 --> 00:13:44,960
A kurzor iterációkhoz
le, hogy a gyermek számára.

261
00:13:44,960 --> 00:13:49,330
>> Nos, ha ez nem null kezdődik,
akkor a kurzor is csak iterációkhoz

262
00:13:49,330 --> 00:13:52,590
le, hogy az a gyerek, anélkül, hogy
kellene kiosztani semmit.

263
00:13:52,590 --> 00:13:56,730
Ez az eset áll fenn, amikor először történt
osztja a "macska". És

264
00:13:56,730 --> 00:14:00,330
azt jelenti, hogy mikor megyünk kiosztani
"Katasztrófa", nem kell létrehozni

265
00:14:00,330 --> 00:14:01,680
csomópontok a C-A-T-újra.

266
00:14:01,680 --> 00:14:04,830
Már léteznek.

267
00:14:04,830 --> 00:14:06,080
>> Mi ez a valami?

268
00:14:06,080 --> 00:14:10,480
Ez az az állapot, ahol c volt
backslash n, ahol c egy új sort.

269
00:14:10,480 --> 00:14:13,710
Ez azt jelenti, hogy sikeresen
elkészült egy szót sem.

270
00:14:13,710 --> 00:14:16,860
Most mit akarunk csinálni, amikor
sikeresen befejezte egy szó?

271
00:14:16,860 --> 00:14:21,100
Fogjuk használni ezt a szót, a területen
belsejében a struct csomópont.

272
00:14:21,100 --> 00:14:23,390
Azt szeretnénk beállítani, hogy igaz.

273
00:14:23,390 --> 00:14:27,150
Tehát, azt jelzi, hogy ez a csomópont
jelzi a sikeres

274
00:14:27,150 --> 00:14:29,250
szó, a tényleges szó.

275
00:14:29,250 --> 00:14:30,940
>> Ezután állítsa be, hogy az igaz.

276
00:14:30,940 --> 00:14:35,150
Azt akarjuk állítani a kurzort a pont
hogy az elején a trie újra.

277
00:14:35,150 --> 00:14:40,160
És végül, növelni a szótár
méret, hiszen talált egy másik munkát.

278
00:14:40,160 --> 00:14:43,230
Így fogjuk tartani csinálja,
olvasás karakterenként,

279
00:14:43,230 --> 00:14:49,150
építése az új csomópont a trie és
minden szót a szótárban, amíg

280
00:14:49,150 --> 00:14:54,020
végül elérjük C! = EOF, amelyben
esetben kitörni a fájlt.

281
00:14:54,020 --> 00:14:57,050
>> Most van két eset alatt
amely talán megüt EOF.

282
00:14:57,050 --> 00:15:00,980
Az első az, ha nem volt hiba
olvasni a fájlból.

283
00:15:00,980 --> 00:15:03,470
Tehát, ha nem volt hiba, akkor
kell tennie a tipikus.

284
00:15:03,470 --> 00:15:06,460
Vegye ki mindent, közel
A fájl, return false.

285
00:15:06,460 --> 00:15:09,810
Feltételezve, hogy nem volt hiba, hogy a
csak azt jelenti, hogy valóban elérje a végén

286
00:15:09,810 --> 00:15:13,750
a fájlt, amely esetben zárjuk a
fájlt, és vissza igaz, mivel

287
00:15:13,750 --> 00:15:17,330
sikeresen betöltve szótár
a mi trie.

288
00:15:17,330 --> 00:15:20,170
>> Most nézzük meg ellenőrzést.

289
00:15:20,170 --> 00:15:25,156
Keresi a check funkció látjuk
hogy ellenőrzés lesz, hogy visszatérjen a bool.

290
00:15:25,156 --> 00:15:29,680
Az igazat ad vissza, ha az a szó, hogy ez az
hogy telt a mi trie.

291
00:15:29,680 --> 00:15:32,110
A HAMIS egyébként.

292
00:15:32,110 --> 00:15:36,050
Szóval, hogy van meghatározni, hogy
ez a szó a mi trie?

293
00:15:36,050 --> 00:15:40,190
>> Látjuk, hogy itt, csakúgy, mint korábban,
fogunk használni kurzor iterációkhoz

294
00:15:40,190 --> 00:15:41,970
keresztül trie.

295
00:15:41,970 --> 00:15:46,600
Most itt fogunk iterációkhoz
mint a teljes szót.

296
00:15:46,600 --> 00:15:50,620
Így az iterációt szót túl vagyunk,
megyünk, hogy meghatározzák a

297
00:15:50,620 --> 00:15:56,400
index a gyerekek tömb
megfelel a szó zárójel I. Tehát ez

298
00:15:56,400 --> 00:15:59,670
fog úgy nézzen ki, mint a
terhelés, ahol, ha szó [i]

299
00:15:59,670 --> 00:16:03,310
van egy aposztróf, akkor szeretnénk
használata index "ABC" - 1.

300
00:16:03,310 --> 00:16:05,350
Mivel megállapítottuk, hogy ez
ahol megyünk tárolni

301
00:16:05,350 --> 00:16:07,100
aposztrófok.

302
00:16:07,100 --> 00:16:11,780
>> Else fogjuk használni a két alsó szó
konzol I. úgy emlékszem, hogy szó

303
00:16:11,780 --> 00:16:13,920
tetszőleges nagybetűk.

304
00:16:13,920 --> 00:16:17,540
És így azt szeretnénk, hogy győződjön meg arról, hogy mi
egy kisbetűs változatát dolgokat.

305
00:16:17,540 --> 00:16:21,920
És akkor a kivonást, hogy az "a", hogy egyszer
Ismét nekünk az alfabetikus

306
00:16:21,920 --> 00:16:23,880
helyzetben, hogy a karakter.

307
00:16:23,880 --> 00:16:27,680
Szóval ez lesz az index
a gyerekek tömbben.

308
00:16:27,680 --> 00:16:32,420
>> És most, ha az index a gyerekek
tömb null, ez azt jelenti,

309
00:16:32,420 --> 00:16:34,990
már nem is iterációjával
le a trie.

310
00:16:34,990 --> 00:16:38,870
Ha ez a helyzet, ez a szó nem
esetleg a mi trie.

311
00:16:38,870 --> 00:16:42,340
Mivel ha ez, amely
azt jelenti, van egy út lenne

312
00:16:42,340 --> 00:16:43,510
le ezt a szót.

313
00:16:43,510 --> 00:16:45,290
És soha nem találkozik null.

314
00:16:45,290 --> 00:16:47,850
Így találkozik null, visszatérünk hamis.

315
00:16:47,850 --> 00:16:49,840
A szó nem szerepel a szótárban.

316
00:16:49,840 --> 00:16:53,660
Ha ez nem nulla, akkor vagyunk
folytatjuk iterációjával.

317
00:16:53,660 --> 00:16:57,220
>> Így fogunk ott kurzor
mutatni, hogy az adott

318
00:16:57,220 --> 00:16:59,760
node abban az index.

319
00:16:59,760 --> 00:17:03,150
Azt csinálom, hogy az egész
a teljes szót, feltételezve, hogy

320
00:17:03,150 --> 00:17:03,950
mi soha nem sújtotta null.

321
00:17:03,950 --> 00:17:07,220
Ez azt jelenti, hogy sikerült átvészelni
a teljes szót és megtalálni

322
00:17:07,220 --> 00:17:08,920
a csomópont a próbát.

323
00:17:08,920 --> 00:17:10,770
De nem egészen kész még.

324
00:17:10,770 --> 00:17:12,290
>> Nem akarjuk, hogy csak vissza igaz.

325
00:17:12,290 --> 00:17:14,770
Azt akarjuk, hogy visszatérjen kurzor> szót.

326
00:17:14,770 --> 00:17:18,980
Mivel emlékszem ismét a "macska" nem
az a szótár, a "katasztrófa"

327
00:17:18,980 --> 00:17:22,935
van, akkor sikeresen kapunk
keresztül a "macska". De a kurzor

328
00:17:22,935 --> 00:17:25,760
szó lesz, hamis és nem igaz.

329
00:17:25,760 --> 00:17:30,930
Így visszatérünk kurzort jelző szót
hogy ez a csomópont valójában egy szót.

330
00:17:30,930 --> 00:17:32,470
És ez a csekk.

331
00:17:32,470 --> 00:17:34,250
>> Szóval nézd meg méretét.

332
00:17:34,250 --> 00:17:37,350
Tehát méretű lesz elég könnyű
mivel emlékszem terhelés, vagyunk

333
00:17:37,350 --> 00:17:41,430
megnő szótár mérete
Minden szó, hogy találkozunk.

334
00:17:41,430 --> 00:17:45,350
Tehát mérete csak fog
vissza szótár méretét.

335
00:17:45,350 --> 00:17:47,390
És ennyi.

336
00:17:47,390 --> 00:17:50,590
>> Így végül már a memóriából.

337
00:17:50,590 --> 00:17:55,100
Tehát kirak, fogunk használni
rekurzív függvény, hogy ténylegesen minden

338
00:17:55,100 --> 00:17:56,530
A munka számunkra.

339
00:17:56,530 --> 00:17:59,340
Így a funkció fog
nevezhetjük a unloader.

340
00:17:59,340 --> 00:18:01,650
Mi unloader fog csinálni?

341
00:18:01,650 --> 00:18:06,580
Látjuk, hogy az ürítés fog
végighaladni mind a gyerekek

342
00:18:06,580 --> 00:18:08,410
az adott csomópont.

343
00:18:08,410 --> 00:18:11,750
És ha a gyermek csomópont nem
null, akkor megyünk

344
00:18:11,750 --> 00:18:13,730
kirak a gyermek csomópont.

345
00:18:13,730 --> 00:18:18,010
>> Tehát ez akkor rekurzív kirak
Minden gyermek.

346
00:18:18,010 --> 00:18:21,080
Ha nem vagyunk biztosak, hogy gyermekeink
kirakodását, akkor

347
00:18:21,080 --> 00:18:25,210
is szabad magunkat, így
kirak magunkat.

348
00:18:25,210 --> 00:18:29,460
Ez a munka rekurzívan
kirak az egész trie.

349
00:18:29,460 --> 00:18:32,850
És ha egyszer ez megtörtént,
mi csak vissza igaz.

350
00:18:32,850 --> 00:18:34,210
Unload nem teheti meg.

351
00:18:34,210 --> 00:18:35,710
Mi csak felszabadítja a dolgokat.

352
00:18:35,710 --> 00:18:38,870
Tehát, ha már kész szabaddá
Mindent vissza igaz.

353
00:18:38,870 --> 00:18:40,320
És ennyi.

354
00:18:40,320 --> 00:18:41,080
A nevem Rob.

355
00:18:41,080 --> 00:18:42,426
És ez volt a helyesírás.

356
00:18:42,426 --> 00:18:47,830
>> [MUSIC Playing]