1
00:00:00,000 --> 00:00:09,700

2
00:00:09,700 --> 00:00:12,140
>> ZAMYLA陳：讓我們
一個拼寫檢查器。

3
00:00:12,140 --> 00:00:16,900
如果你打開speller.c，然後你會看到
大部分的功能​​為

4
00:00:16,900 --> 00:00:20,810
檢查對一個文本文件
字典是已經為你做。

5
00:00:20,810 --> 00:00:26,330
/拼寫檢查，傳遞一個字典文字
文件，然後另一個文本文件，

6
00:00:26,330 --> 00:00:28,960
將檢查的文本文件
對字典。

7
00:00:28,960 --> 00:00:34,160
>> 現在，詞典文本文件將包含
有效的話，每行一個。

8
00:00:34,160 --> 00:00:37,910
然後speller.c將調用Load
在字典中的文本文件。

9
00:00:37,910 --> 00:00:43,650
它會調用被調用函數檢查
每一個字的輸入的文本文件，

10
00:00:43,650 --> 00:00:46,460
打印所有拼寫錯誤的單詞。

11
00:00:46,460 --> 00:00:50,030
>> Speller.c還將呼籲大小來
決定在單詞數

12
00:00:50,030 --> 00:00:53,500
字典和調用卸載
以釋放內存。

13
00:00:53,500 --> 00:00:57,600
speller.c也將跟踪如何
多少時間是用來進行這些

14
00:00:57,600 --> 00:01:00,560
過程，但我們會
到後來。

15
00:01:00,560 --> 00:01:02,440
>> 那麼，我們需要做什麼？

16
00:01:02,440 --> 00:01:05,110
我們需要填寫dictionary.c。

17
00:01:05,110 --> 00:01:09,940
在dictionary.c，我們有幫手
功能加載，加載了

18
00:01:09,940 --> 00:01:10,855
字典。

19
00:01:10,855 --> 00:01:15,490
功能檢查，如果它檢查
一個給定的字在字典中。

20
00:01:15,490 --> 00:01:19,150
該函數大小返回數字
在字典中的字。

21
00:01:19,150 --> 00:01:24,870
最後，我們已經卸載，這
從存儲器釋放字典。

22
00:01:24,870 --> 00:01:27,070
>> 因此，首先讓我們來解決負載。

23
00:01:27,070 --> 00:01:32,110
在字典中的文字每個字
文件，加載將存儲在那些話

24
00:01:32,110 --> 00:01:34,860
的詞典數據的結構
您的選擇，無論是中

25
00:01:34,860 --> 00:01:36,750
哈希表或線索。

26
00:01:36,750 --> 00:01:39,440
我過去無論是在
此穿行。

27
00:01:39,440 --> 00:01:43,150
>> 首先，讓我們來談談哈希表。

28
00:01:43,150 --> 00:01:47,050
說你有10台球和
你想存儲它們。

29
00:01:47,050 --> 00:01:50,420
你不妨把它們放在一個桶裡，
當你需要一個特定的

30
00:01:50,420 --> 00:01:54,010
編號的球，你會採取一
出桶時間的

31
00:01:54,010 --> 00:01:55,880
尋找那個球。

32
00:01:55,880 --> 00:01:59,370
而只有10球，你應該
能夠找到你的球在一個合理的

33
00:01:59,370 --> 00:02:01,160
量的時間。

34
00:02:01,160 --> 00:02:03,180
>> 但是，如果你有20個球？

35
00:02:03,180 --> 00:02:05,480
現在它可能需要一點時間。

36
00:02:05,480 --> 00:02:06,180
怎麼樣100？

37
00:02:06,180 --> 00:02:07,880
1,000？

38
00:02:07,880 --> 00:02:11,590
現在，這將是容易得多，如果
你有多個桶。

39
00:02:11,590 --> 00:02:15,890
也許有鬥球編號為零
經過九個，另一桶

40
00:02:15,890 --> 00:02:18,800
球編號為10至
19，依此類推。

41
00:02:18,800 --> 00:02:22,330
>> 現在，當您需要尋找特定
球，你可以自動

42
00:02:22,330 --> 00:02:26,320
去一個特定的桶和
搜索通過桶。

43
00:02:26,320 --> 00:02:29,840
如果每個桶中有大約10
球，那麼你可以很容易地搜索

44
00:02:29,840 --> 00:02:31,790
通過它。

45
00:02:31,790 --> 00:02:34,960
>> 現在，因為我們正在處理
字典，一個用於單鬥

46
00:02:34,960 --> 00:02:41,970
所有在字典中的單詞會
可能是太少桶。

47
00:02:41,970 --> 00:02:44,370
因此，讓我們來看看哈希表。

48
00:02:44,370 --> 00:02:46,940
>> 把它看成是水桶的數組。

49
00:02:46,940 --> 00:02:50,370
並且在這種情況下，該桶
是我們的鍊錶。

50
00:02:50,370 --> 00:02:54,770
我們將分發所有的我們的話
其中在這些多重鍊錶

51
00:02:54,770 --> 00:02:58,940
一個有組織的方式使用哈希函數，
它會告訴我們哪些

52
00:02:58,940 --> 00:03:03,720
鬥一個給定的鍵，一個給定的
字，屬於。

53
00:03:03,720 --> 00:03:05,960
>> 讓我們代表這示意性的。

54
00:03:05,960 --> 00:03:11,320
藍色方框這裡包含的價值觀和
紅色方框指向另一個值

55
00:03:11,320 --> 00:03:12,280
指針對。

56
00:03:12,280 --> 00:03:14,800
我們稱這些成對節點。

57
00:03:14,800 --> 00:03:18,260
現在，每個桶，正如我所說
早期，是一個鍊錶。

58
00:03:18,260 --> 00:03:21,820
在鍊錶中，每個節點都有一個值，
以及一個指針，指向

59
00:03:21,820 --> 00:03:23,170
下一個值。

60
00:03:23,170 --> 00:03:26,150
>> 現在，處理鍊錶，
這是非常重要的，你

61
00:03:26,150 --> 00:03:28,120
不輸任何鏈接。

62
00:03:28,120 --> 00:03:32,250
而另一個事實要記住的是，
最後一個節點，如果它不指向

63
00:03:32,250 --> 00:03:35,120
另一個節點，指向空。

64
00:03:35,120 --> 00:03:37,970
>> 那麼，我們如何代表在C？

65
00:03:37,970 --> 00:03:40,540
在這裡，我們定義我們的結構。

66
00:03:40,540 --> 00:03:44,850
在這種情況下的值是
長度的字符數組。

67
00:03:44,850 --> 00:03:48,880
長度加1，其中長度是
最大長度的任何單詞，加1

68
00:03:48,880 --> 00:03:50,380
空終止。

69
00:03:50,380 --> 00:03:54,210
然後我們有一個指針
另一個節點叫做下一步。

70
00:03:54,210 --> 00:03:56,730
>> 因此，讓我們做一個小的鍊錶。

71
00:03:56,730 --> 00:04:00,390
首先，你會想用malloc您的節點，
它在內存中創建空間

72
00:04:00,390 --> 00:04:04,010
您的節點類型的大小。

73
00:04:04,010 --> 00:04:06,100
並讓另一個節點，
再次mallocing。

74
00:04:06,100 --> 00:04:09,370

75
00:04:09,370 --> 00:04:14,340
>> 現在，如果你想要一個值賦給一個
字，那麼我們可能會說node1上箭頭

76
00:04:14,340 --> 00:04:18,820
字等於“你好。”這個箭頭操作符
取消引用指針和

77
00:04:18,820 --> 00:04:20,620
訪問結構體的變量。

78
00:04:20,620 --> 00:04:24,330
這樣，我們就不必同時使用
點和星算。

79
00:04:24,330 --> 00:04:30,100
>> 於是我有node2上箭頭字等於
“世界”。而且，這些值是

80
00:04:30,100 --> 00:04:33,110
居住在我的節點。

81
00:04:33,110 --> 00:04:38,780
為了使鏈接，我會通過在節點1
旁邊的箭頭，訪問該節點的明星，

82
00:04:38,780 --> 00:04:44,160
該節點的指針，等於節點2，
指向節點1到節點2。

83
00:04:44,160 --> 00:04:46,360
我們在那裡有一個鍊錶。

84
00:04:46,360 --> 00:04:51,480
>> 所以這只是一個鍊錶，但
哈希表是整個陣列

85
00:04:51,480 --> 00:04:52,520
鍊錶。

86
00:04:52,520 --> 00:04:55,920
好了，我們將有相同的節點
如前結構。

87
00:04:55,920 --> 00:05:00,140
但是，如果我們想要一個實際的哈希表，
那麼我們可以只讓一個節點指針

88
00:05:00,140 --> 00:05:01,330
數組在這裡。

89
00:05:01,330 --> 00:05:04,940
例如，大小500。

90
00:05:04,940 --> 00:05:08,910
>> 現在通知，還有的將是一個貿易
關的大小之間的

91
00:05:08,910 --> 00:05:11,280
哈希表及大小
您的鍊錶。

92
00:05:11,280 --> 00:05:15,640
如果你有一個非常高數
水桶，想像不必跑回來

93
00:05:15,640 --> 00:05:18,230
和向前一行
找到你的水​​桶。

94
00:05:18,230 --> 00:05:21,530
但你也不想少數
水桶，因為那時我們又回到了

95
00:05:21,530 --> 00:05:26,850
如何具有原始問題
太多的球，我們的水桶。

96
00:05:26,850 --> 00:05:30,480
>> 好了，但那些我們的球去了？

97
00:05:30,480 --> 00:05:33,150
那麼，我們首先需要
有一個球，對不對？

98
00:05:33,150 --> 00:05:39,130
因此，讓我們的malloc為每一個節點
新詞，我們有。

99
00:05:39,130 --> 00:05:42,900
節點* new_node等號
的malloc（的sizeof（節點））。

100
00:05:42,900 --> 00:05:46,760
>> 現在我們有了這個結構，我們
可以掃描中，使用功能

101
00:05:46,760 --> 00:05:51,850
的fscanf，從我們的文件中的字符串，如果
這是一個字典文件，進

102
00:05:51,850 --> 00:05:55,780
new_node箭頭字，其中new_node
箭頭的話是我們

103
00:05:55,780 --> 00:05:58,110
該單詞的目的地。

104
00:05:58,110 --> 00:06:01,900
>> 接下來，我們將要哈希
字使用哈希函數。

105
00:06:01,900 --> 00:06:05,860
散列函數將一個字符串
並返回一個索引。

106
00:06:05,860 --> 00:06:09,760
在這種情況下，索引有
小於的數量

107
00:06:09,760 --> 00:06:11,440
你有水桶。

108
00:06:11,440 --> 00:06:14,600
>> 現在，散列函數，當你試圖
找到一個，並創建一個

109
00:06:14,600 --> 00:06:17,890
你自己，記住他們
必須是確定性的。

110
00:06:17,890 --> 00:06:22,420
這意味著相同的值需要
每次映射到同一個桶

111
00:06:22,420 --> 00:06:23,800
您哈希它。

112
00:06:23,800 --> 00:06:25,300
>> 這有點像一個圖書館。

113
00:06:25,300 --> 00:06:28,560
當你把一本書的基礎上，
作者，你知道哪個貨架它應該

114
00:06:28,560 --> 00:06:31,890
去，無論是貨架編號
一個，兩個或三個。

115
00:06:31,890 --> 00:06:36,280
而這本書將永遠屬於上
任一貨架的一個，兩個或三個。

116
00:06:36,280 --> 00:06:39,460

117
00:06:39,460 --> 00:06:43,810
>> 所以，如果new_node箭頭字的
從你的字典​​中的單詞，然後

118
00:06:43,810 --> 00:06:47,770
散列new_node箭頭會字
給我們的索引

119
00:06:47,770 --> 00:06:49,370
鬥哈希表中。

120
00:06:49,370 --> 00:06:54,040
然後我們將其插入該
由指定的特定鍊錶

121
00:06:54,040 --> 00:06:56,060
回到我們的哈希函數的值。

122
00:06:56,060 --> 00:06:59,070
>> 讓我們看一個例子
插入一個節點到

123
00:06:59,070 --> 00:07:01,750
開始的鍊錶。

124
00:07:01,750 --> 00:07:06,930
如果頭是一個節點指針，指示
的一個鏈接的開始

125
00:07:06,930 --> 00:07:12,420
列表，並new_node表示新
要進入，只是節點

126
00:07:12,420 --> 00:07:17,340
分配頭new_node將失去
鏈接列表的其餘部分。

127
00:07:17,340 --> 00:07:19,330
所以，我們不希望這樣做。

128
00:07:19,330 --> 00:07:22,160
>> 相反，我們要確保
我們堅持每

129
00:07:22,160 --> 00:07:23,550
在我們的節目單節點。

130
00:07:23,550 --> 00:07:29,560
所以運行new_node箭頭旁邊的equals
頭，然後頭等於new_node

131
00:07:29,560 --> 00:07:34,470
將保留所有的
鏈接和不會丟失任何。

132
00:07:34,470 --> 00:07:39,330
>> 但如果你想你的列表是
排序，因為有一個排序的鏈接

133
00:07:39,330 --> 00:07:42,910
清單可能為更容易
尋找它以後？

134
00:07:42,910 --> 00:07:46,020
那麼，對於這一點，你需要知道的
如何遍歷鍊錶。

135
00:07:46,020 --> 00:07:51,210
>> 遍歷一個鍊錶，讓我們
一個節點的指針，一個節點*，充當

136
00:07:51,210 --> 00:07:54,120
你的光標，指示哪些
節點你在起

137
00:07:54,120 --> 00:07:55,460
在第一個元素。

138
00:07:55,460 --> 00:08:01,070
循環，直到光標為空，我們可以
進行一定的處理，然後

139
00:08:01,070 --> 00:08:04,330
向前移動光標，​​當我們需要
使用光標箭頭的價值。

140
00:08:04,330 --> 00:08:08,820
>> 請記住，這是同樣的事情
話說明星光標，提領

141
00:08:08,820 --> 00:08:13,480
光標，然後使用
點運算符值。

142
00:08:13,480 --> 00:08:19,000
所以通過將更新光標
光標移動到光標箭頭旁邊。

143
00:08:19,000 --> 00:08:24,960
>> 說你確定D變為在
與C和E要插入的節點，

144
00:08:24,960 --> 00:08:30,030
有new_node C點到
節點E，這是下一個光標。

145
00:08:30,030 --> 00:08:36,409
然後C，光標，可以再點
到D這樣，你保持一個列表。

146
00:08:36,409 --> 00:08:41,080
小心不要失去你的鏈接
移動光標箭頭旁邊到D

147
00:08:41,080 --> 00:08:43,929
的時候了。

148
00:08:43,929 --> 00:08:44,620
>> 好的。

149
00:08:44,620 --> 00:08:48,920
所以這就是你會如何插入節點，
加載它們，負載話到這些

150
00:08:48,920 --> 00:08:51,600
個節點，並把它們插入
到你的哈希表。

151
00:08:51,600 --> 00:08:53,580
所以，現在讓我們來看看嘗試。

152
00:08:53,580 --> 00:08:58,540
>> 在字典樹中，每個節點將包含一個
結點的指針，一個用於每個陣列

153
00:08:58,540 --> 00:09:02,260
字母在字母表
加一個單引號。

154
00:09:02,260 --> 00:09:06,150
並且陣列中的每個元素
將指向另一節點。

155
00:09:06,150 --> 00:09:10,130
如果該節點為null，則該信
不會成為下一個字母

156
00:09:10,130 --> 00:09:15,690
在一個序列中的任何一句話，因為每
字指示它是否是最後

157
00:09:15,690 --> 00:09:18,160
字一個字或不是。

158
00:09:18,160 --> 00:09:19,750
>> 讓我們看一個圖。

159
00:09:19,750 --> 00:09:22,260
希望事情會
有點清晰。

160
00:09:22,260 --> 00:09:27,210
在此圖中，我們看到只有
某些字母及若干子

161
00:09:27,210 --> 00:09:28,190
被列出。

162
00:09:28,190 --> 00:09:32,500
這樣你就可以遵循一定的路徑，
所有這些路徑將導致你

163
00:09:32,500 --> 00:09:34,020
不同的詞。

164
00:09:34,020 --> 00:09:37,630
>> 那麼，我們如何代表在C？

165
00:09:37,630 --> 00:09:41,910
那麼，每一個節點現在將不得不
一個布爾值，表示是否

166
00:09:41,910 --> 00:09:46,580
該節點的端
一個給定的字或沒有。

167
00:09:46,580 --> 00:09:50,690
然後還會有一個數組
所謂的子節點指針，

168
00:09:50,690 --> 00:09:53,440
有將是他們中的27。

169
00:09:53,440 --> 00:09:56,510
請記住，你也想要
保持你的第一個節點的軌道。

170
00:09:56,510 --> 00:09:59,830
我們要調用根。

171
00:09:59,830 --> 00:10:01,690
>> 所以這是一個線索的結構。

172
00:10:01,690 --> 00:10:05,630
我們如何代表這
作為一本字典？

173
00:10:05,630 --> 00:10:09,890
好吧，加載字，每
字典中的單詞，你會想

174
00:10:09,890 --> 00:10:11,960
遍歷線索。

175
00:10:11,960 --> 00:10:16,170
而在孩子的每個元素
對應於不同的字母。

176
00:10:16,170 --> 00:10:21,660
>> 因此，在孩子檢查值
索引i，其中i代表

177
00:10:21,660 --> 00:10:24,840
信的特定索引
你想插入。

178
00:10:24,840 --> 00:10:28,980
好吧，如果這是null，那麼你要
malloc的一個新節點，並有孩子

179
00:10:28,980 --> 00:10:31,110
我指向該節點。

180
00:10:31,110 --> 00:10:35,630
>> 如果它不為null，那麼這意味著，
，鑑於分支，即給定

181
00:10:35,630 --> 00:10:37,350
子，已經存在。

182
00:10:37,350 --> 00:10:40,160
這樣的話你只移動到
新的節點，然後繼續。

183
00:10:40,160 --> 00:10:43,220
如果你在單詞的末尾的
你想在加載

184
00:10:43,220 --> 00:10:48,120
字典，那麼你可以設置
你是在為true當前節點。

185
00:10:48,120 --> 00:10:51,550
>> 因此，讓我們來看看插入的一個例子
單詞“狐狸”到我們

186
00:10:51,550 --> 00:10:53,070
字典。

187
00:10:53,070 --> 00:10:56,110
假裝我們開始
一個空的字典。

188
00:10:56,110 --> 00:11:01,610
第一個字母F，將設
小兒指數五根

189
00:11:01,610 --> 00:11:03,700
兒童數組。

190
00:11:03,700 --> 00:11:05,430
因此，我們插入英寸

191
00:11:05,430 --> 00:11:14,610
>> 然後字母O將在兒童
指標15，這樓後，再進行X

192
00:11:14,610 --> 00:11:20,180
甚至會低於，分支
關中的O的孩子。

193
00:11:20,180 --> 00:11:24,120
然後，因為X是最後一個字母
這個詞的“狐狸”，那麼我要去

194
00:11:24,120 --> 00:11:27,210
顏色是綠色，表示
它是字的末尾。

195
00:11:27,210 --> 00:11:32,880
在C語言中，這將被設定為
字布爾值true值。

196
00:11:32,880 --> 00:11:36,780
>> 現在，如果下一個字，你是
加載中為單詞“富”？

197
00:11:36,780 --> 00:11:41,490
那麼，你不需要用malloc任何更多
空間F或為O，因為

198
00:11:41,490 --> 00:11:42,990
那些已經存在。

199
00:11:42,990 --> 00:11:45,910
但在foo中的最後2 O

200
00:11:45,910 --> 00:11:47,320
那一個，你就必須對malloc。

201
00:11:47,320 --> 00:11:52,390
使該新節點，設置
的是字布爾為true。

202
00:11:52,390 --> 00:11:57,340
>> 所以，現在讓我們將“狗”。狗會
先從根指數3

203
00:11:57,340 --> 00:12:00,520
孩子，因為D有沒有
尚未建立。

204
00:12:00,520 --> 00:12:04,990
我們將遵循類似的過程，
之前，創建子狗，

205
00:12:04,990 --> 00:12:10,400
哪來的G被染成綠色，因為
這是一個字的結尾。

206
00:12:10,400 --> 00:12:13,160
>> 現在，如果我們要插入“做”什麼？

207
00:12:13,160 --> 00:12:17,150
那麼，這是狗的一個子串，所以
我們並不需要將malloc了。

208
00:12:17,150 --> 00:12:20,800
但是，我們需要指出，我們已經
達到該字的結束。

209
00:12:20,800 --> 00:12:24,020
所以O將被標記為綠色。

210
00:12:24,020 --> 00:12:27,810
持續這一過程的每一個
詞在你的字典中，你已經

211
00:12:27,810 --> 00:12:32,120
在加載它們到任何你
哈希表或您的線索。

212
00:12:32,120 --> 00:12:37,530
>> speller.c將通過在字符串
dictionary.c進行檢查。

213
00:12:37,530 --> 00:12:41,140
現在，檢查函數來操作
在不區分大小寫。

214
00:12:41,140 --> 00:12:45,980
這意味著，大寫字母和
小寫字母和兩者的混合

215
00:12:45,980 --> 00:12:50,670
應該都等同於真實的，如果任何
的該組合是在

216
00:12:50,670 --> 00:12:51,880
字典。

217
00:12:51,880 --> 00:12:55,580
您也可以假設字符串
只會包含字母

218
00:12:55,580 --> 00:12:58,200
字符或單引號。

219
00:12:58,200 --> 00:13:02,490
>> 因此，讓我們看看如何可以檢查
用哈希表結構。

220
00:13:02,490 --> 00:13:07,330
好吧，如果存在的話，那麼它
可以在哈希表中找到。

221
00:13:07,330 --> 00:13:12,240
這樣，那麼你可以嘗試尋找
單詞在相關水桶。

222
00:13:12,240 --> 00:13:14,480
>> 因此，這將鬥那個詞是？

223
00:13:14,480 --> 00:13:20,060
好了，你會得到多少，該索引
鏟斗，通過散列該字

224
00:13:20,060 --> 00:13:23,690
然後搜索在該鍊錶，
在整個穿越

225
00:13:23,690 --> 00:13:28,060
鍊錶，使用String
比較功能。

226
00:13:28,060 --> 00:13:31,940
>> 如果鍊錶的末端是
達到了，這意味著你的光標

227
00:13:31,940 --> 00:13:36,030
達到零，那麼這個詞是不是
在字典中找到。

228
00:13:36,030 --> 00:13:39,090
它不會在任何其他桶。

229
00:13:39,090 --> 00:13:43,020
所以在這裡，你可能會看到怎麼有可能
是具有兩種之間的權衡

230
00:13:43,020 --> 00:13:46,280
排序的鍊錶或無序的。

231
00:13:46,280 --> 00:13:51,180
要么會在需要更多的時間
檢查過程中加載或更多的時間。

232
00:13:51,180 --> 00:13:53,560
>> 你會如何檢查
一個線索結構？

233
00:13:53,560 --> 00:13:56,370
我們將向下行進
在特里。

234
00:13:56,370 --> 00:14:00,390
在輸入單詞的每個字母
我們正在檢查，我們去了

235
00:14:00,390 --> 00:14:03,280
對應於孩子元素。

236
00:14:03,280 --> 00:14:07,770
>> 如果該元素為null，則該方法
有沒有子

237
00:14:07,770 --> 00:14:11,110
包含我們輸入字，所以
單詞拼寫錯誤。

238
00:14:11,110 --> 00:14:15,140
如果它不為空，我們可以移動到
我們是這個詞的下一個字母

239
00:14:15,140 --> 00:14:18,850
檢查和繼續這一進程
直到我們到達終點

240
00:14:18,850 --> 00:14:20,350
的輸入字。

241
00:14:20,350 --> 00:14:23,330
然後我們可以檢查
如果是的話是真實的。

242
00:14:23,330 --> 00:14:24,610
如果是，那也不錯。

243
00:14:24,610 --> 00:14:25,590
這個詞是正確的。

244
00:14:25,590 --> 00:14:30,890
但如果沒有，即使該子
存在於字典樹，單詞是

245
00:14:30,890 --> 00:14:32,250
拼寫錯誤。

246
00:14:32,250 --> 00:14:36,590
>> 當函數大小被調用時，大小
應返回字的數目是

247
00:14:36,590 --> 00:14:39,110
在你的字典中給出
數據結構。

248
00:14:39,110 --> 00:14:42,780
所以，如果你正在使用一個哈希表，你
可以通過每一個

249
00:14:42,780 --> 00:14:45,860
鍊錶中的每一個
鬥數著數

250
00:14:45,860 --> 00:14:47,130
話在那裡。

251
00:14:47,130 --> 00:14:49,940
如果您使用的是特里，你可以
經過每一個非空

252
00:14:49,940 --> 00:14:52,030
路徑在您的線索。

253
00:14:52,030 --> 00:14:56,420
或者你正在加載的字典，而
中，也許你可以保持跟踪如何

254
00:14:56,420 --> 00:14:58,760
您正在加載英寸多的話

255
00:14:58,760 --> 00:15:03,180
>> 一旦speller.c完成檢查
對字典的文本文件，然後

256
00:15:03,180 --> 00:15:08,010
它的完成，所以它調用卸載，其中
你的工作是什麼自由

257
00:15:08,010 --> 00:15:09,500
你已經malloced。

258
00:15:09,500 --> 00:15:14,420
所以，如果你使用一個哈希表，那麼你
需要特別小心，以避免

259
00:15:14,420 --> 00:15:18,830
通過不釋放任何內存洩漏
過早和持有到每

260
00:15:18,830 --> 00:15:20,780
之前你免​​單鏈接。

261
00:15:20,780 --> 00:15:24,680

262
00:15:24,680 --> 00:15:30,100
>> 因此，對於在哈希表中的每一個元素
並在鍊錶的每個節點，

263
00:15:30,100 --> 00:15:32,370
你要釋放該節點。

264
00:15:32,370 --> 00:15:34,970
你怎麼去釋放
鍊錶？

265
00:15:34,970 --> 00:15:38,570
設置您的節點指針光標
頭部，以的開頭

266
00:15:38,570 --> 00:15:43,100
鍊錶，那麼當你的光標
不為空，你可以設置一個臨時的

267
00:15:43,100 --> 00:15:45,610
節點指針光標。

268
00:15:45,610 --> 00:15:48,370
然後向前移動光標。

269
00:15:48,370 --> 00:15:52,950
然後你就可以釋放該臨時
價值，同時仍堅持著

270
00:15:52,950 --> 00:15:55,650
一切之後。

271
00:15:55,650 --> 00:15:57,800
>> 如果您使用的是特里什麼？

272
00:15:57,800 --> 00:16:00,410
那麼做到這一點的最好辦法
是從一卸

273
00:16:00,410 --> 00:16:02,290
底部到頂部。

274
00:16:02,290 --> 00:16:06,920
通過旅行到盡可能低的
節點，你可以釋放所有指針

275
00:16:06,920 --> 00:16:11,430
孩子，然後原路返回
向上，釋放所有的所有元素

276
00:16:11,430 --> 00:16:15,610
孩子陣列，直到
你打你的頂級根節點。

277
00:16:15,610 --> 00:16:18,920
這裡就是遞歸
會派上用場。

278
00:16:18,920 --> 00:16:22,780
>> 為了確保你可能已經被釋放
一切，你已經malloced，

279
00:16:22,780 --> 00:16:24,400
您可以使用Valgrind的。

280
00:16:24,400 --> 00:16:28,640
運行Valgrind的運行你的程序
計數的內存多少字節

281
00:16:28,640 --> 00:16:32,440
你使用，並確保你已經
釋放他們，告訴你

282
00:16:32,440 --> 00:16:34,530
在那裡你可能有
忘記了自由。

283
00:16:34,530 --> 00:16:38,390
這樣運行的，一旦Valgrind的告訴你
並為您提供了繼續前進的話

284
00:16:38,390 --> 00:16:41,160
你已經完成卸載。

285
00:16:41,160 --> 00:16:44,420
>> 現在，一對夫婦的秘訣在你走之前
關閉並開始實施你的

286
00:16:44,420 --> 00:16:46,260
字典。

287
00:16:46,260 --> 00:16:49,650
我建議你通過在一個較小的
字典，當你試圖測試

288
00:16:49,650 --> 00:16:52,620
出來的東西和調試國內生產總值。

289
00:16:52,620 --> 00:16:58,550
拼寫檢查器的用法。​​/拼寫檢查器，一個
可選的字典，然後一個文本。

290
00:16:58,550 --> 00:17:01,550
>> 默認情況下，它在加載
大字典。

291
00:17:01,550 --> 00:17:06,670
所以，你可能想通過在小
字典，或者甚至讓你的

292
00:17:06,670 --> 00:17:11,819
自己的，定制你的字典
和你的文本文件。

293
00:17:11,819 --> 00:17:15,950
>> 然後最後，我也建議
拿一支筆和紙，畫

294
00:17:15,950 --> 00:17:20,490
東西出來之前，期間和之後
你寫的所有代碼。

295
00:17:20,490 --> 00:17:24,170
只要確保你有
這些指針恰到好處。

296
00:17:24,170 --> 00:17:26,480
>> 祝你好運。

297
00:17:26,480 --> 00:17:29,690
一旦您完成後，如果你想
挑戰大板和

298
00:17:29,690 --> 00:17:34,390
看看你的程序是如何比較快
你的同學'，那麼我鼓勵

299
00:17:34,390 --> 00:17:35,960
你檢查出來。

300
00:17:35,960 --> 00:17:39,220
>> 就這樣，你已經完成了
在拼寫檢查PSET。

301
00:17:39,220 --> 00:17:41,800
我的名字是Zamyla，這是CS50。

302
00:17:41,800 --> 00:17:49,504