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