1
00:00:00,000 --> 00:00:12,350
>> [音樂播放]

2
00:00:12,350 --> 00:00:13,050
>> ROB BOWDEN：你好。

3
00:00:13,050 --> 00:00:13,640
我搶。

4
00:00:13,640 --> 00:00:16,210
而且我們這個解決方案了。

5
00:00:16,210 --> 00:00:20,070
所以在這裡我們要實現
一個總表。

6
00:00:20,070 --> 00:00:24,090
我們看到，我們的結構節點
表是要這個樣子。

7
00:00:24,090 --> 00:00:28,710
因此，這將有一個char字
數組大小長度+ 1。

8
00:00:28,710 --> 00:00:32,259
不要忘了+1，因為最大
字在字典中是45

9
00:00:32,259 --> 00:00:33,130
字符。

10
00:00:33,130 --> 00:00:37,070
然後，我們將需要一個額外的
字符反斜杠零。

11
00:00:37,070 --> 00:00:40,870
>> 然後我們在每個哈希表
鬥將要存儲

12
00:00:40,870 --> 00:00:42,320
節點鍊錶。

13
00:00:42,320 --> 00:00:44,420
我們沒有做線性探測在這裡。

14
00:00:44,420 --> 00:00:48,430
所以為了鏈接到下一個
在桶的元素，我們需要一個

15
00:00:48,430 --> 00:00:50,390
結構節點*未來。

16
00:00:50,390 --> 00:00:51,110
確定。

17
00:00:51,110 --> 00:00:53,090
所以，這就是一個節點的樣子。

18
00:00:53,090 --> 00:00:56,180
>> 現在，這裡是聲明
我們的哈希表。

19
00:00:56,180 --> 00:00:59,640
這將有16,834桶。

20
00:00:59,640 --> 00:01:01,910
但這個數字其實並不重要。

21
00:01:01,910 --> 00:01:05,450
最後，我們將有
全局變量哈希表大小，這

22
00:01:05,450 --> 00:01:07,000
會作為零開始。

23
00:01:07,000 --> 00:01:10,760
並且它會跟踪如何
許多詞都在我們的字典。

24
00:01:10,760 --> 00:01:13,710
>> 因此，讓我們來看看負荷。

25
00:01:13,710 --> 00:01:16,390
請注意，負載，它返回一個布爾值。

26
00:01:16,390 --> 00:01:20,530
您將返回true，如果它是成功的
加載，否則返回false。

27
00:01:20,530 --> 00:01:23,990
它需要一個為const char *的字典，
這就是詞典

28
00:01:23,990 --> 00:01:25,280
我們要打開。

29
00:01:25,280 --> 00:01:27,170
所以這是第一件事情
我們要做的。

30
00:01:27,170 --> 00:01:29,500
>> 我們要去給fopen的
字典閱讀。

31
00:01:29,500 --> 00:01:31,680
而我們將不得不作出
確保它成功了。

32
00:01:31,680 --> 00:01:35,920
所以，如果它返回NULL，那麼我們沒有
成功打開詞典。

33
00:01:35,920 --> 00:01:37,440
我們需要返回false。

34
00:01:37,440 --> 00:01:41,580
但假設它確實成功
開放的，那麼我們要讀取的

35
00:01:41,580 --> 00:01:42,400
字典。

36
00:01:42,400 --> 00:01:46,450
因此，保持循環，直到我們找到了一些
理由打破這種循環，

37
00:01:46,450 --> 00:01:47,570
我們將拭目以待。

38
00:01:47,570 --> 00:01:48,920
因此，保持循環。

39
00:01:48,920 --> 00:01:51,780
>> 現在我們要
malloc的一個節點。

40
00:01:51,780 --> 00:01:54,020
，當然，我們需要
宣揚再次檢查。

41
00:01:54,020 --> 00:01:58,680
所以，如果mallocing沒有成功，那麼
我們要卸載的任何節點，我們

42
00:01:58,680 --> 00:02:02,590
碰巧的malloc之前，請關閉
字典和返回false。

43
00:02:02,590 --> 00:02:06,830
但是忽略了，假設我們
成功了，那麼我們要使用的fscanf

44
00:02:06,830 --> 00:02:12,400
從讀一個字我們
字典到我們的節點。

45
00:02:12,400 --> 00:02:17,940
所以請記住該條目>字是字符
大小茸，加1字緩衝區

46
00:02:17,940 --> 00:02:20,300
那我們要存儲的單詞英寸

47
00:02:20,300 --> 00:02:25,070
>> 所以的fscanf會返回1，只要
因為它能夠成功地

48
00:02:25,070 --> 00:02:26,750
從文件中讀一個字。

49
00:02:26,750 --> 00:02:30,460
如果任何一個錯誤發生，或者我們
到達文件的結尾，它

50
00:02:30,460 --> 00:02:31,950
將不會返回1。

51
00:02:31,950 --> 00:02:35,180
在這種情況下，它不會返回1，
我們終於要擺脫

52
00:02:35,180 --> 00:02:37,280
這個while循環。

53
00:02:37,280 --> 00:02:42,770
所以我們看到，一旦我們成功
讀一個字到

54
00:02:42,770 --> 00:02:48,270
入門>字，那麼我們也要去那
詞使用我們的哈希函數。

55
00:02:48,270 --> 00:02:49,580
>> 讓我們來看看
散列函數。

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

57
00:02:52,430 --> 00:02:55,610
所以，你並不真的需要
要理解這一點。

58
00:02:55,610 --> 00:02:59,460
而實際上我們只是拉著這個散列
從互聯網上起作用。

59
00:02:59,460 --> 00:03:04,010
你需要認識到的唯一一件事就是
這需要為const char *字。

60
00:03:04,010 --> 00:03:08,960
所以它採取一個字符串作為輸入，並
返回一個unsigned int作為輸出。

61
00:03:08,960 --> 00:03:12,360
所以這就是所有的散列函數，它是
需要在輸入和給你一個

62
00:03:12,360 --> 00:03:14,490
索引的哈希表。

63
00:03:14,490 --> 00:03:18,530
>> 請注意，我們被NUM_BUCKETS模變，
使返回值

64
00:03:18,530 --> 00:03:21,730
實際上是一個索引哈希表
並沒有索引超出了

65
00:03:21,730 --> 00:03:24,320
陣列的界限。

66
00:03:24,320 --> 00:03:28,060
所以，有了該功能，我們將
散列，我們讀單詞

67
00:03:28,060 --> 00:03:29,390
字典。

68
00:03:29,390 --> 00:03:31,700
然後我們將使用
散列插入

69
00:03:31,700 --> 00:03:33,750
進入哈希表。

70
00:03:33,750 --> 00:03:38,520
>> 現在，哈希表散列是當前
鏈接表列表中。

71
00:03:38,520 --> 00:03:41,410
而且它很可能
它只是為NULL。

72
00:03:41,410 --> 00:03:44,960
我們要插入我們在入口
開始這個鍊錶中。

73
00:03:44,960 --> 00:03:48,600
所以我們就要有我們目前的
切入點是什麼哈希表

74
00:03:48,600 --> 00:03:50,380
目前指向。

75
00:03:50,380 --> 00:03:53,310
然後我們要保存，
在哈希表在

76
00:03:53,310 --> 00:03:55,350
哈希，當前條目。

77
00:03:55,350 --> 00:03:59,320
所以，這兩條線插入成功
在本月初的入口

78
00:03:59,320 --> 00:04:02,260
鍊錶的索引處
在哈希表。

79
00:04:02,260 --> 00:04:04,900
>> 一旦我們與該做的，我們知道
我們發現了另一個字的

80
00:04:04,900 --> 00:04:07,790
字典，我們增加了。

81
00:04:07,790 --> 00:04:13,960
因此，我們繼續這樣做，直到的fscanf
最後在返回的東西非1

82
00:04:13,960 --> 00:04:16,950
這一點請記住，
我們需要自由進入。

83
00:04:16,950 --> 00:04:19,459
所以，在這裡我們malloced一個條目。

84
00:04:19,459 --> 00:04:21,329
我們試著讀的東西
從字典。

85
00:04:21,329 --> 00:04:23,910
我們沒有成功地讀
東西從字典中，在

86
00:04:23,910 --> 00:04:26,650
我們需要釋放進入這種情況下，
我們從來沒有真正投入

87
00:04:26,650 --> 00:04:29,140
哈希表，並最終破裂。

88
00:04:29,140 --> 00:04:32,750
>> 一旦我們突破了，我們需要看到的，好了，
我們沒有打出來，因為有

89
00:04:32,750 --> 00:04:34,360
從文件中讀取的錯誤？

90
00:04:34,360 --> 00:04:37,120
還是我們打出來，因為我們
到達文件的末尾？

91
00:04:37,120 --> 00:04:39,480
如果有錯誤，則
我們要返回false。

92
00:04:39,480 --> 00:04:40,930
由於負載沒有成功。

93
00:04:40,930 --> 00:04:43,890
而在這個過程中，我們要卸載
所有我們在閱讀的話，

94
00:04:43,890 --> 00:04:45,670
關閉字典文件。

95
00:04:45,670 --> 00:04:48,740
>> 假設我們沒有成功，那麼我們就
仍然需要關閉字典

96
00:04:48,740 --> 00:04:53,040
文件，最後返回true，因為我們
成功加載字典。

97
00:04:53,040 --> 00:04:54,420
這就是它的負載。

98
00:04:54,420 --> 00:04:59,020
所以，現在檢查，給定一個哈希表裝，
是要這個樣子。

99
00:04:59,020 --> 00:05:03,140
因此，檢查，它返回一個布爾值，它是
將指示是否通過

100
00:05:03,140 --> 00:05:07,530
以char *的話，是否通過
字符串是在我們的字典。

101
00:05:07,530 --> 00:05:09,890
因此，如果它是在字典中，
如果是在我們的哈希表中，

102
00:05:09,890 --> 00:05:11,170
我們將返回true。

103
00:05:11,170 --> 00:05:13,380
如果不是的話，我們將返回false。

104
00:05:13,380 --> 00:05:17,740
>> 鑑於這種通過在Word中，我們
要哈希的話。

105
00:05:17,740 --> 00:05:22,110
現在認識到的重要一點是
在負載，我​​們知道，所有的

106
00:05:22,110 --> 00:05:23,820
也就是說，我們要為小寫。

107
00:05:23,820 --> 00:05:25,820
但在這裡，我們不是那麼肯定。

108
00:05:25,820 --> 00:05:29,510
如果我們看一看我們的哈希函數，
我們的哈希函數實際上

109
00:05:29,510 --> 00:05:32,700
是下殼體的每個字符
的話。

110
00:05:32,700 --> 00:05:37,940
所以不管資本化
總之，我們的哈希函數是返回

111
00:05:37,940 --> 00:05:42,270
同樣的指數無論
資本化，因為這將有

112
00:05:42,270 --> 00:05:45,280
返回一個完全小寫
版的字。

113
00:05:45,280 --> 00:05:46,600
好吧。

114
00:05:46,600 --> 00:05:49,790
這是我們的指數進入
哈希表這個詞。

115
00:05:49,790 --> 00:05:52,940
>> 現在，這個for循環是要
遍歷鍊錶

116
00:05:52,940 --> 00:05:55,000
這是該索引。

117
00:05:55,000 --> 00:05:59,610
所以請注意，我們初始化入口
指向該索引。

118
00:05:59,610 --> 00:06:02,750
我們將繼續
而進入！= NULL。

119
00:06:02,750 --> 00:06:07,770
請記住，更新指針
在我們的鏈接列表條目=項目>未來。

120
00:06:07,770 --> 00:06:14,400
因此，有我們目前的切入點
在鍊錶中的下一個項目。

121
00:06:14,400 --> 00:06:19,250
>> 因此，對於在該鏈接的表的每個條目，
我們將使用strcasecmp。

122
00:06:19,250 --> 00:06:20,330
這不是STRCOMP。

123
00:06:20,330 --> 00:06:23,780
因為再次，我們要
做事不區別大小寫。

124
00:06:23,780 --> 00:06:27,870
因此我們使用strcasecmp比較
這是通過這個詞通過

125
00:06:27,870 --> 00:06:31,860
對詞功能
那就是在這個條目。

126
00:06:31,860 --> 00:06:35,570
如果返回零，這意味著有
一個匹配，在這種情況下，我們希望

127
00:06:35,570 --> 00:06:36,630
返回true。

128
00:06:36,630 --> 00:06:39,590
我們成功地找到了
字在我們的哈希表。

129
00:06:39,590 --> 00:06:43,040
>> 如果有不匹配，那麼我們
再次要循環，並期待在

130
00:06:43,040 --> 00:06:43,990
下一個條目。

131
00:06:43,990 --> 00:06:47,640
我們將繼續循環，同時有
在此鍊錶條目。

132
00:06:47,640 --> 00:06:50,160
如果我們分手會發生什麼
出這個for循環？

133
00:06:50,160 --> 00:06:55,110
這意味著我們沒有發現一個條目，
匹配這個詞，在這種情況下，

134
00:06:55,110 --> 00:07:00,220
我們返回false，表明我們的
哈希表中沒有包含這個詞。

135
00:07:00,220 --> 00:07:02,540
，這是一個檢查。

136
00:07:02,540 --> 00:07:04,790
>> 因此，讓我們來看看大小。

137
00:07:04,790 --> 00:07:06,970
現在，大小將是非常簡單的。

138
00:07:06,970 --> 00:07:11,080
因為記得在負載，每個字
我們發現，我們增加一個全球性的

139
00:07:11,080 --> 00:07:12,880
可變的哈希表大小。

140
00:07:12,880 --> 00:07:16,480
因此，大小功能只是去
返回全局變量。

141
00:07:16,480 --> 00:07:18,150
就是這樣。

142
00:07:18,150 --> 00:07:22,300
>> 現在，終於，我們需要卸載
字典曾經的一切的完成。

143
00:07:22,300 --> 00:07:25,340
那麼我們如何做到這一點？

144
00:07:25,340 --> 00:07:30,440
在這裡我們要遍歷
本表的所有桶。

145
00:07:30,440 --> 00:07:33,240
因此，有NUM_BUCKETS桶。

146
00:07:33,240 --> 00:07:37,410
並為每個鍊錶我們
哈希表，我們將遍歷

147
00:07:37,410 --> 00:07:41,070
該鏈接的表的全部，
釋放每個元素。

148
00:07:41,070 --> 00:07:42,900
>> 現在，我們必須要小心。

149
00:07:42,900 --> 00:07:47,910
所以在這裡，我們有一個臨時變量
這是存儲指針指向下一個

150
00:07:47,910 --> 00:07:49,730
元件中的鍊錶。

151
00:07:49,730 --> 00:07:52,140
然後我們將免費
當前元素。

152
00:07:52,140 --> 00:07:55,990
我們需要確保我們做到這一點，因為我們
不能只釋放當前元素

153
00:07:55,990 --> 00:07:59,180
然後再試著訪問下一個指針，
因為一旦我們釋放它，

154
00:07:59,180 --> 00:08:00,870
內存變為無效。

155
00:08:00,870 --> 00:08:04,990
>> 因此，我們需要保持周圍的指針
下一個元素，那麼我們就可以釋放

156
00:08:04,990 --> 00:08:08,360
當前元素，然後我們就可以更新
我們目前的元素指向

157
00:08:08,360 --> 00:08:09,550
下一個元素。

158
00:08:09,550 --> 00:08:12,800
我們將循環而有元素
在此鍊錶。

159
00:08:12,800 --> 00:08:15,620
我們將做到這一點的所有鏈接
在哈希表中列出。

160
00:08:15,620 --> 00:08:19,460
有一次，我們正在與該做的，我們已經
完全卸載的哈希表，並

161
00:08:19,460 --> 00:08:20,190
我們就大功告成了。

162
00:08:20,190 --> 00:08:23,200
所以這是不可能的卸載
永遠返回false。

163
00:08:23,200 --> 00:08:26,470
而當我們完成後，我們
剛剛返回true。

164
00:08:26,470 --> 00:08:29,000
>> 讓我們給這個方案一試。

165
00:08:29,000 --> 00:08:33,070
因此，讓我們來看看我們什麼
結構節點的樣子。

166
00:08:33,070 --> 00:08:36,220
在這裡，我們看到，我們就要有一個bool
字和一個結構節點*兒童

167
00:08:36,220 --> 00:08:37,470
支架字母。

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

169
00:08:38,929 --> 00:08:42,020
所以，你可能是第一件事情
想知道，為什麼是字母

170
00:08:42,020 --> 00:08:44,660
編輯定義為27？

171
00:08:44,660 --> 00:08:47,900
好了，記住，我們將需要
待處理的單引號。

172
00:08:47,900 --> 00:08:51,910
所以這將是有點的
整個程序中的特殊情況。

173
00:08:51,910 --> 00:08:54,710
>> 現在還記得如何在特里
實際工作。

174
00:08:54,710 --> 00:08:59,380
比方說，我們正在索引字
“貓”。然後從字典樹的根，

175
00:08:59,380 --> 00:09:02,610
我們要看看孩子
數組，我們要看看

176
00:09:02,610 --> 00:09:08,090
對應於字母索引
C.這樣會被索引2。

177
00:09:08,090 --> 00:09:11,530
因此考慮到，那將
給我們一個新的節點。

178
00:09:11,530 --> 00:09:13,820
然後我們將努力從該節點。

179
00:09:13,820 --> 00:09:17,770
>> 所以，有了這個節點，我們再次
去看看孩子們的數組。

180
00:09:17,770 --> 00:09:22,110
而且我們要看看指數為零
對應於貓在A。

181
00:09:22,110 --> 00:09:27,170
這樣的話，我們會去到該節點，
並給予該節點我們將

182
00:09:27,170 --> 00:09:31,090
來看看它到底是一個對應
到T和移動到該節點，

183
00:09:31,090 --> 00:09:35,530
最後，我們已經完全看
通過我們的詞“貓”。現在bool的

184
00:09:35,530 --> 00:09:40,960
單詞應該以指示是否
這個給定的字實際上是一個字。

185
00:09:40,960 --> 00:09:43,470
>> 那麼，為什麼我們需要這種特殊情況？

186
00:09:43,470 --> 00:09:47,700
什麼樣的詞以及“災難”
是在我們的字典，但

187
00:09:47,700 --> 00:09:50,150
單詞“貓”是不是？

188
00:09:50,150 --> 00:09:54,580
所以，看，看單詞“貓”
在我們的字典，我們

189
00:09:54,580 --> 00:09:59,970
要成功地去翻
該指數C-A-T的區域節點。

190
00:09:59,970 --> 00:10:04,290
但是，這僅僅是因為災難
發生在其上創建節點的方法

191
00:10:04,290 --> 00:10:07,190
從C-A-T，一路
字的結尾。

192
00:10:07,190 --> 00:10:12,020
所以布爾字被用來指示是否
這個特殊的位置

193
00:10:12,020 --> 00:10:14,310
實際上表示一個字。

194
00:10:14,310 --> 00:10:15,140
>> 好的。

195
00:10:15,140 --> 00:10:19,310
所以，現在我們知道它特里是什麼
會是什麼樣子，讓我們來看看

196
00:10:19,310 --> 00:10:20,730
加載功能。

197
00:10:20,730 --> 00:10:24,610
因此，負載將會返回一個bool
對於我們是否成功

198
00:10:24,610 --> 00:10:26,720
不成功地加載的字典。

199
00:10:26,720 --> 00:10:30,460
這將是字典
我們要加載。

200
00:10:30,460 --> 00:10:33,930
>> 我們是這樣做的第一件事就是打開
了那本詞典閱讀。

201
00:10:33,930 --> 00:10:36,160
我們必須確保
我們沒有失敗。

202
00:10:36,160 --> 00:10:39,580
因此，如果在字典不
成功打開，它將返回

203
00:10:39,580 --> 00:10:42,400
null，在這種情況下，我們
要返回false。

204
00:10:42,400 --> 00:10:47,230
但假設它成功
開了，那麼我們就可以真正閱讀

205
00:10:47,230 --> 00:10:48,220
通過字典。

206
00:10:48,220 --> 00:10:50,880
>> 我們將這樣的第一件事
想要做的是我們有這個

207
00:10:50,880 --> 00:10:52,500
全局變量的根。

208
00:10:52,500 --> 00:10:56,190
現在根將是一個節點*。

209
00:10:56,190 --> 00:10:59,760
這是我們的字典樹的頂部，我們是
將要逐一查看。

210
00:10:59,760 --> 00:11:02,660
所以我們要去的第一件事
想要做的是分配

211
00:11:02,660 --> 00:11:04,140
內存為我們的根。

212
00:11:04,140 --> 00:11:07,980
請注意，我們使用了釋放calloc
功能，這是基本相同

213
00:11:07,980 --> 00:11:11,500
作為malloc函數，除了它的
保證返回的東西是

214
00:11:11,500 --> 00:11:13,180
完全歸零。

215
00:11:13,180 --> 00:11:17,290
因此，如果我們使用的malloc，我們需要
通過所有的指針我們

216
00:11:17,290 --> 00:11:20,160
節點，並確保
它們都是空。

217
00:11:20,160 --> 00:11:22,710
所以釋放calloc會替我們。

218
00:11:22,710 --> 00:11:26,330
>> 現在，就像malloc的，我們需要做
確保分配竟是

219
00:11:26,330 --> 00:11:27,520
成功的。

220
00:11:27,520 --> 00:11:29,990
如果返回null，那麼我們
需要關閉或字典

221
00:11:29,990 --> 00:11:32,100
文件並返回false。

222
00:11:32,100 --> 00:11:36,835
所以，假設分配是
成功，我們將使用一個節點*

223
00:11:36,835 --> 00:11:40,270
游標遍歷我們的線索。

224
00:11:40,270 --> 00:11:43,890
所以，我們的根永遠不會改變，
但我們要使用光標

225
00:11:43,890 --> 00:11:47,875
實際上去從一個節點到另一個節點。

226
00:11:47,875 --> 00:11:50,940
>> 因此，在這個for循環，我們正在閱讀
通過字典文件。

227
00:11:50,940 --> 00:11:53,670
而我們使用的是龜etc。

228
00:11:53,670 --> 00:11:56,290
龜etc是要搶單
字符從該文件。

229
00:11:56,290 --> 00:11:59,370
我們要繼續抓
雖然我們不到達的字符

230
00:11:59,370 --> 00:12:01,570
該文件的末尾。

231
00:12:01,570 --> 00:12:03,480
>> 有兩種情況，我們需要處理。

232
00:12:03,480 --> 00:12:06,610
第一，如果字符
是不是一個新行。

233
00:12:06,610 --> 00:12:10,450
所以我們知道，如果它是一個新行，然後
我們即將進入到一個新詞。

234
00:12:10,450 --> 00:12:15,240
但假設它不是一個新行，然後
在這裡，我們想弄清楚的

235
00:12:15,240 --> 00:12:18,380
指數我們要索引
在孩子陣列

236
00:12:18,380 --> 00:12:19,810
我們看著面前。

237
00:12:19,810 --> 00:12:23,880
>> 所以，就像我之前說的，我們需要
特殊情況下的單引號。

238
00:12:23,880 --> 00:12:26,220
我們正在使用的三元通知
運營商在這裡。

239
00:12:26,220 --> 00:12:29,580
所以，我們要讀這個，因為如果
我們讀到的字符是一個

240
00:12:29,580 --> 00:12:35,330
單引號，那麼我們要設置
指數=“字母”-1，這將

241
00:12:35,330 --> 00:12:37,680
是該指數26。

242
00:12:37,680 --> 00:12:41,130
>> 否則，如果它不是一個單引號，有
我們要設置索引

243
00:12:41,130 --> 00:12:43,760
等於c  - 一個。

244
00:12:43,760 --> 00:12:49,030
所以請記住先前對套回，
C  - 一個是要給我們

245
00:12:49,030 --> 00:12:53,410
C的英文字母位置所以，如果
C是字母A，這將

246
00:12:53,410 --> 00:12:54,700
給我們指數為零。

247
00:12:54,700 --> 00:12:58,120
對於字母B，它會給
我們的索引1，依此類推。

248
00:12:58,120 --> 00:13:03,010
>> 因此，這給了我們中的索引
兒童陣列，我們想要的。

249
00:13:03,010 --> 00:13:08,890
現在，如果該指數是目前在空
子，這意味著，一個節點

250
00:13:08,890 --> 00:13:11,830
目前不存在
從該路徑。

251
00:13:11,830 --> 00:13:15,160
因此，我們需要分配
一個節點的路徑。

252
00:13:15,160 --> 00:13:16,550
這就是我們在這裡做的。

253
00:13:16,550 --> 00:13:20,690
>> 所以，我們要再次使用釋放calloc
功能，這樣我們就不必

254
00:13:20,690 --> 00:13:22,880
零出所有的指針。

255
00:13:22,880 --> 00:13:27,240
而我們又需要檢查
這釋放calloc沒有失敗。

256
00:13:27,240 --> 00:13:30,700
如果釋放calloc會失敗，那麼我們就需要
卸載一切，我們關閉

257
00:13:30,700 --> 00:13:32,820
字典，並返回false。

258
00:13:32,820 --> 00:13:40,050
因此，假如它沒有出現故障，則
這將創建一個新的子我們。

259
00:13:40,050 --> 00:13:41,930
然後我們會去那個孩子。

260
00:13:41,930 --> 00:13:44,960
我們的光標會遍歷
下到那個孩子。

261
00:13:44,960 --> 00:13:49,330
>> 現在，如果這不是空，首先，
然後將光標可以只遍歷

262
00:13:49,330 --> 00:13:52,590
下到那個孩子沒有實際
不必分配任何東西。

263
00:13:52,590 --> 00:13:56,730
這是我們第一次發生的情況
分配單詞“貓”。和

264
00:13:56,730 --> 00:14:00,330
這意味著當我們去分配
“大災難”，我們並不需要創建

265
00:14:00,330 --> 00:14:01,680
再次為C-A-T的節點。

266
00:14:01,680 --> 00:14:04,830
它們已經存在。

267
00:14:04,830 --> 00:14:06,080
>> 這是什麼東西？

268
00:14:06,080 --> 00:14:10,480
這是其中c是條件
反斜杠N，其中c是一個新行。

269
00:14:10,480 --> 00:14:13,710
這意味著我們已經成功
完成了一個字。

270
00:14:13,710 --> 00:14:16,860
現在，我們究竟想要做的，當我們
成功地完成了一個字？

271
00:14:16,860 --> 00:14:21,100
我們將用這個詞場
我們的內部結構的節點。

272
00:14:21,100 --> 00:14:23,390
我們要設置為true。

273
00:14:23,390 --> 00:14:27,150
以便表明該節點
表示成功

274
00:14:27,150 --> 00:14:29,250
一句話，一個實際的單詞。

275
00:14:29,250 --> 00:14:30,940
>> 現在設置為true。

276
00:14:30,940 --> 00:14:35,150
我們要重設我們的光標點
在特里的開始了。

277
00:14:35,150 --> 00:14:40,160
最後，增加我們的字典
大小，因為我們發現了另一個工作。

278
00:14:40,160 --> 00:14:43,230
所以，我們要繼續這樣做，
在讀取一個字符一個字符，

279
00:14:43,230 --> 00:14:49,150
構建新的節點在我們的線索和
每個字在字典中，直到

280
00:14:49,150 --> 00:14:54,020
我們終於到達C！= EOF，其中
情況下，我們打出來的文件。

281
00:14:54,020 --> 00:14:57,050
>> 現在有下2箱子
我們可能EOF打擊。

282
00:14:57,050 --> 00:15:00,980
如果有錯誤，首先是
讀取該文件。

283
00:15:00,980 --> 00:15:03,470
所以，如果有錯誤，我們
需要做的典型。

284
00:15:03,470 --> 00:15:06,460
卸載一切，接近
該文件，返回false。

285
00:15:06,460 --> 00:15:09,810
假設沒有了一個錯誤，該
只是意味著我們實際上打的結尾

286
00:15:09,810 --> 00:15:13,750
的文件，在這種情況下，我們關閉
文件，並返回true，因為我們

287
00:15:13,750 --> 00:15:17,330
成功載入字典
進入我們的線索。

288
00:15:17,330 --> 00:15:20,170
>> 所以，現在讓我們看看檢查。

289
00:15:20,170 --> 00:15:25,156
縱觀檢查功能，我們看到
該檢查將要返回一個bool。

290
00:15:25,156 --> 00:15:29,680
如果這個詞，它是返回true
傳遞是在我們的線索。

291
00:15:29,680 --> 00:15:32,110
它，否則返回false。

292
00:15:32,110 --> 00:15:36,050
那麼你是如何判斷是否
這個詞在我們的線索？

293
00:15:36,050 --> 00:15:40,190
>> 我們在這裡看到的是，就像以前一樣，
我們將使用游標來遍歷

294
00:15:40,190 --> 00:15:41,970
通過我們的線索。

295
00:15:41,970 --> 00:15:46,600
現在，在這裡我們要遍歷
在我們的整個字。

296
00:15:46,600 --> 00:15:50,620
因此，迭代，我們過去的話，
我們要確定

297
00:15:50,620 --> 00:15:56,400
索引的兒童陣列
對應詞支架一所以這

298
00:15:56,400 --> 00:15:59,670
是要完全一樣
負載，其中，如果字[I]

299
00:15:59,670 --> 00:16:03,310
是一個撇號，然後我們想
使用索引“字母” -  1。

300
00:16:03,310 --> 00:16:05,350
因為我們確定了
就是我們要去的地方來存儲

301
00:16:05,350 --> 00:16:07,100
單引號。

302
00:16:07,100 --> 00:16:11,780
>> 否則我們將使用兩個低字
支架一，因此請記住一句話就可以

303
00:16:11,780 --> 00:16:13,920
具有任意大小寫。

304
00:16:13,920 --> 00:16:17,540
所以我們要確保我們
用一個事物的小寫版本。

305
00:16:17,540 --> 00:16:21,920
然後從'a'到一次減
再次給我們按字母順序排列

306
00:16:21,920 --> 00:16:23,880
該字符的位置。

307
00:16:23,880 --> 00:16:27,680
所以這將是我們的索引
進入孩子們的數組。

308
00:16:27,680 --> 00:16:32,420
>> 而現在，如果該索引到孩子
數組為null，這意味著我們

309
00:16:32,420 --> 00:16:34,990
不能再繼續迭代
下來我們的線索。

310
00:16:34,990 --> 00:16:38,870
如果是這樣的話，這個詞不能
可能是在我們的線索。

311
00:16:38,870 --> 00:16:42,340
因為如果它是，這將
意味著將有一個路徑

312
00:16:42,340 --> 00:16:43,510
下到這個詞。

313
00:16:43,510 --> 00:16:45,290
而你永遠不會遇到空。

314
00:16:45,290 --> 00:16:47,850
所以遇到空，返回false。

315
00:16:47,850 --> 00:16:49,840
的字不在字典中。

316
00:16:49,840 --> 00:16:53,660
如果它不為null，那麼我們
要繼續迭代。

317
00:16:53,660 --> 00:16:57,220
>> 所以我們要在那裡光標
以指向特定的

318
00:16:57,220 --> 00:16:59,760
節點的索引處。

319
00:16:59,760 --> 00:17:03,150
我們繼續在整個這樣做
整個單詞，假設

320
00:17:03,150 --> 00:17:03,950
我們從不打空。

321
00:17:03,950 --> 00:17:07,220
這意味著我們能夠獲得通過
整個單詞並找到

322
00:17:07,220 --> 00:17:08,920
在我們的嘗試的一個節點。

323
00:17:08,920 --> 00:17:10,770
但我們還沒有完全完成。

324
00:17:10,770 --> 00:17:12,290
>> 我們不希望只是返回true。

325
00:17:12,290 --> 00:17:14,770
我們要返回游標>字。

326
00:17:14,770 --> 00:17:18,980
由於再次記住，是“貓”不
在我們的字典，和“大災難”

327
00:17:18,980 --> 00:17:22,935
，那麼我們會成功，我們得到
通過字“貓”。但光標

328
00:17:22,935 --> 00:17:25,760
字會是假的，而不是真實的。

329
00:17:25,760 --> 00:17:30,930
所以我們返回游標字來表示
是否該節點實際上是一個字。

330
00:17:30,930 --> 00:17:32,470
就是這樣的檢查。

331
00:17:32,470 --> 00:17:34,250
>> 因此，讓我們看看大小。

332
00:17:34,250 --> 00:17:37,350
所以，大小將是很容易
因為，記得在負載，我​​們

333
00:17:37,350 --> 00:17:41,430
遞增的字典大小
我們遇到的每一個字。

334
00:17:41,430 --> 00:17:45,350
所以，大小只是要
返回字典大小。

335
00:17:45,350 --> 00:17:47,390
就是這樣。

336
00:17:47,390 --> 00:17:50,590
>> 所以最後我們已經卸載。

337
00:17:50,590 --> 00:17:55,100
所以卸載，我們將使用
遞歸函數實際上做

338
00:17:55,100 --> 00:17:56,530
對我們的工作。

339
00:17:56,530 --> 00:17:59,340
因此，我們的功能是要
算得上卸料。

340
00:17:59,340 --> 00:18:01,650
什麼是卸載怎麼辦？

341
00:18:01,650 --> 00:18:06,580
我們在這裡看到的卸料器是要
遍歷所有的兒童在

342
00:18:06,580 --> 00:18:08,410
這個特殊的節點。

343
00:18:08,410 --> 00:18:11,750
和如果該子節點不是
null，那麼我們要

344
00:18:11,750 --> 00:18:13,730
卸的子節點。

345
00:18:13,730 --> 00:18:18,010
>> 因此，這是你遞歸卸載
我們所有的孩子。

346
00:18:18,010 --> 00:18:21,080
一旦我們確定我們的孩子
已經卸載，那麼我們

347
00:18:21,080 --> 00:18:25,210
可以釋放自己，所以
卸載自己。

348
00:18:25,210 --> 00:18:29,460
這將遞歸工作
卸載整個線索。

349
00:18:29,460 --> 00:18:32,850
然後一旦這樣做了，
我們可以只返回true。

350
00:18:32,850 --> 00:18:34,210
卸載不能失敗。

351
00:18:34,210 --> 00:18:35,710
我們只是釋放的東西。

352
00:18:35,710 --> 00:18:38,870
所以一旦我們完成了解放
一切，返回true。

353
00:18:38,870 --> 00:18:40,320
就是這樣。

354
00:18:40,320 --> 00:18:41,080
我的名字是羅布。

355
00:18:41,080 --> 00:18:42,426
這是拼寫檢查。

356
00:18:42,426 --> 00:18:47,830
>> [音樂播放]