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
>> [音乐播放]