1
00:00:00,000 --> 00:00:00,530

2
00:00:00,530 --> 00:00:03,070
>> 扬声器1：让我们给
该解决方案一试。

3
00:00:03,070 --> 00:00:07,130
因此，让我们来看看我们什么
结构节点的样子。

4
00:00:07,130 --> 00:00:11,040
在这里，我们看到了我们将有一个
布尔字和一个结构节点明星

5
00:00:11,040 --> 00:00:12,990
儿童括起来的字母。

6
00:00:12,990 --> 00:00:18,720
所以，第一件事情你可能想知道，
为什么字母散列定义为27？

7
00:00:18,720 --> 00:00:22,540
好了，记住，我们将需要
待处理的单引号，所以

8
00:00:22,540 --> 00:00:25,610
这将是一个有点特殊
情况下整个程序。

9
00:00:25,610 --> 00:00:28,780
>> 好了，现在请大家记住一个
特里的实际工作。

10
00:00:28,780 --> 00:00:33,420
比方说，我们正在索引字猫，
然后从我们的Trie树的根，

11
00:00:33,420 --> 00:00:36,670
我们要看看孩子
数组，我们要看看

12
00:00:36,670 --> 00:00:42,250
对应于字母索引
C.因此，这将是指数2。

13
00:00:42,250 --> 00:00:46,400
因此考虑到，这将给予我们
一个新的节点，然后我们将

14
00:00:46,400 --> 00:00:47,880
从该节点工作。

15
00:00:47,880 --> 00:00:51,830
>> 所以，有了这个节点，我们再次
去看看孩子阵列，

16
00:00:51,830 --> 00:00:56,170
而且我们要看看指数为零
对应于猫在A。

17
00:00:56,170 --> 00:01:01,240
这样的话，我们会去到该节点，
并给予该节点，我们要

18
00:01:01,240 --> 00:01:05,170
看对应的索引处
到T和移动到该节点，

19
00:01:05,170 --> 00:01:09,590
最后，我们已经完全看
通过我们的字猫，现在布尔

20
00:01:09,590 --> 00:01:15,020
单词应该表明是否
这个给定的字实际上是一个字。

21
00:01:15,020 --> 00:01:17,530
>> 那么，为什么我们需要这种特殊情况？

22
00:01:17,530 --> 00:01:21,680
那么，如果这个词灾难
在我们的字典，但

23
00:01:21,680 --> 00:01:24,120
字猫是不是？

24
00:01:24,120 --> 00:01:29,030
所以想看看，如果这个词是猫
在我们的字典，我们要

25
00:01:29,030 --> 00:01:34,880
成功地翻阅索引
C-A-T和到达一个节点，但是这

26
00:01:34,880 --> 00:01:39,760
只是因为灾难发生在
从C-A-T的方式创建所有的节点

27
00:01:39,760 --> 00:01:41,250
一直到单词的末尾。

28
00:01:41,250 --> 00:01:46,520
所以布尔字是用来说明是否
这个特殊的位置，实际上

29
00:01:46,520 --> 00:01:48,370
表示一个字。

30
00:01:48,370 --> 00:01:52,920
>> 好了，所以现在我们知道什么是
特里是怎么回事的样子，让我们来看看

31
00:01:52,920 --> 00:01:54,800
在负载功能。

32
00:01:54,800 --> 00:01:58,670
因此，负载将会返回一个布尔
对于我们是否成功

33
00:01:58,670 --> 00:02:03,020
加载失败字典和
这将是字典

34
00:02:03,020 --> 00:02:04,520
我们要加载。

35
00:02:04,520 --> 00:02:08,310
我们将这样做第一件事就是打开
了那本词典阅读。

36
00:02:08,310 --> 00:02:12,060
我们必须确保我们没有失败，
因此，如果在字典不

37
00:02:12,060 --> 00:02:15,280
成功打开，它将返回
不，在这种情况下，我们要

38
00:02:15,280 --> 00:02:16,340
返回False。

39
00:02:16,340 --> 00:02:21,290
但假设它成功
开了，那么我们就可以真正阅读

40
00:02:21,290 --> 00:02:22,310
通过字典。

41
00:02:22,310 --> 00:02:24,940
>> 我们将这样的第一件事
想要做的是我们有这个

42
00:02:24,940 --> 00:02:26,560
全局变量的根。

43
00:02:26,560 --> 00:02:30,250
现在，根将是一个节点明星。

44
00:02:30,250 --> 00:02:33,830
这是我们的Trie树的顶部，我们是
将要逐一查看。

45
00:02:33,830 --> 00:02:38,200
我们会想这样的第一件事
做的是为我们的根分配内存。

46
00:02:38,200 --> 00:02:42,040
>> 请注意，我们使用了释放calloc
功能，这是基本相同

47
00:02:42,040 --> 00:02:45,560
作为malloc函数，除了它的
保证返回的东西是

48
00:02:45,560 --> 00:02:47,240
完全归零。

49
00:02:47,240 --> 00:02:51,350
因此，如果我们使用的malloc，我们需要
通过所有的指针我们

50
00:02:51,350 --> 00:02:54,220
节点，并确保
它们都是空。

51
00:02:54,220 --> 00:02:56,780
所以释放calloc会替我们。

52
00:02:56,780 --> 00:03:00,390
>> 现在，就像malloc的，我们需要做
确保分配实际上

53
00:03:00,390 --> 00:03:01,580
成功的。

54
00:03:01,580 --> 00:03:04,060
如果返回null，那么我们
需要关闭我们的字典

55
00:03:04,060 --> 00:03:06,170
文件并返回False。

56
00:03:06,170 --> 00:03:11,040
因此，假如被分配
成功，我们将使用一个节点

57
00:03:11,040 --> 00:03:14,340
明星游标来遍历
通过我们的特里。

58
00:03:14,340 --> 00:03:17,950
因此，我们的根永远不会改变，
但我们要使用游标来

59
00:03:17,950 --> 00:03:20,770
实际上去从一个节点到另一个节点。

60
00:03:20,770 --> 00:03:25,000
>> 好吧，所以在这个For循环中，我们
通过字典文件读取，

61
00:03:25,000 --> 00:03:26,965
我们正在使用的龟etc。

62
00:03:26,965 --> 00:03:30,360
所以龟etc是要抢单
字符从该文件。

63
00:03:30,360 --> 00:03:33,430
我们要继续抓
虽然我们不到达的字符

64
00:03:33,430 --> 00:03:37,540
该文件的结束，所以有
2箱子我们需要处理。

65
00:03:37,540 --> 00:03:41,640
第一，如果该字符不是
新的生产线，所以我们知道，如果它是一个新的

66
00:03:41,640 --> 00:03:44,480
行，那么我们将要
移动到一个新词。

67
00:03:44,480 --> 00:03:49,300
但假设它不是一个新行，然后
在这里，我们想弄清楚的

68
00:03:49,300 --> 00:03:52,440
指数我们要索引
儿童数组中

69
00:03:52,440 --> 00:03:53,890
我们看着面前。

70
00:03:53,890 --> 00:03:57,950
>> 所以，就像我之前说的，我们需要
特殊情况下的单引号。

71
00:03:57,950 --> 00:04:01,040
我们使用三元运算符通知
在这里，所以我们要读

72
00:04:01,040 --> 00:04:05,500
这好像我们在阅读的字符是
一个单引号，那么我们要

73
00:04:05,500 --> 00:04:11,740
设置索引等于减去字母
1，这将是该指数26。

74
00:04:11,740 --> 00:04:15,190
否则，如果它不是一个单引号，
然后我们要设置索引

75
00:04:15,190 --> 00:04:17,820
等于c减去一个。

76
00:04:17,820 --> 00:04:23,090
所以请记住从以前的p设置回来，
Ç减去一个是要给我们

77
00:04:23,090 --> 00:04:27,470
C的按字母顺序排列的位置，所以如果
c是字母A，这将

78
00:04:27,470 --> 00:04:28,770
给我们指数为零。

79
00:04:28,770 --> 00:04:32,180
对于字母B，它会给
我们的索引1，依此类推。

80
00:04:32,180 --> 00:04:37,070
>> 因此，这给了我们中的索引
儿童阵列，我们想要的。

81
00:04:37,070 --> 00:04:42,540
现在，如果该指数是目前在空
儿童阵列，这意味着

82
00:04:42,540 --> 00:04:47,470
节点当前不存在从
这条道路，所以我们需要分配一个

83
00:04:47,470 --> 00:04:49,220
节点的路径。

84
00:04:49,220 --> 00:04:50,610
这就是我们在这里做的。

85
00:04:50,610 --> 00:04:54,650
所以，我们要再次，使用释放calloc
功能，使我们不必

86
00:04:54,650 --> 00:05:00,130
零出所有的指针，而我们，
再次，需要检查释放calloc

87
00:05:00,130 --> 00:05:01,300
没有失败。

88
00:05:01,300 --> 00:05:04,760
如果释放calloc会失败，那么我们就需要
卸载一切，我们关闭

89
00:05:04,760 --> 00:05:06,880
字典，并返回False。

90
00:05:06,880 --> 00:05:14,110
>> 因此，假如它没有出现故障，则
这为我们创建一个新的子，

91
00:05:14,110 --> 00:05:16,000
然后我们会去那个孩子。

92
00:05:16,000 --> 00:05:19,030
我们的光标会遍历
下到那个孩子。

93
00:05:19,030 --> 00:05:23,390
现在，如果这不是空，首先，
然后将光标可以只遍历

94
00:05:23,390 --> 00:05:26,650
下到那个孩子没有实际
不必分配任何东西。

95
00:05:26,650 --> 00:05:30,790
这是我们第一次发生的情况
分配的字猫，和

96
00:05:30,790 --> 00:05:34,390
这意味着当我们去分配
灾难中，我们并不需要创建

97
00:05:34,390 --> 00:05:35,720
再次为C-A-T的节点。

98
00:05:35,720 --> 00:05:37,620
它们已经存在。

99
00:05:37,620 --> 00:05:40,140
>> 好了，这是什么东西？

100
00:05:40,140 --> 00:05:44,600
这是其中c是条件
反斜杠N，其中c是一个新行。

101
00:05:44,600 --> 00:05:47,780
这意味着我们已经成功
完成了一个字。

102
00:05:47,780 --> 00:05:51,020
现在，我们想要做的，当我们
成功地完成了一个字？

103
00:05:51,020 --> 00:05:55,250
我们将用这个词场
我们的内部结构体的节点。

104
00:05:55,250 --> 00:06:00,570
>> 我们要设置为True，这样，
表明该节点表示一个

105
00:06:00,570 --> 00:06:03,320
成功的话实际字。

106
00:06:03,320 --> 00:06:05,050
现在，设置为True。

107
00:06:05,050 --> 00:06:09,210
我们要重设我们的光标点
在特里的开始了。

108
00:06:09,210 --> 00:06:13,510
最后，增加我们的字典
大小，因为我们发现了另一个字。

109
00:06:13,510 --> 00:06:16,450
>> 好吧，所以我们要继续做
即，通过读取字符

110
00:06:16,450 --> 00:06:21,960
字符，兴建新节点
我们的Trie树和在每个字

111
00:06:21,960 --> 00:06:26,810
字典，直到我们终于到达C
等于EOF，在这种情况下，我们分手吧

112
00:06:26,810 --> 00:06:28,100
出来的文件。

113
00:06:28,100 --> 00:06:31,110
现在，有下2案件
我们可能EOF打击。

114
00:06:31,110 --> 00:06:35,680
如果有错误，首先是
从文件中读取的，所以如果有

115
00:06:35,680 --> 00:06:39,280
的错误，我们需要做的典型
卸载一切，关闭文件，

116
00:06:39,280 --> 00:06:40,520
返回False。

117
00:06:40,520 --> 00:06:43,870
假设没有了一个错误，该
只是意味着我们实际上打的结尾

118
00:06:43,870 --> 00:06:47,820
的文件，在这种情况下，我们关闭
文件，并返回True，因为我们

119
00:06:47,820 --> 00:06:51,010
成功载入字典
进入我们的特里。

120
00:06:51,010 --> 00:06:54,240
>> 好吧，那么现在让我们来
退房入住。

121
00:06:54,240 --> 00:06:58,780
纵观检查功能，我们看到
该检查将要返回一个布尔值。

122
00:06:58,780 --> 00:07:03,740
如果这个词，它是它返回True
传递是在我们的特里。

123
00:07:03,740 --> 00:07:06,170
它，否则返回False。

124
00:07:06,170 --> 00:07:10,110
>> 那么我们如何来判断是否
这个词在我们的特里？

125
00:07:10,110 --> 00:07:14,270
我们在这里看到的是，就像以前一样，
我们将使用游标来遍历

126
00:07:14,270 --> 00:07:16,010
通过我们的特里。

127
00:07:16,010 --> 00:07:20,650
现在，在这里，我们要遍历
在我们的整个字。

128
00:07:20,650 --> 00:07:24,680
所以遍历我们的字
过去了，我们要确定

129
00:07:24,680 --> 00:07:29,280
索引的儿童阵列
对应词支架I。

130
00:07:29,280 --> 00:07:34,150
因此，这是要完全一样
负载，其中，如果字架我是一个

131
00:07:34,150 --> 00:07:38,110
单引号，那么我们要使用索引
字母减去1，因为我们确定

132
00:07:38,110 --> 00:07:41,160
那就是我们要去的地方
存储单引号。

133
00:07:41,160 --> 00:07:44,440
>> 否则我们将要使用的tolower
字架我。

134
00:07:44,440 --> 00:07:48,270
所以请记住这个词可以有任意的
资本化，所以我们

135
00:07:48,270 --> 00:07:51,590
要确保我们使用
一个小写版本的东西。

136
00:07:51,590 --> 00:07:55,300
然后从该小写减
一来，再次给我们

137
00:07:55,300 --> 00:07:57,940
按字母顺序排列的位置
该角色。

138
00:07:57,940 --> 00:08:01,740
所以这将是我们的索引
到儿童阵列。

139
00:08:01,740 --> 00:08:06,480
>> 而现在，如果该索引到儿童
数组为null，这意味着我们

140
00:08:06,480 --> 00:08:09,050
不能再继续迭代
下来我们的特里。

141
00:08:09,050 --> 00:08:13,320
如果是这样的话，这个词不能
可能是在我们的特里，因为如果它

142
00:08:13,320 --> 00:08:18,000
是，这将意味着会有一个
小路下到那个字，你会

143
00:08:18,000 --> 00:08:19,350
从来没有遇到空。

144
00:08:19,350 --> 00:08:21,910
所以遇到空，我们返回False。

145
00:08:21,910 --> 00:08:23,810
的字不在字典中。

146
00:08:23,810 --> 00:08:28,200
如果它不为null，那么我们要
继续迭代，所以我们要

147
00:08:28,200 --> 00:08:33,150
更新我们的光标指向
该指数在特定节点。

148
00:08:33,150 --> 00:08:36,659
>> 因此，我们继续在整个这样做
整个字。

149
00:08:36,659 --> 00:08:40,630
假设我们从来不打空，那手段
我们能够打通整个

150
00:08:40,630 --> 00:08:44,840
世界，发现在我们的特里一个节点，
但我们还没有完全完成。

151
00:08:44,840 --> 00:08:46,350
我们不希望只是返回True。

152
00:08:46,350 --> 00:08:51,400
我们要返回游标错误字
因为，记得再次，如果猫是不是

153
00:08:51,400 --> 00:08:55,140
在我们的字典和灾难是，
那么我们将成功打通

154
00:08:55,140 --> 00:08:59,810
字猫，但光标字
将虚假和不正确的。

155
00:08:59,810 --> 00:09:04,990
所以我们返回游标字来表示
是否该节点实际上是一个字，

156
00:09:04,990 --> 00:09:06,530
，就是这样的检查。

157
00:09:06,530 --> 00:09:08,310
>> 因此，让我们看看大小。

158
00:09:08,310 --> 00:09:11,410
所以，大小将是很容易
因为，记得在负载，我们

159
00:09:11,410 --> 00:09:15,480
递增的字典大小
我们遇到的每一个字。

160
00:09:15,480 --> 00:09:20,820
因此，尺寸只是要返回
字典大小，仅此而已。

161
00:09:20,820 --> 00:09:24,650
>> 好吧，那么最后，我们有卸载。

162
00:09:24,650 --> 00:09:29,050
所以卸载，我们将使用
递归函数实际上做

163
00:09:29,050 --> 00:09:33,390
对于我们，所以我们的函数的工作
将被称为卸料。

164
00:09:33,390 --> 00:09:35,830
什么是卸荷怎么办？

165
00:09:35,830 --> 00:09:40,640
我们在这里看到了卸荷是要
遍历所有的儿童在

166
00:09:40,640 --> 00:09:45,810
这个特定的节点，并且如果子
节点不为空，那么我们要

167
00:09:45,810 --> 00:09:47,760
卸的子节点。

168
00:09:47,760 --> 00:09:52,070
>> 所以，这是怎么回事递归
卸载所有我们的孩子。

169
00:09:52,070 --> 00:09:55,140
一旦我们确定我们的孩子
已经卸载，那么我们

170
00:09:55,140 --> 00:09:58,830
可以释放自己，所以卸载我们自己。

171
00:09:58,830 --> 00:10:04,550
因此，这将递归卸载
整个特里，然后一旦这

172
00:10:04,550 --> 00:10:06,910
完成后，我们可以只返回True。

173
00:10:06,910 --> 00:10:09,770
卸载不能失败，我们
刚解放的东西。

174
00:10:09,770 --> 00:10:12,985
所以一旦我们完成了解放
一切，返回True。

175
00:10:12,985 --> 00:10:14,380
就是这样。

176
00:10:14,380 --> 00:10:16,792
我的名字是罗布，这
是[听不清]。

177
00:10:16,792 --> 00:10:21,888