1
00:00:00,000 --> 00:00:08,250

2
00:00:08,250 --> 00:00:12,680
>> JASON HIRSCHHORN：歡迎大家
在第七節。

3
00:00:12,680 --> 00:00:15,040
我們是在使用過程中七個星期。

4
00:00:15,040 --> 00:00:18,440
而這個即將到來的週四
是萬聖節，所以我

5
00:00:18,440 --> 00:00:21,420
打扮得像個南瓜。

6
00:00:21,420 --> 00:00:23,460
我不能彎腰，把上
我的鞋，所以這就是為什麼我

7
00:00:23,460 --> 00:00:25,660
只是穿著襪子。

8
00:00:25,660 --> 00:00:29,220
我也沒有下穿什麼
這一點，所以我不能把它關閉，如果它的

9
00:00:29,220 --> 00:00:29,950
分心給你。

10
00:00:29,950 --> 00:00:31,860
我提前表示歉意。

11
00:00:31,860 --> 00:00:33,170
你不需要想像
這是怎麼回事。

12
00:00:33,170 --> 00:00:34,240
我穿的拳擊手。

13
00:00:34,240 --> 00:00:36,170
所以，這一切都很好。

14
00:00:36,170 --> 00:00:41,120
>> 我為什麼我是一個較長的故事
打扮成一個南瓜，但我要去

15
00:00:41,120 --> 00:00:45,110
保存後在本節
因為我確實想上手。

16
00:00:45,110 --> 00:00:47,720
我們有很多令人興奮的事情
走在這個星期。

17
00:00:47,720 --> 00:00:51,810
他們大多​​直接涉及到這一點
本週的問題集，拼寫錯誤。

18
00:00:51,810 --> 00:00:54,680
我們打算是想在聯
列表和哈希表

19
00:00:54,680 --> 00:00:57,160
整個一節。

20
00:00:57,160 --> 00:01:02,490
我每星期把這個名單了，名單
你來幫助您的資源

21
00:01:02,490 --> 00:01:04,120
本課程的材料。

22
00:01:04,120 --> 00:01:07,600
如果處於虧損狀態，或者尋找一些
更多信息，請查看之一

23
00:01:07,600 --> 00:01:09,930
這些資源。

24
00:01:09,930 --> 00:01:14,530
>> 再次，pset6是拼寫錯誤，
本週的pset中。

25
00:01:14,530 --> 00:01:17,690
它也鼓勵你，和我
鼓勵你，使用一些其他的

26
00:01:17,690 --> 00:01:20,320
資源專門為這個pset中。

27
00:01:20,320 --> 00:01:23,390
特別是，這三個我已經
列出在屏幕上 - 

28
00:01:23,390 --> 00:01:27,160
gdb的，這是我們一直熟悉的
並一直在使用了一段時間了，是

29
00:01:27,160 --> 00:01:29,270
打算這週是非常有益的。

30
00:01:29,270 --> 00:01:30,190
所以，我把那在這裡。

31
00:01:30,190 --> 00:01:32,910
但每當你用C的工作，
你應該總是使用gdb來

32
00:01:32,910 --> 00:01:34,430
調試程序。

33
00:01:34,430 --> 00:01:36,660
這個星期也Valgrind的。

34
00:01:36,660 --> 00:01:38,535
有誰知道什麼Valgrind的呢？

35
00:01:38,535 --> 00:01:42,184

36
00:01:42,184 --> 00:01:43,890
>> 觀眾：它檢查內存洩漏？

37
00:01:43,890 --> 00:01:45,950
>> JASON HIRSCHHORN：Valgrind的
檢查內存洩漏。

38
00:01:45,950 --> 00:01:49,970
所以，如果你在malloc的東西你
程序，你要求的內存。

39
00:01:49,970 --> 00:01:52,920
在程序結束時，你有
寫免費的你已經一切

40
00:01:52,920 --> 00:01:54,800
malloced給記憶回來了。

41
00:01:54,800 --> 00:01:58,420
如果你不寫免費在年底
你的程序涉及到一個結論，

42
00:01:58,420 --> 00:02:00,000
一切都將自動
被釋放。

43
00:02:00,000 --> 00:02:02,340
而對於小程序，它的
不是什麼大不了的事。

44
00:02:02,340 --> 00:02:05,250
但是，如果你正在編寫一個較長的運行
程序不會退出，

45
00:02:05,250 --> 00:02:09,180
不一定，在一兩分鐘或中
幾秒鐘，然後內存洩漏

46
00:02:09,180 --> 00:02:10,710
可以成為一個巨大的交易。

47
00:02:10,710 --> 00:02:14,940
>> 所以對於pset6，期望是
你將有零內存洩漏與

48
00:02:14,940 --> 00:02:15,910
你的程序。

49
00:02:15,910 --> 00:02:18,690
要檢查內存洩漏，運行的valgrind
它會給你一些不錯的

50
00:02:18,690 --> 00:02:21,190
輸出讓你知道是否
或不是一切是免費的。

51
00:02:21,190 --> 00:02:23,940
我們將用它以後練
今天，有希望。

52
00:02:23,940 --> 00:02:25,790
>> 最後，diff命令。

53
00:02:25,790 --> 00:02:28,900
你用類似於它的東西
在pset5與偷看工具。

54
00:02:28,900 --> 00:02:30,780
讓你看看裡面。

55
00:02:30,780 --> 00:02:33,400
您也使用差異，同樣，每
問題設置規範。

56
00:02:33,400 --> 00:02:35,950
但允許你
比較兩個文件。

57
00:02:35,950 --> 00:02:39,180
你可以比較的位圖文件和
一名工作人員解決方案信息標題和

58
00:02:39,180 --> 00:02:42,200
在pset5你的解決方案，如果
您選擇使用它。

59
00:02:42,200 --> 00:02:44,030
差異可以讓你
做到這一點，也是如此。

60
00:02:44,030 --> 00:02:48,620
您可以比較正確的答案
本週的問題設​​置為你的答案

61
00:02:48,620 --> 00:02:52,210
，看看它是否行向上或
其中誤差。

62
00:02:52,210 --> 00:02:55,870
>> 因此，這些都是三個好工具，
你應該使用這個星期，

63
00:02:55,870 --> 00:02:58,130
一定要檢查你的程序
這三個工具

64
00:02:58,130 --> 00:03:00,520
將其入夥前

65
00:03:00,520 --> 00:03:04,650
同樣，正如我剛才所說的每一周，
如果您有任何意見對我來說 - 無論是

66
00:03:04,650 --> 00:03:06,470
積極和建設性的 - 

67
00:03:06,470 --> 00:03:09,930
可以自由地前往網站
在這張幻燈片的底部

68
00:03:09,930 --> 00:03:11,270
並且輸入它。

69
00:03:11,270 --> 00:03:13,440
我真的很感激任何
和所有的反饋。

70
00:03:13,440 --> 00:03:17,360
如果你給我具體的東西，
我可以做些什麼來改善或者說我

71
00:03:17,360 --> 00:03:21,350
做得很好，你想我
繼續，我採取的心臟和

72
00:03:21,350 --> 00:03:24,040
真的努力去傾聽
您的反饋。

73
00:03:24,040 --> 00:03:27,720
我不能保證我會做
一切，不過，就像穿了

74
00:03:27,720 --> 00:03:30,700
每週南瓜服裝。

75
00:03:30,700 --> 00:03:34,020
>> 因此，我們要花費大量的
部分，正如我所說，談論

76
00:03:34,020 --> 00:03:37,240
鍊錶和哈希表，這
將直接適用於

77
00:03:37,240 --> 00:03:38,780
問題本週設置。

78
00:03:38,780 --> 00:03:42,580
鍊錶我們就去了相對
很快，因為我​​們已經花了一個公平的位

79
00:03:42,580 --> 00:03:44,930
的時間段去了它。

80
00:03:44,930 --> 00:03:48,680
所以我們會得到直入
編碼問題的鍊錶。

81
00:03:48,680 --> 00:03:52,740
然後在最後我們來談談
哈希表和它們如何適用於本

82
00:03:52,740 --> 00:03:55,280
本週的問題集。

83
00:03:55,280 --> 00:03:57,560
>> 你以前見過這個代碼。

84
00:03:57,560 --> 00:04:02,730
這是一個結構，它被定義
新的東西稱為一個節點。

85
00:04:02,730 --> 00:04:10,660
和一個節點內有一個整數
在這裡，有一個指針

86
00:04:10,660 --> 00:04:11,830
另一節點。

87
00:04:11,830 --> 00:04:12,790
我們之前已經看到這一點。

88
00:04:12,790 --> 00:04:14,830
這已經上來的
一對夫婦現在星期。

89
00:04:14,830 --> 00:04:18,680
它結合了三分球，這是我們一直
與和結構，這讓工作

90
00:04:18,680 --> 00:04:22,079
我們將兩個不同的
事成一種數據類型。

91
00:04:22,079 --> 00:04:24,830

92
00:04:24,830 --> 00:04:26,490
>> 有很多在屏幕上怎麼回事。

93
00:04:26,490 --> 00:04:30,220
但是，這一切應該是比較
熟悉你。

94
00:04:30,220 --> 00:04:33,810
在第一行中，我們
聲明一個新的節點。

95
00:04:33,810 --> 00:04:41,650
然後將該新節點裡面，我設置
一個在該節點的整數。

96
00:04:41,650 --> 00:04:44,950
我們的下一行我做了見
printf命令，但我已經變灰

97
00:04:44,950 --> 00:04:48,080
printf命令，因為真的
重要的是這條線在這裡 - 

98
00:04:48,080 --> 00:04:50,020
new_node.n。

99
00:04:50,020 --> 00:04:51,270
什麼是圓點是什麼意思？

100
00:04:51,270 --> 00:04:53,810

101
00:04:53,810 --> 00:04:57,240
>> 觀眾：轉到節點，
評估它的N值。

102
00:04:57,240 --> 00:04:58,370
>> JASON HIRSCHHORN：這是
完全正確。

103
00:04:58,370 --> 00:05:03,300
點指訪問n個部分
這個新的節點。

104
00:05:03,300 --> 00:05:05,690
下面這一行做什麼？

105
00:05:05,690 --> 00:05:16,140

106
00:05:16,140 --> 00:05:17,050
邁克爾。

107
00:05:17,050 --> 00:05:21,910
>> 觀眾：它創建另一個節點
將指向新的節點。

108
00:05:21,910 --> 00:05:24,870
>> JASON HIRSCHHORN：所以它不
創建新的節點。

109
00:05:24,870 --> 00:05:26,120
它創建了一個什麼？

110
00:05:26,120 --> 00:05:28,300

111
00:05:28,300 --> 00:05:29,300
>> 觀眾：一個指針。

112
00:05:29,300 --> 00:05:33,460
>> JASON HIRSCHHORN：一個指針，指向一個節點，
通過該節點*這裡所示。

113
00:05:33,460 --> 00:05:34,800
因此它產生一個指針指向一個節點。

114
00:05:34,800 --> 00:05:37,490
和哪一個節點指向它
到，邁克爾？

115
00:05:37,490 --> 00:05:38,440
>> 觀眾：新的節點？

116
00:05:38,440 --> 00:05:39,240
>> JASON HIRSCHHORN：新節點。

117
00:05:39,240 --> 00:05:43,020
和它的指向那裡，因為我們已經
賦予它新的節點的地址。

118
00:05:43,020 --> 00:05:45,820
現在在這條線，我們看到
兩種不同的方法

119
00:05:45,820 --> 00:05:46,910
表達了同樣的事情。

120
00:05:46,910 --> 00:05:49,650
而我想指出如​​何將這些
兩件事情是相同的。

121
00:05:49,650 --> 00:05:54,740
在第一行中，我們解引用
指針。

122
00:05:54,740 --> 00:05:55,830
所以我們去的節點。

123
00:05:55,830 --> 00:05:56,830
這就是這個星號表示。

124
00:05:56,830 --> 00:05:57,930
我們已經看到，之前與指針。

125
00:05:57,930 --> 00:05:59,280
去那個節點。

126
00:05:59,280 --> 00:06:00,370
這就是在括號中。

127
00:06:00,370 --> 00:06:04,610
然後通過點操作符訪問
該節點的n個元素。

128
00:06:04,610 --> 00:06:08,430
>> 所以這走的語法
我們看到在這裡和現在

129
00:06:08,430 --> 00:06:09,670
使用它的指針。

130
00:06:09,670 --> 00:06:13,730
當然，它得到的忙，如果樣
你寫的那些括號 - 

131
00:06:13,730 --> 00:06:14,940
這星和那點。

132
00:06:14,940 --> 00:06:16,220
它變得有點忙。

133
00:06:16,220 --> 00:06:18,500
因此，我們有一些語法糖。

134
00:06:18,500 --> 00:06:19,920
而這條線就在這裡 - 

135
00:06:19,920 --> 00:06:21,170
ptr_node  - >ñ。

136
00:06:21,170 --> 00:06:25,400

137
00:06:25,400 --> 00:06:28,000
這做同樣的事情。

138
00:06:28,000 --> 00:06:30,840
因此，在這兩行代碼是
等效，並會盡

139
00:06:30,840 --> 00:06:31,650
完全相同的事情。

140
00:06:31,650 --> 00:06:34,210
>> 但我想指出那些之前
我們再往前走讓你明白

141
00:06:34,210 --> 00:06:39,000
真的這個東西在這裡是
只是語法糖提領

142
00:06:39,000 --> 00:06:44,200
的指針，然後將要
該結構的n個部分。

143
00:06:44,200 --> 00:06:45,525
這個幻燈片有任何疑問？

144
00:06:45,525 --> 00:06:53,020

145
00:06:53,020 --> 00:06:54,390
確定。

146
00:06:54,390 --> 00:06:58,510
>> 因此，我們要經過幾個
操作，你可以做的

147
00:06:58,510 --> 00:06:59,730
鍊錶。

148
00:06:59,730 --> 00:07:05,770
鍊錶，召回，是一系列的
指向另一個節點。

149
00:07:05,770 --> 00:07:12,470
而我們一般先從一個指針
稱為頭，一般地，一個指向

150
00:07:12,470 --> 00:07:14,040
在列表中的第一件事情。

151
00:07:14,040 --> 00:07:18,900
所以在第一行這裡，我們
首先我們原裝L。

152
00:07:18,900 --> 00:07:21,370
所以，那個東西你能想到的 - 這
這裡的文字，你能想到的作為

153
00:07:21,370 --> 00:07:23,560
剛剛我們已經存儲的指針
某處點

154
00:07:23,560 --> 00:07:24,670
第一個元素。

155
00:07:24,670 --> 00:07:27,500
而在這個鍊錶
我們有四個節點。

156
00:07:27,500 --> 00:07:29,530
每個節點都是一個大箱子。

157
00:07:29,530 --> 00:07:33,430
裡面的大較大的方框
框是整數部分。

158
00:07:33,430 --> 00:07:37,400
然後我們有一個指針組成部分。

159
00:07:37,400 --> 00:07:39,630
>> 這些箱子都沒有吸引到
因為規模是多大

160
00:07:39,630 --> 00:07:42,320
以字節為單位的整數

161
00:07:42,320 --> 00:07:43,290
現在有多大？

162
00:07:43,290 --> 00:07:43,710
四。

163
00:07:43,710 --> 00:07:45,470
多大是一個指針？

164
00:07:45,470 --> 00:07:45,940
四。

165
00:07:45,940 --> 00:07:48,180
因此，其實，如果我們繪製
這個擴展的兩個方塊

166
00:07:48,180 --> 00:07:49,690
將是相同的大小。

167
00:07:49,690 --> 00:07:52,870
在這種情況下，我們希望插入
事到鍊錶。

168
00:07:52,870 --> 00:07:57,190
所以，你可以下來看看我們在這裡插入
5，我們通過遍歷

169
00:07:57,190 --> 00:08:01,310
鍊錶，找到其中5
去，然後將其插入。

170
00:08:01,310 --> 00:08:03,560
>> 讓我們打破了，去
多一點點慢。

171
00:08:03,560 --> 00:08:05,510
我要指出的板。

172
00:08:05,510 --> 00:08:09,930
因此，我們有我們的節點5的
我們在mallocs創建。

173
00:08:09,930 --> 00:08:11,190
為什麼大家都笑了？

174
00:08:11,190 --> 00:08:12,130
只是在開玩笑。

175
00:08:12,130 --> 00:08:13,310
確定。

176
00:08:13,310 --> 00:08:14,820
因此，我們已經malloced五位。

177
00:08:14,820 --> 00:08:16,310
我們創建這個節點
別的地方。

178
00:08:16,310 --> 00:08:17,740
我們必須準備好去。

179
00:08:17,740 --> 00:08:20,130
我們開始在前面
我們的名單有兩個。

180
00:08:20,130 --> 00:08:22,380
我們要插入
在已排序的方式。

181
00:08:22,380 --> 00:08:27,550
>> 所以，如果我們看到了兩個，我們希望把
五，我們該怎麼做，當我們看到

182
00:08:27,550 --> 00:08:28,800
東西不到我們？

183
00:08:28,800 --> 00:08:31,850

184
00:08:31,850 --> 00:08:33,520
什麼？

185
00:08:33,520 --> 00:08:36,750
我們要插入五成這
鍊錶，保持它排序。

186
00:08:36,750 --> 00:08:37,520
我們看到第二。

187
00:08:37,520 --> 00:08:38,769
那麼，我們該怎麼辦？

188
00:08:38,769 --> 00:08:39,179
馬庫斯？

189
00:08:39,179 --> 00:08:40,679
>> 觀眾：調用指針
到下一個節點。

190
00:08:40,679 --> 00:08:42,530
>> JASON HIRSCHHORN：為什麼做
我們去下一個？

191
00:08:42,530 --> 00:08:45,970
>> 觀眾：因為它是
列表中的下一個節點。

192
00:08:45,970 --> 00:08:48,310
而我們只知道其他位置。

193
00:08:48,310 --> 00:08:50,410
>> JASON HIRSCHHORN：而且五是更大
大於2，尤其如此。

194
00:08:50,410 --> 00:08:51,600
因為我們要保持它排序。

195
00:08:51,600 --> 00:08:52,730
因此，五是大於二。

196
00:08:52,730 --> 00:08:54,460
因此，我們就移動到下一個。

197
00:08:54,460 --> 00:08:55,240
現在我們達到四。

198
00:08:55,240 --> 00:08:56,490
而當我們達到四會發生什麼？

199
00:08:56,490 --> 00:08:58,920

200
00:08:58,920 --> 00:09:00,310
>> 五是大於四。

201
00:09:00,310 --> 00:09:01,460
因此，我們繼續前進。

202
00:09:01,460 --> 00:09:03,110
現在我們是在六人。

203
00:09:03,110 --> 00:09:04,360
什麼我們六看？

204
00:09:04,360 --> 00:09:08,672

205
00:09:08,672 --> 00:09:09,608
是的，卡洛斯？

206
00:09:09,608 --> 00:09:10,544
>> 觀眾：六是大於五。

207
00:09:10,544 --> 00:09:11,480
>> JASON HIRSCHHORN：六是
大於五。

208
00:09:11,480 --> 00:09:13,660
所以這就是我們想要的
插入五位。

209
00:09:13,660 --> 00:09:17,320
但是，請記住，如果我們
只有一個指針在這裡 - 

210
00:09:17,320 --> 00:09:19,840
這是我們額外的指針，它是
遍歷整個列表。

211
00:09:19,840 --> 00:09:21,860
我們正在指向6。

212
00:09:21,860 --> 00:09:25,010
我們已經失去了什麼軌道
談到前六。

213
00:09:25,010 --> 00:09:29,130
因此，如果我們要插入到的東西
這個列表保持排序，我們

214
00:09:29,130 --> 00:09:31,630
大概需要多少個三分球？

215
00:09:31,630 --> 00:09:32,280
>> 觀眾：兩個。

216
00:09:32,280 --> 00:09:32,920
>> JASON HIRSCHORN：兩個。

217
00:09:32,920 --> 00:09:35,720
一個以跟踪當前的
1，一個用於跟踪

218
00:09:35,720 --> 00:09:37,050
前一個。

219
00:09:37,050 --> 00:09:38,450
這僅僅是一個單向鍊錶。

220
00:09:38,450 --> 00:09:39,670
那就只一個方向。

221
00:09:39,670 --> 00:09:43,220
如果我們有一個雙向鍊錶，其中
一切都指向一點

222
00:09:43,220 --> 00:09:46,240
之後和之前的事情了，然後
我們不需要那樣做。

223
00:09:46,240 --> 00:09:49,350
但在這種情況下，我們不希望失去
軌道的情況下，我們面前什麼來

224
00:09:49,350 --> 00:09:53,350
我們需要插入五個地方
在中間。

225
00:09:53,350 --> 00:09:55,610
說我們被插入9。

226
00:09:55,610 --> 00:09:57,260
什麼時候會發生
我們得到了八？

227
00:09:57,260 --> 00:10:01,860

228
00:10:01,860 --> 00:10:04,880
>> 觀眾：你不得不
拿到零點。

229
00:10:04,880 --> 00:10:07,820
而不必空點你不得不
添加一個元素，然後有

230
00:10:07,820 --> 00:10:09,216
這點九。

231
00:10:09,216 --> 00:10:09,700
>> JASON HIRSCHORN：沒錯。

232
00:10:09,700 --> 00:10:10,600
所以我們得到8。

233
00:10:10,600 --> 00:10:13,140
我們到達列表的末尾，因為
這是指向空。

234
00:10:13,140 --> 00:10:16,330
而不是有和現在，它指向
空我們把它指向我們的新節點。

235
00:10:16,330 --> 00:10:19,870
而我們在設置指針
我們的新節點為null。

236
00:10:19,870 --> 00:10:21,445
沒有任何人有任何疑問，
有關插入？

237
00:10:21,445 --> 00:10:25,620

238
00:10:25,620 --> 00:10:28,100
如果我不關心什麼
保持排序的列表？

239
00:10:28,100 --> 00:10:31,701

240
00:10:31,701 --> 00:10:34,350
>> 觀眾：在堅持它
開始或結束。

241
00:10:34,350 --> 00:10:35,510
>> JASON HIRSCHORN：在堅持它
的開始或結束。

242
00:10:35,510 --> 00:10:37,276
哪一個才好呢？

243
00:10:37,276 --> 00:10:38,770
鮑比？

244
00:10:38,770 --> 00:10:41,020
為什麼要結束了嗎？

245
00:10:41,020 --> 00:10:43,250
>> 觀眾：因為開始時
已經充滿。

246
00:10:43,250 --> 00:10:43,575
>> JASON HIRSCHORN：確定。

247
00:10:43,575 --> 00:10:44,360
一開始已經充滿。

248
00:10:44,360 --> 00:10:46,090
誰想要反駁鮑比。

249
00:10:46,090 --> 00:10:47,290
馬庫斯。

250
00:10:47,290 --> 00:10:48,910
>> 觀眾：那麼你可能想
把它貼在一開始，因為

251
00:10:48,910 --> 00:10:50,140
否則，如果你把它在
最後，你不得不

252
00:10:50,140 --> 00:10:51,835
遍歷整個列表。

253
00:10:51,835 --> 00:10:52,990
>> JASON HIRSCHORN：沒錯。

254
00:10:52,990 --> 00:10:57,970
因此，如果我們正在考慮運行時，
在最後插入的運行時

255
00:10:57,970 --> 00:11:00,110
將N，這個尺寸。

256
00:11:00,110 --> 00:11:03,080
什麼是插入的大O運行
在開始？

257
00:11:03,080 --> 00:11:04,170
常量時間。

258
00:11:04,170 --> 00:11:07,075
所以，如果你不關心保持
整理東西，好多只

259
00:11:07,075 --> 00:11:08,420
插入此列表的開頭。

260
00:11:08,420 --> 00:11:10,320
並可以在常數時間內完成。

261
00:11:10,320 --> 00:11:13,900

262
00:11:13,900 --> 00:11:14,690
>> 確定。

263
00:11:14,690 --> 00:11:18,870
接下來的操作就是找到，這是其它 - 
我們這個措辭作為搜索。

264
00:11:18,870 --> 00:11:22,470
但我們要看看通過
鍊錶的一些對象。

265
00:11:22,470 --> 00:11:26,000
你們已經看到代碼
以前搜索的講座。

266
00:11:26,000 --> 00:11:29,490
樣的，但我們只是做了它與
插入，或者至少插入

267
00:11:29,490 --> 00:11:30,580
東西來分類的。

268
00:11:30,580 --> 00:11:36,350
你通過，由節點將節點，
直到你發現你的號

269
00:11:36,350 --> 00:11:37,780
尋找。

270
00:11:37,780 --> 00:11:39,670
如果你達到會發生什麼
該列表的末尾？

271
00:11:39,670 --> 00:11:43,020
說我在找九和我
到達列表末尾。

272
00:11:43,020 --> 00:11:44,270
我們該怎麼辦？

273
00:11:44,270 --> 00:11:47,147

274
00:11:47,147 --> 00:11:48,110
>> 觀眾：返回false？

275
00:11:48,110 --> 00:11:48,690
>> JASON HIRSCHORN：返回false。

276
00:11:48,690 --> 00:11:49,960
我們沒有發現它。

277
00:11:49,960 --> 00:11:52,010
如果到達列表的末尾，
你沒有找到你的號

278
00:11:52,010 --> 00:11:54,170
尋找的，它不是在那裡。

279
00:11:54,170 --> 00:11:55,420
大約有任何疑問找到？

280
00:11:55,420 --> 00:11:59,530

281
00:11:59,530 --> 00:12:04,615
如果這是一個排序的列表，會是什麼
對我們的搜索有什麼不同？

282
00:12:04,615 --> 00:12:07,370

283
00:12:07,370 --> 00:12:08,103
是啊。

284
00:12:08,103 --> 00:12:10,600
>> 觀眾：它會找到的第一個值
這是大於1

285
00:12:10,600 --> 00:12:12,390
你正在尋找和
然後返回false。

286
00:12:12,390 --> 00:12:13,190
>> JASON HIRSCHORN：沒錯。

287
00:12:13,190 --> 00:12:17,310
所以，如果這是一個排序的列表，如果我們得到
東西是比什麼

288
00:12:17,310 --> 00:12:20,180
我們要尋找的，我們不需要
繼續前進到列表的末尾。

289
00:12:20,180 --> 00:12:24,060
我們可以在這一點上返回false
因為我們不會找到它。

290
00:12:24,060 --> 00:12:27,340
現在的問題是，我們已經討論過
保持鍊錶排序，

291
00:12:27,340 --> 00:12:28,180
保持它們排序。

292
00:12:28,180 --> 00:12:30,050
那將是什麼你
可能將不得不去思考

293
00:12:30,050 --> 00:12:34,240
當編碼問題設置5，如果你
選擇配有獨立的哈希表

294
00:12:34,240 --> 00:12:36,360
鏈接的方法，這
我們將在以後討論。

295
00:12:36,360 --> 00:12:41,400
>> 但它是值得的，以保持列表
排序，然後才能有可能

296
00:12:41,400 --> 00:12:42,310
更快的搜索？

297
00:12:42,310 --> 00:12:47,220
還是更快速插入
東西在不斷的運行，但隨後

298
00:12:47,220 --> 00:12:48,430
有較長的搜索？

299
00:12:48,430 --> 00:12:52,250
這是一個折中就在那裡，你
去決定什麼是更合適

300
00:12:52,250 --> 00:12:53,590
針對您的具體問題。

301
00:12:53,590 --> 00:12:56,680
而且也並不一定是
絕對正確的答案。

302
00:12:56,680 --> 00:12:59,520
但它肯定是你的決定
做了，大概好保衛

303
00:12:59,520 --> 00:13:05,270
在，也就是說，一個或兩個註釋為什麼
你選擇了一個比其他。

304
00:13:05,270 --> 00:13:06,490
>> 最後，刪除。

305
00:13:06,490 --> 00:13:08,100
我們已經看到刪除。

306
00:13:08,100 --> 00:13:09,180
它類似於搜索。

307
00:13:09,180 --> 00:13:11,020
我們期待的元素。

308
00:13:11,020 --> 00:13:12,390
假設我們正在試圖刪除6。

309
00:13:12,390 --> 00:13:14,450
因此，我們發現了六個就在這裡。

310
00:13:14,450 --> 00:13:18,860
我們必須確保我們的東西
做的是，無論是指向

311
00:13:18,860 --> 00:13:21,220
6  - 正如我們在一步看
兩下在這裡 - 

312
00:13:21,220 --> 00:13:26,500
凡是指著六個需要
跳過6現在改為

313
00:13:26,500 --> 00:13:28,160
無論6指向。

314
00:13:28,160 --> 00:13:31,410
我們不希望永遠孤兒的其餘部分
通過忘記來設定我們的名單

315
00:13:31,410 --> 00:13:32,960
以前的指針。

316
00:13:32,960 --> 00:13:35,960
然後，具體情況取決於
上節目，他們就會

317
00:13:35,960 --> 00:13:37,380
完全刪除該節點。

318
00:13:37,380 --> 00:13:40,135
有時候你會想回到
該值，在此節點。

319
00:13:40,135 --> 00:13:42,490
所以這就是如何刪除工作。

320
00:13:42,490 --> 00:13:44,610
對任何問題刪除？

321
00:13:44,610 --> 00:13:51,280

322
00:13:51,280 --> 00:13:53,850
>> 觀眾：所以，如果你要刪除
它，你只需要使用免費的，因為

323
00:13:53,850 --> 00:13:55,655
想必有人malloced？

324
00:13:55,655 --> 00:13:57,976
>> JASON HIRSCHORN：如果你想釋放
東西是完全正確的，你

325
00:13:57,976 --> 00:13:58,540
malloced它。

326
00:13:58,540 --> 00:14:00,410
假設我們想返回這個值。

327
00:14:00,410 --> 00:14:04,010
我們可能會選出6位，然後免費
這個節點和呼叫免費就可以了。

328
00:14:04,010 --> 00:14:06,180
或者，我們可能會調用free第一
然後選出6。

329
00:14:06,180 --> 00:14:11,210

330
00:14:11,210 --> 00:14:11,580
>> 確定。

331
00:14:11,580 --> 00:14:14,010
因此，讓我們繼續前進練習編碼。

332
00:14:14,010 --> 00:14:16,090
我們要編寫三個函數。

333
00:14:16,090 --> 00:14:18,260
第一個被稱為insert_node。

334
00:14:18,260 --> 00:14:22,170
所以，你有我發郵件給你的代碼，
如果你看這個以後

335
00:14:22,170 --> 00:14:28,020
您可以訪問代碼linked.c
在CS50網站。

336
00:14:28,020 --> 00:14:30,880
但在linked.c，有一些
框架代碼的已經

337
00:14:30,880 --> 00:14:32,280
已為你寫好。

338
00:14:32,280 --> 00:14:34,560
然後有一對夫婦的功能
你需要寫。

339
00:14:34,560 --> 00:14:36,380
>> 首先我們要
寫insert_node。

340
00:14:36,380 --> 00:14:39,800
什麼insert_node呢
就是插入一個整數。

341
00:14:39,800 --> 00:14:42,440
而你給的整數
成一個鍊錶。

342
00:14:42,440 --> 00:14:45,470
特別是，你需要
保持排序的列表

343
00:14:45,470 --> 00:14:47,650
從最小到最大。

344
00:14:47,650 --> 00:14:51,360
此外，您不希望
插入任何重複。

345
00:14:51,360 --> 00:14:54,600
最後，你可以看到insert_node
返回一個布爾值。

346
00:14:54,600 --> 00:14:57,140
所以你應該讓用戶知道
是否插入了

347
00:14:57,140 --> 00:15:00,800
成功通過返回true或false。

348
00:15:00,800 --> 00:15:02,580
在這個程序結束 - 

349
00:15:02,580 --> 00:15:05,750
而這個階段你不需要
不用擔心釋放任何東西。

350
00:15:05,750 --> 00:15:11,790
因此，所有你正在做的是採取一個整數
並將其插入到一個列表中。

351
00:15:11,790 --> 00:15:13,890
>> 這就是我要問你現在要做的。

352
00:15:13,890 --> 00:15:17,620
再次，在linked.c，你
全有，是框架代碼。

353
00:15:17,620 --> 00:15:20,980
你應該向底部看
示例函數聲明。

354
00:15:20,980 --> 00:15:27,390
然而，在進入它的編碼
在C中，我強烈建議你去

355
00:15:27,390 --> 00:15:29,330
經過的步驟，我們已經
每星期練習。

356
00:15:29,330 --> 00:15:31,100
我們已經通過了
在此照片。

357
00:15:31,100 --> 00:15:33,380
所以，你應該有一定的了解
是如何工作的。

358
00:15:33,380 --> 00:15:36,590
但我會鼓勵你寫
跳水英寸之前的一些偽代碼

359
00:15:36,590 --> 00:15:38,640
我們要去投奔
偽代碼為一組。

360
00:15:38,640 --> 00:15:41,470
然後，一旦你寫你的
偽代碼，一旦我們寫我們

361
00:15:41,470 --> 00:15:45,850
偽代碼為一組，你可以
進入編碼它在C

362
00:15:45,850 --> 00:15:49,980
>> 作為一名負責人時，insert_node功能
可能是最棘手的

363
00:15:49,980 --> 00:15:53,550
三，我們要去寫，因為我
增加了一些額外的限制，

364
00:15:53,550 --> 00:15:57,190
你的編程，尤其是
你不會插入任何

365
00:15:57,190 --> 00:15:59,880
重複，並且列表
應保持有序。

366
00:15:59,880 --> 00:16:02,660
所以這是一個不平凡的程序
你需要的代碼。

367
00:16:02,660 --> 00:16:06,470
而你為什麼不採取六時五十五
分鐘，只是為了讓工作在

368
00:16:06,470 --> 00:16:07,640
偽代碼和代碼。

369
00:16:07,640 --> 00:16:09,460
然後我們將開始
要為一組。

370
00:16:09,460 --> 00:16:11,680
同樣，如果你​​有任何問題，只是
舉起你的手，我會回到你身邊。

371
00:16:11,680 --> 00:16:15,258

372
00:16:15,258 --> 00:16:16,508
。

373
00:16:16,508 --> 00:18:28,370

374
00:18:28,370 --> 00:18:30,120
>> 我們一般做這些 - 

375
00:18:30,120 --> 00:18:32,070
或者我沒有明確說你
能與人合作。

376
00:18:32,070 --> 00:18:36,500
但很明顯，我強烈鼓勵你，
如果你有問題，問

377
00:18:36,500 --> 00:18:39,840
鄰居坐在你旁邊
甚至是與別人合作

378
00:18:39,840 --> 00:18:40,510
否則，如果你想。

379
00:18:40,510 --> 00:18:42,600
這不必是一個單獨的
沉默的活動。

380
00:18:42,600 --> 00:20:11,770

381
00:20:11,770 --> 00:20:16,330
>> 讓我們開始寫一些
偽代碼在黑板上。

382
00:20:16,330 --> 00:20:19,395
誰可以給我的第一行
偽代碼對這一計劃？

383
00:20:19,395 --> 00:20:22,240

384
00:20:22,240 --> 00:20:23,640
對於此功能，而 - 
insert_node。

385
00:20:23,640 --> 00:20:29,960

386
00:20:29,960 --> 00:20:31,830
奧爾登？

387
00:20:31,830 --> 00:20:36,560
>> 觀眾：所以第一件事是
創建一個新的指針的節點和餘

388
00:20:36,560 --> 00:20:41,320
初始化它指向相同
東西的清單指向。

389
00:20:41,320 --> 00:20:41,550
>> JASON HIRSCHORN：確定。

390
00:20:41,550 --> 00:20:45,190
所以，你要創建一個新的指針
到列表中，而不是到該節點。

391
00:20:45,190 --> 00:20:45,420
>> 觀眾：對。

392
00:20:45,420 --> 00:20:46,150
是啊。

393
00:20:46,150 --> 00:20:46,540
>> JASON HIRSCHORN：確定。

394
00:20:46,540 --> 00:20:48,221
然後我們究竟想幹什麼？

395
00:20:48,221 --> 00:20:49,163
什麼之後呢？

396
00:20:49,163 --> 00:20:50,105
怎麼樣的節點？

397
00:20:50,105 --> 00:20:51,050
我們沒有一個節點。

398
00:20:51,050 --> 00:20:52,300
我們只是有一個值。

399
00:20:52,300 --> 00:20:55,918

400
00:20:55,918 --> 00:20:58,890
如果我們要插入一個節點，我們怎麼辦
需要之前，我們甚至可以先做

401
00:20:58,890 --> 00:20:59,980
想想插入呢？

402
00:20:59,980 --> 00:21:00,820
>> 觀眾：哦，對不起。

403
00:21:00,820 --> 00:21:02,160
我們需要將malloc空間的節點。

404
00:21:02,160 --> 00:21:02,455
>> JASON HIRSCHORN：優秀。

405
00:21:02,455 --> 00:21:03,210
讓我們做 - 

406
00:21:03,210 --> 00:21:04,628
確定。

407
00:21:04,628 --> 00:21:06,065
無法達到那麼高。

408
00:21:06,065 --> 00:21:08,939

409
00:21:08,939 --> 00:21:09,897
確定。

410
00:21:09,897 --> 00:21:13,236
我們要往下走，然後
我們使用的是兩列。

411
00:21:13,236 --> 00:21:13,732
我不能去了 - 

412
00:21:13,732 --> 00:21:14,982
確定。

413
00:21:14,982 --> 00:21:23,660

414
00:21:23,660 --> 00:21:25,130
創建新的節點。

415
00:21:25,130 --> 00:21:29,380
您可以創建另一個指針列表
或者你可以用列表作為它的存在。

416
00:21:29,380 --> 00:21:30,720
你並不真的需要做到這一點。

417
00:21:30,720 --> 00:21:31,750
>> 因此，我們創建了一個新的節點。

418
00:21:31,750 --> 00:21:32,010
大。

419
00:21:32,010 --> 00:21:32,840
這就是我們做的第一個。

420
00:21:32,840 --> 00:21:34,870
下一步是什麼？

421
00:21:34,870 --> 00:21:35,080
>> 觀眾：請等待。

422
00:21:35,080 --> 00:21:38,330
如果我們現在創建一個新的節點或
我們應該等待，以確保

423
00:21:38,330 --> 00:21:42,260
有節點沒有重複
名單上之前，我們創建它嗎？

424
00:21:42,260 --> 00:21:43,100
>> JASON HIRSCHORN：好問題。

425
00:21:43,100 --> 00:21:47,770
讓我們認為，對於後來因為
大部分我們將要創建的時間

426
00:21:47,770 --> 00:21:48,220
一個新節點。

427
00:21:48,220 --> 00:21:49,110
因此，我們會繼續在這裡。

428
00:21:49,110 --> 00:21:51,006
但是，這是一個很好的問題。

429
00:21:51,006 --> 00:21:53,250
如果我們創建它，我們發現
一式兩份，又該

430
00:21:53,250 --> 00:21:54,490
我們返回之前做的？

431
00:21:54,490 --> 00:21:55,190
>> 觀眾：釋放它。

432
00:21:55,190 --> 00:21:55,470
>> JASON HIRSCHORN：是啊。

433
00:21:55,470 --> 00:21:56,500
可能釋放它。

434
00:21:56,500 --> 00:21:56,760
確定。

435
00:21:56,760 --> 00:21:59,850
我們之後我們做什麼
創建一個新的節點？

436
00:21:59,850 --> 00:22:02,260
安妮？

437
00:22:02,260 --> 00:22:04,780
>> 觀眾：我們把
在節點數量？

438
00:22:04,780 --> 00:22:05,140
>> JASON HIRSCHORN：沒錯。

439
00:22:05,140 --> 00:22:07,190
我們把數字 - 我們用malloc空間。

440
00:22:07,190 --> 00:22:08,160
我要離開了
所有為一行。

441
00:22:08,160 --> 00:22:08,720
但你說得對。

442
00:22:08,720 --> 00:22:10,305
我們malloc的空間，然後
我們把數英寸

443
00:22:10,305 --> 00:22:12,585
我們甚至可以設置指針
它的一部分為null。

444
00:22:12,585 --> 00:22:13,720
這是完全正確的。

445
00:22:13,720 --> 00:22:17,400
再怎麼樣之後呢？

446
00:22:17,400 --> 00:22:18,490
我們畫了這幅畫在黑板上。

447
00:22:18,490 --> 00:22:21,190
那麼，我們該怎麼辦？

448
00:22:21,190 --> 00:22:22,680
>> 觀眾：我們通過列表。

449
00:22:22,680 --> 00:22:23,930
>> JASON HIRSCHORN：穿過列表。

450
00:22:23,930 --> 00:22:30,620

451
00:22:30,620 --> 00:22:31,100
確定。

452
00:22:31,100 --> 00:22:34,280
什麼我們在每個節點檢查。

453
00:22:34,280 --> 00:22:35,955
庫爾特，什麼我們檢查
於每個節點？

454
00:22:35,955 --> 00:22:41,640
>> 觀眾：看有無N值的
該節點是大於n值

455
00:22:41,640 --> 00:22:43,070
我們的節點。

456
00:22:43,070 --> 00:22:43,340
>> JASON HIRSCHORN：確定。

457
00:22:43,340 --> 00:22:44,280
我該怎麼辦 - 

458
00:22:44,280 --> 00:22:45,855
是的，確定。

459
00:22:45,855 --> 00:22:48,160
所以它的北 - 

460
00:22:48,160 --> 00:22:59,040
我會說，如果值大於
比這個節點，那麼我們怎麼辦？

461
00:22:59,040 --> 00:23:07,290
>> 觀眾：好，那我們插入
前正確的事情。

462
00:23:07,290 --> 00:23:07,970
>> JASON HIRSCHORN：確定。

463
00:23:07,970 --> 00:23:09,410
所以，如果它大於這個，
那麼我們要插入。

464
00:23:09,410 --> 00:23:14,010
但我們要正確之前，將其插入
因為我們也將需要

465
00:23:14,010 --> 00:23:16,070
跟踪，然後，
什麼是以前。

466
00:23:16,070 --> 00:23:22,690
所以之前插入。

467
00:23:22,690 --> 00:23:25,120
因此，我們可能錯過了什麼
較早前。

468
00:23:25,120 --> 00:23:27,770
我們可能需要被保留
軌道發生了什麼事情。

469
00:23:27,770 --> 00:23:28,460
但我們會回到那裡。

470
00:23:28,460 --> 00:23:30,160
那麼，什麼值小於？

471
00:23:30,160 --> 00:23:38,030

472
00:23:38,030 --> 00:23:39,710
庫爾特，我們該怎麼做，如果
值小於？

473
00:23:39,710 --> 00:23:43,000
>> 觀眾：那你只是繼續前進
除非它是最後一個。

474
00:23:43,000 --> 00:23:43,550
>> JASON HIRSCHORN：我喜歡這樣。

475
00:23:43,550 --> 00:23:44,800
所以去到下一個節點。

476
00:23:44,800 --> 00:23:47,410

477
00:23:47,410 --> 00:23:48,930
除非它是最後一個 - 

478
00:23:48,930 --> 00:23:51,100
我們可能檢查的
中的一個條件的條件。

479
00:23:51,100 --> 00:23:54,870
但是，是的，下一個節點。

480
00:23:54,870 --> 00:23:58,680
而且是越來越過低，
因此，我們將在這裡搬過來。

481
00:23:58,680 --> 00:24:02,030
但是，如果 - 

482
00:24:02,030 --> 00:24:03,280
大家可以看到這個？

483
00:24:03,280 --> 00:24:07,230

484
00:24:07,230 --> 00:24:11,610
如果我們是平等的我們該怎麼做？

485
00:24:11,610 --> 00:24:15,740
如果這個值我們試圖插入
等於該節點的值？

486
00:24:15,740 --> 00:24:16,320
是嗎？

487
00:24:16,320 --> 00:24:18,400
>> 觀眾：[聽不清]。

488
00:24:18,400 --> 00:24:18,850
>> JASON HIRSCHORN：是啊。

489
00:24:18,850 --> 00:24:19,290
鑑於這一點 - 

490
00:24:19,290 --> 00:24:20,090
馬庫斯是正確的。

491
00:24:20,090 --> 00:24:21,330
我們也可以或許做
不同的東西。

492
00:24:21,330 --> 00:24:25,360
但鑑於我們已經創造了它，在這裡
我們應該釋放，然後返回。

493
00:24:25,360 --> 00:24:26,774
哦男孩。

494
00:24:26,774 --> 00:24:30,080
是更好嗎？

495
00:24:30,080 --> 00:24:31,850
怎麼樣？

496
00:24:31,850 --> 00:24:33,100
確定。

497
00:24:33,100 --> 00:24:35,360

498
00:24:35,360 --> 00:24:37,640
免費，然後我們怎麼辦
返回[聽不清]？

499
00:24:37,640 --> 00:24:41,330

500
00:24:41,330 --> 00:24:44,110
確定。

501
00:24:44,110 --> 00:24:45,360
我們是否缺少什麼？

502
00:24:45,360 --> 00:24:53,500

503
00:24:53,500 --> 00:24:59,650
那麼，我們要跟踪
事先節點？

504
00:24:59,650 --> 00:25:02,370
>> 觀眾：我覺得它會去
之後創建一個新的節點。

505
00:25:02,370 --> 00:25:02,600
>> JASON HIRSCHORN：確定。

506
00:25:02,600 --> 00:25:03,940
所以，在一開始我們可能會 - 

507
00:25:03,940 --> 00:25:07,175
是的，我們可以創建一個指向新
節點，就像前一個節點的指針和

508
00:25:07,175 --> 00:25:09,600
當前節點的指針。

509
00:25:09,600 --> 00:25:12,640
因此，讓我們插入這裡。

510
00:25:12,640 --> 00:25:15,610

511
00:25:15,610 --> 00:25:26,900
創建當前和以前
指向的節點。

512
00:25:26,900 --> 00:25:28,955
但是，當我們調整這些指針？

513
00:25:28,955 --> 00:25:30,205
我們在哪裡做的代碼？

514
00:25:30,205 --> 00:25:33,830

515
00:25:33,830 --> 00:25:34,160
傑夫？

516
00:25:34,160 --> 00:25:35,170
>> 觀眾： - 值條件是什麼？

517
00:25:35,170 --> 00:25:36,420
>> JASON HIRSCHORN：哪
一個特殊？

518
00:25:36,420 --> 00:25:39,862

519
00:25:39,862 --> 00:25:40,720
>> 觀眾：我只是困惑。

520
00:25:40,720 --> 00:25:44,200
如果值大於這個節點，
並不意味著你要去

521
00:25:44,200 --> 00:25:45,320
到下一個節點？

522
00:25:45,320 --> 00:25:49,515
>> JASON HIRSCHHORN：所以，如果我們的價值
大於該節點的值。

523
00:25:49,515 --> 00:25:52,130
>> 觀眾：是啊，那你想要
進一步向下行去，對不對？

524
00:25:52,130 --> 00:25:52,590
>> JASON HIRSCHHORN：對。

525
00:25:52,590 --> 00:25:53,840
所以我們不要插入在這裡。

526
00:25:53,840 --> 00:25:58,430

527
00:25:58,430 --> 00:26:03,240
如果值小於當前節點，然後
我們進入下一個節點 - 或者那我們

528
00:26:03,240 --> 00:26:03,835
前插入。

529
00:26:03,835 --> 00:26:05,966
>> 觀眾：等一下，這是本
節點，這是價值？

530
00:26:05,966 --> 00:26:08,510

531
00:26:08,510 --> 00:26:09,280
>> JASON HIRSCHHORN：好問題。

532
00:26:09,280 --> 00:26:13,260
根據該函數的定義值
就是我們給出。

533
00:26:13,260 --> 00:26:16,910
因此，價值是我們給出的數字。

534
00:26:16,910 --> 00:26:21,120
因此，如果該值小於該
節點，我們需要時間來插入。

535
00:26:21,120 --> 00:26:24,575
如果值大於這個節點，
我們去到下一個節點。

536
00:26:24,575 --> 00:26:26,790
再回到原來的問題，
不過，在這裡 - 

537
00:26:26,790 --> 00:26:29,060
>> 觀眾：如果值大於
比這個節點。

538
00:26:29,060 --> 00:26:30,310
>> JASON HIRSCHHORN：所以
我們該怎麼做嗎？

539
00:26:30,310 --> 00:26:36,790

540
00:26:36,790 --> 00:26:38,160
甜蜜。

541
00:26:38,160 --> 00:26:38,860
這是正確的。

542
00:26:38,860 --> 00:26:41,370
我只是去寫
更新指針。

543
00:26:41,370 --> 00:26:44,010
但是，是的，與當前的
你會更新到

544
00:26:44,010 --> 00:26:46,080
指向下一個。

545
00:26:46,080 --> 00:26:47,330
別的我們缺少什麼？

546
00:26:47,330 --> 00:26:52,710

547
00:26:52,710 --> 00:26:54,940
所以，我要輸入此
編碼成gedit的。

548
00:26:54,940 --> 00:26:58,375
而我做到這一點，你可以有一個
夫婦多鐘上班編碼

549
00:26:58,375 --> 00:28:19,240
這在C

550
00:28:19,240 --> 00:28:20,940
>> 所以，我有輸入的偽代碼。

551
00:28:20,940 --> 00:28:22,940
一個快速的音符在我們開始之前。

552
00:28:22,940 --> 00:28:25,560
我們未必能夠完全
在完成所有這

553
00:28:25,560 --> 00:28:27,300
這三個功能。

554
00:28:27,300 --> 00:28:30,630
有正確的解決辦法
我會發電子郵件到你們

555
00:28:30,630 --> 00:28:33,730
部後，它會
張貼在CS50.net。

556
00:28:33,730 --> 00:28:35,640
所以我不鼓勵你
去看看部分。

557
00:28:35,640 --> 00:28:40,550
我鼓勵你在嘗試這些你
自己，然後用實踐

558
00:28:40,550 --> 00:28:41,760
問題來檢查你的答案。

559
00:28:41,760 --> 00:28:47,070
這些都被設計成緊密
與堅持什麼

560
00:28:47,070 --> 00:28:48,400
你所要做的習題集。

561
00:28:48,400 --> 00:28:53,820
因此，我鼓勵你練習這個
在你自己的，然後使用代碼

562
00:28:53,820 --> 00:28:54,660
檢查你的答案。

563
00:28:54,660 --> 00:28:57,060
因為我確實想移動到哈希
表在某些部分點。

564
00:28:57,060 --> 00:28:58,150
因此，我們可能不會得到通過這一切。

565
00:28:58,150 --> 00:28:59,960
但我們現在會做盡可能多的，我們可以。

566
00:28:59,960 --> 00:29:00,370
>> 確定。

567
00:29:00,370 --> 00:29:01,960
讓我們開始吧。

568
00:29:01,960 --> 00:29:04,770
阿薩姆，我們如何創建一個新的節點？

569
00:29:04,770 --> 00:29:06,810
>> 觀眾：你STRUCT *。

570
00:29:06,810 --> 00:29:09,640
>> JASON HIRSCHHORN：所以我們
有一個在這裡。

571
00:29:09,640 --> 00:29:10,040
哦，對不起。

572
00:29:10,040 --> 00:29:13,530
你是說結構*。

573
00:29:13,530 --> 00:29:17,260
>> 觀眾：然後[？樣？]
節點或c節點。

574
00:29:17,260 --> 00:29:17,780
>> JASON HIRSCHHORN：確定。

575
00:29:17,780 --> 00:29:19,740
我要叫它new_node
所以我們可以保持一致。

576
00:29:19,740 --> 00:29:22,646

577
00:29:22,646 --> 00:29:33,180
>> 觀眾：你要設置的
頭，第一個節點。

578
00:29:33,180 --> 00:29:33,580
>> JASON HIRSCHHORN：確定。

579
00:29:33,580 --> 00:29:37,290
所以，現在這個指向 - 所以這
還沒有創建一個新的節點呢。

580
00:29:37,290 --> 00:29:41,380
這僅僅是指向
列表中的第一個節點。

581
00:29:41,380 --> 00:29:42,630
我如何創建一個新的節點？

582
00:29:42,630 --> 00:29:45,490

583
00:29:45,490 --> 00:29:48,070
如果我需要空間來創建一個新的節點。

584
00:29:48,070 --> 00:29:49,230
malloc的。

585
00:29:49,230 --> 00:29:51,710
有多大？

586
00:29:51,710 --> 00:30:00,390
>> 觀眾：結構體的大小。

587
00:30:00,390 --> 00:30:01,150
>> JASON HIRSCHHORN：該
該結構的大小。

588
00:30:01,150 --> 00:30:02,400
和什麼所謂的結構？

589
00:30:02,400 --> 00:30:09,670

590
00:30:09,670 --> 00:30:09,840
>> 觀眾：節點？

591
00:30:09,840 --> 00:30:11,640
>> JASON HIRSCHHORN：節點。

592
00:30:11,640 --> 00:30:17,640
所以的malloc（的sizeof（節點））;
給我們空間。

593
00:30:17,640 --> 00:30:19,740
而就是這條線 - 

594
00:30:19,740 --> 00:30:21,740
有一件事是不正確的這條線。

595
00:30:21,740 --> 00:30:24,430
是new_node一個指向結構的指針？

596
00:30:24,430 --> 00:30:25,650
這是一個通用名稱。

597
00:30:25,650 --> 00:30:26,520
這是什麼 - 

598
00:30:26,520 --> 00:30:27,450
節點，沒錯。

599
00:30:27,450 --> 00:30:29,340
這是一個結點*。

600
00:30:29,340 --> 00:30:33,010
右後我們該怎麼做
我們malloc的東西，阿三？

601
00:30:33,010 --> 00:30:34,476
什麼是我們做的第一件事？

602
00:30:34,476 --> 00:30:38,850

603
00:30:38,850 --> 00:30:40,320
如果它不工作？

604
00:30:40,320 --> 00:30:42,430
>> 觀眾：哦，檢查它是否
指向的節點？

605
00:30:42,430 --> 00:30:43,310
>> JASON HIRSCHHORN：沒錯。

606
00:30:43,310 --> 00:30:46,750
所以，如果你new_node等於等於
空，我們該怎麼做？

607
00:30:46,750 --> 00:30:51,650

608
00:30:51,650 --> 00:30:54,820
這會返回一個布爾值，此功能。

609
00:30:54,820 --> 00:30:57,760
沒錯。

610
00:30:57,760 --> 00:30:58,450
看起來不錯。

611
00:30:58,450 --> 00:30:59,680
什麼要補充的嗎？

612
00:30:59,680 --> 00:31:00,670
我們會在末尾添加的東西。

613
00:31:00,670 --> 00:31:03,160
但是，到目前為止，看起來不錯。

614
00:31:03,160 --> 00:31:06,170
創建當前和以前的指針。

615
00:31:06,170 --> 00:31:08,650
邁克爾，我該怎麼辦呢？

616
00:31:08,650 --> 00:31:12,810
>> 觀眾：你將不得不
做一個結點*。

617
00:31:12,810 --> 00:31:21,800

618
00:31:21,800 --> 00:31:25,502
你必須做一個不
為new_node但對於

619
00:31:25,502 --> 00:31:26,905
節點我們已經有了。

620
00:31:26,905 --> 00:31:27,230
>> JASON HIRSCHHORN：確定。

621
00:31:27,230 --> 00:31:29,255
因此，在當前節點我們是在。

622
00:31:29,255 --> 00:31:30,505
我會打電話給那個CURR。

623
00:31:30,505 --> 00:31:39,650

624
00:31:39,650 --> 00:31:39,770
好的。

625
00:31:39,770 --> 00:31:41,620
我們已經決定，我們希望保持
2，因為我們需要知道

626
00:31:41,620 --> 00:31:42,870
什麼才。

627
00:31:42,870 --> 00:31:45,770

628
00:31:45,770 --> 00:31:47,020
他們得到什麼初始化？

629
00:31:47,020 --> 00:31:49,874

630
00:31:49,874 --> 00:31:54,180
>> 觀眾：他們在我們的列表值。

631
00:31:54,180 --> 00:31:58,090
>> JASON HIRSCHHORN：那麼什麼是
我們的名單上的第一件事？

632
00:31:58,090 --> 00:32:04,050
或者，我們怎麼知道在哪裡
一開始我們的名單是什麼？

633
00:32:04,050 --> 00:32:08,015
>> 觀眾：是不是應該通過
進入功能？

634
00:32:08,015 --> 00:32:08,466
>> JASON HIRSCHHORN：對。

635
00:32:08,466 --> 00:32:09,716
它是通過在這裡。

636
00:32:09,716 --> 00:32:15,910

637
00:32:15,910 --> 00:32:18,980
這樣，如果它的傳遞給函數，該
啟動列表中，我們應該怎樣

638
00:32:18,980 --> 00:32:21,270
設置電流等於？

639
00:32:21,270 --> 00:32:22,110
>> 觀眾：列表。

640
00:32:22,110 --> 00:32:22,900
>> JASON HIRSCHHORN：列表。

641
00:32:22,900 --> 00:32:24,090
這是完全正確的。

642
00:32:24,090 --> 00:32:26,290
現在，它擁有的地址
我們的列表的開始。

643
00:32:26,290 --> 00:32:28,450
又是怎麼回事以前？

644
00:32:28,450 --> 00:32:31,920
>> 觀眾：原價減一？

645
00:32:31,920 --> 00:32:32,690
>> JASON HIRSCHHORN：有
什麼才。

646
00:32:32,690 --> 00:32:34,580
所以，我們能做些什麼來表示什麼？

647
00:32:34,580 --> 00:32:35,050
>> 觀眾：空。

648
00:32:35,050 --> 00:32:35,450
>> JASON HIRSCHHORN：是啊。

649
00:32:35,450 --> 00:32:37,950
這聽起來是個好主意。

650
00:32:37,950 --> 00:32:38,360
完美的。

651
00:32:38,360 --> 00:32:39,630
謝謝。

652
00:32:39,630 --> 00:32:42,850
經過列表。

653
00:32:42,850 --> 00:32:45,490
康斯坦丁，多久我們要
要經過的名單？

654
00:32:45,490 --> 00:32:49,010
>> 觀眾：直到我們到達空。

655
00:32:49,010 --> 00:32:49,390
>> JASON HIRSCHHORN：確定。

656
00:32:49,390 --> 00:32:50,430
所以，如果，而對於循環。

657
00:32:50,430 --> 00:32:52,200
我們在做什麼？

658
00:32:52,200 --> 00:32:53,320
>> 觀眾：也許一個for循環？

659
00:32:53,320 --> 00:32:53,910
>> JASON HIRSCHHORN：讓我們做一個for循環。

660
00:32:53,910 --> 00:32:55,870
確定。

661
00:32:55,870 --> 00:33:02,465
>> 觀眾：我們說的 - 

662
00:33:02,465 --> 00:33:09,764

663
00:33:09,764 --> 00:33:13,390
直到當前指針
不等於空。

664
00:33:13,390 --> 00:33:19,160
>> JASON HIRSCHHORN：所以，如果我們知道
條件下，我們怎麼能寫一個循環

665
00:33:19,160 --> 00:33:21,740
根據關閉的狀態。

666
00:33:21,740 --> 00:33:24,380
我們應該使用什麼樣的循環？

667
00:33:24,380 --> 00:33:25,260
>> 觀眾：雖然。

668
00:33:25,260 --> 00:33:25,590
>> JASON HIRSCHHORN：是啊。

669
00:33:25,590 --> 00:33:27,130
這使得基於更有意義
關閉你說什麼。

670
00:33:27,130 --> 00:33:29,430
如果我們只是想進入我們它會
只知道那個東西，它將使

671
00:33:29,430 --> 00:33:31,680
踏踏實實做一個while循環。

672
00:33:31,680 --> 00:33:39,880
而當前不等於空值，
如果值小於該節點。

673
00:33:39,880 --> 00:33:41,650
AKSHAR，給我這條線。

674
00:33:41,650 --> 00:33:48,810

675
00:33:48,810 --> 00:33:56,955
>> 觀眾：如果電流>Ñ
Ñ​​低於價值。

676
00:33:56,955 --> 00:34:00,170

677
00:34:00,170 --> 00:34:03,260
或推翻。

678
00:34:03,260 --> 00:34:06,140
開關的支架。

679
00:34:06,140 --> 00:34:06,620
>> JASON HIRSCHHORN：對不起。

680
00:34:06,620 --> 00:34:08,760
>> 觀眾：更換支架。

681
00:34:08,760 --> 00:34:10,914
>> JASON HIRSCHHORN：所以，如果它是
比價值更大。

682
00:34:10,914 --> 00:34:18,719

683
00:34:18,719 --> 00:34:22,120
因為這是混亂的
上面的評論，我會做到這一點。

684
00:34:22,120 --> 00:34:22,480
但肯定的。

685
00:34:22,480 --> 00:34:25,125
如果我們的價值低於本
節點，我們該怎麼做？

686
00:34:25,125 --> 00:34:25,540
呵呵。

687
00:34:25,540 --> 00:34:26,710
我就在這裡。

688
00:34:26,710 --> 00:34:27,960
前插入。

689
00:34:27,960 --> 00:34:32,080

690
00:34:32,080 --> 00:34:32,370
確定。

691
00:34:32,370 --> 00:34:33,933
我們該怎麼做呢？

692
00:34:33,933 --> 00:34:34,900
>> 觀眾：是不是還是我？

693
00:34:34,900 --> 00:34:36,150
>> JASON HIRSCHHORN：是啊。

694
00:34:36,150 --> 00:34:38,520

695
00:34:38,520 --> 00:34:39,770
>> 觀眾：你 - 

696
00:34:39,770 --> 00:34:42,909

697
00:34:42,909 --> 00:34:44,159
new_node  - >下一個。

698
00:34:44,159 --> 00:34:46,770

699
00:34:46,770 --> 00:34:50,163
>> JASON HIRSCHHORN：那麼什麼是
這將等於？

700
00:34:50,163 --> 00:34:52,070
>> 觀眾：這將相等的電流。

701
00:34:52,070 --> 00:34:53,889
>> JASON HIRSCHHORN：沒錯。

702
00:34:53,889 --> 00:34:55,730
這樣一來，其他 - 

703
00:34:55,730 --> 00:34:56,730
我們需要更新什麼？

704
00:34:56,730 --> 00:34:59,982
>> 觀眾：檢查過去等於null。

705
00:34:59,982 --> 00:35:01,870
>> JASON HIRSCHHORN：如果上一個 - 

706
00:35:01,870 --> 00:35:03,730
所以，如果前一個等於null。

707
00:35:03,730 --> 00:35:05,990
>> 觀眾：這意味著它是怎麼回事
成為頭部。

708
00:35:05,990 --> 00:35:06,780
>> JASON HIRSCHHORN：這意味著
它已經成為了頭。

709
00:35:06,780 --> 00:35:07,620
這樣的話我們該怎麼做？

710
00:35:07,620 --> 00:35:12,510
>> 觀眾：我們做頭部等於new_node。

711
00:35:12,510 --> 00:35:16,690
>> JASON HIRSCHHORN：頭
等於new_node。

712
00:35:16,690 --> 00:35:20,540
以及為什麼在這裡頭，沒有列出？

713
00:35:20,540 --> 00:35:24,940
>> 觀眾：因為頭是一個全球性的
變量，它是起始位。

714
00:35:24,940 --> 00:35:26,190
>> JASON HIRSCHHORN：甜。

715
00:35:26,190 --> 00:35:33,750

716
00:35:33,750 --> 00:35:34,170
確定。

717
00:35:34,170 --> 00:35:36,150
和 - 

718
00:35:36,150 --> 00:35:53,796
>> 觀眾：那你別的上一頁 - >
接下來等於new_node。

719
00:35:53,796 --> 00:35:55,080
然後返回true。

720
00:35:55,080 --> 00:35:59,560

721
00:35:59,560 --> 00:36:02,700
>> JASON HIRSCHHORN：在哪裡做
我們設置new_node結束了嗎？

722
00:36:02,700 --> 00:36:04,850
>> 觀眾：我會 - 

723
00:36:04,850 --> 00:36:06,180
我設置的開始。

724
00:36:06,180 --> 00:36:07,430
>> JASON HIRSCHHORN：那麼什麼線？

725
00:36:07,430 --> 00:36:10,000

726
00:36:10,000 --> 00:36:12,598
>> 觀眾：在if語句
如果它被稱為檢查。

727
00:36:12,598 --> 00:36:13,057
>> JASON HIRSCHHORN：就在這裡？

728
00:36:13,057 --> 00:36:18,335
>> 觀眾：我願意做new_node  - >Ñ
等於價值。

729
00:36:18,335 --> 00:36:19,585
>> JASON HIRSCHHORN：聽起來不錯。

730
00:36:19,585 --> 00:36:21,740

731
00:36:21,740 --> 00:36:25,090
也許這是有道理的 - 我們不這樣做
要知道我們是在什麼名單

732
00:36:25,090 --> 00:36:26,280
因為我們只處理
用一個列表。

733
00:36:26,280 --> 00:36:29,560
因此，一個更好的函數聲明為
這只是為了擺脫這種

734
00:36:29,560 --> 00:36:34,360
完全和剛插入
一個值到頭部。

735
00:36:34,360 --> 00:36:35,930
我們甚至不需要知道
我們在做什麼榜單中。

736
00:36:35,930 --> 00:36:39,140
但我會保持它現在和
那麼在更新變化

737
00:36:39,140 --> 00:36:42,590
幻燈片和代碼。

738
00:36:42,590 --> 00:36:44,980
所以，看起來很不錯的了。

739
00:36:44,980 --> 00:36:46,560
如果值 - 誰可以做這行？

740
00:36:46,560 --> 00:36:47,810
如果 - 

741
00:36:47,810 --> 00:36:52,240

742
00:36:52,240 --> 00:36:53,840
我們該怎麼做在這裡，諾亞。

743
00:36:53,840 --> 00:36:57,890

744
00:36:57,890 --> 00:37:07,100
>> 觀眾：如果值大於
比CURR  - >北 - 

745
00:37:07,100 --> 00:37:16,830

746
00:37:16,830 --> 00:37:18,240
>> JASON HIRSCHHORN：如何做
我們進入下一個節點？

747
00:37:18,240 --> 00:37:27,760

748
00:37:27,760 --> 00:37:30,530
>> 觀眾：CURR-> n是
等於new_node。

749
00:37:30,530 --> 00:37:37,630

750
00:37:37,630 --> 00:37:39,195
>> JASON HIRSCHHORN：那麼n是
什麼樣的結構的一部分？

751
00:37:39,195 --> 00:37:43,065

752
00:37:43,065 --> 00:37:46,020
整數。

753
00:37:46,020 --> 00:37:50,420
和new_node是一個指針，指向的節點。

754
00:37:50,420 --> 00:37:51,880
因此，我們應該更新什麼CURR的一部分？

755
00:37:51,880 --> 00:38:03,900

756
00:38:03,900 --> 00:38:05,400
如果沒有n，那麼有什麼其他部分？

757
00:38:05,400 --> 00:38:21,680

758
00:38:21,680 --> 00:38:22,810
諾亞，有什麼其他部分。

759
00:38:22,810 --> 00:38:23,570
>> 觀眾：呵呵，下次。

760
00:38:23,570 --> 00:38:25,645
>> JASON HIRSCHHORN：下一步，沒錯。

761
00:38:25,645 --> 00:38:26,410
沒錯。

762
00:38:26,410 --> 00:38:28,770
接下來是正確的。

763
00:38:28,770 --> 00:38:31,540
還有什麼我們需要
更新，諾亞？

764
00:38:31,540 --> 00:38:32,840
>> 觀眾：該指針。

765
00:38:32,840 --> 00:38:34,840
>> JASON HIRSCHHORN：所以
我們更新了電流。

766
00:38:34,840 --> 00:38:36,090
>> 觀眾：上一頁 - >下一個。

767
00:38:36,090 --> 00:38:48,160

768
00:38:48,160 --> 00:38:49,410
>> JASON HIRSCHHORN：是啊。

769
00:38:49,410 --> 00:38:57,465

770
00:38:57,465 --> 00:38:58,370
OK，我們會暫停。

771
00:38:58,370 --> 00:39:02,200
誰可以幫助我們在這裡？

772
00:39:02,200 --> 00:39:03,385
馬努，我們應該怎樣做？

773
00:39:03,385 --> 00:39:05,615
>> 觀眾：你一定要設置
它等於CURR  - >下一個。

774
00:39:05,615 --> 00:39:09,110

775
00:39:09,110 --> 00:39:11,630
但做到這一點之前的前行。

776
00:39:11,630 --> 00:39:12,880
>> JASON HIRSCHHORN：確定。

777
00:39:12,880 --> 00:39:16,590

778
00:39:16,590 --> 00:39:18,260
還有別的嗎？

779
00:39:18,260 --> 00:39:19,170
AKSHAR。

780
00:39:19,170 --> 00:39:22,680
>> 觀眾：我不認為你是
為了改變未來CURR->。

781
00:39:22,680 --> 00:39:29,270
我覺得你的意思做CURR等於
CURR  - >下次去到下一個節點。

782
00:39:29,270 --> 00:39:30,500
>> JASON HIRSCHHORN：那麼對不起，在哪裡？

783
00:39:30,500 --> 00:39:32,680
在哪一行？

784
00:39:32,680 --> 00:39:33,420
這條線？

785
00:39:33,420 --> 00:39:33,750
>> 觀眾：是啊。

786
00:39:33,750 --> 00:39:35,745
讓CURR等於CURR  - >下一個。

787
00:39:35,745 --> 00:39:39,690

788
00:39:39,690 --> 00:39:43,360
>> JASON HIRSCHHORN：所以這是正確的
因為電流是

789
00:39:43,360 --> 00:39:45,220
指針到一個節點。

790
00:39:45,220 --> 00:39:48,550
我們希望它指向下一個
什麼是越來越當前節點

791
00:39:48,550 --> 00:39:49,930
指出。

792
00:39:49,930 --> 00:39:54,410
CURR本身所具有的未來。

793
00:39:54,410 --> 00:39:58,620
但如果我們要更新curr.next，我們
將更新的實際音符

794
00:39:58,620 --> 00:40:01,430
本身，而不是這個地方
指針指著。

795
00:40:01,430 --> 00:40:02,680
那麼這條線，雖然。

796
00:40:02,680 --> 00:40:05,160

797
00:40:05,160 --> 00:40:07,330
阿維？

798
00:40:07,330 --> 00:40:09,590
>> 觀眾：上一頁 - >下一次等於CURR。

799
00:40:09,590 --> 00:40:12,500

800
00:40:12,500 --> 00:40:19,440
>> JASON HIRSCHHORN：如此反复，如果上一個是一個
指針指向一個節點，前值 - >下一個是

801
00:40:19,440 --> 00:40:23,020
實際的指針中的節點。

802
00:40:23,020 --> 00:40:27,190
所以這將是一個更新
指針在一個節點CURR。

803
00:40:27,190 --> 00:40:28,570
我們不希望更新
指針中的一個節點。

804
00:40:28,570 --> 00:40:30,570
我們要更新以前。

805
00:40:30,570 --> 00:40:31,850
那麼，如何才能做到這一點？

806
00:40:31,850 --> 00:40:34,250
>> 觀眾：這純粹是上一個。

807
00:40:34,250 --> 00:40:34,565
>> JASON HIRSCHHORN：對。

808
00:40:34,565 --> 00:40:35,560
上一個是指向的節點。

809
00:40:35,560 --> 00:40:38,750
現在，我們正在改變到一個
新的指針的節點。

810
00:40:38,750 --> 00:40:40,830
OK，讓我們向下移動。

811
00:40:40,830 --> 00:40:41,940
最後，這最後一個條件。

812
00:40:41,940 --> 00:40:44,896
傑夫，我們該怎麼做嗎？

813
00:40:44,896 --> 00:40:47,515
>> 觀眾：如果值是
等於CURR->ñ。

814
00:40:47,515 --> 00:40:51,030

815
00:40:51,030 --> 00:40:51,300
>> JASON HIRSCHHORN：對不起。

816
00:40:51,300 --> 00:40:52,372
哦，我的天啊。

817
00:40:52,372 --> 00:40:54,330
什麼？

818
00:40:54,330 --> 00:40:55,580
值== CURR->ñ。

819
00:40:55,580 --> 00:41:01,050

820
00:41:01,050 --> 00:41:02,300
我們該怎麼辦？

821
00:41:02,300 --> 00:41:04,760

822
00:41:04,760 --> 00:41:10,950
>> 觀眾：你會釋放我們的new_node，
然後你會返回false。

823
00:41:10,950 --> 00:41:21,410

824
00:41:21,410 --> 00:41:23,460
>> JASON HIRSCHHORN：這是什麼
我們已經寫了這麼遠。

825
00:41:23,460 --> 00:41:25,710
沒有任何人有什麼
加入我們做出過嗎？

826
00:41:25,710 --> 00:41:35,460

827
00:41:35,460 --> 00:41:35,710
確定。

828
00:41:35,710 --> 00:41:36,960
讓我們試試吧。

829
00:41:36,960 --> 00:41:44,180

830
00:41:44,180 --> 00:41:46,110
控制可能到達終點
非void函數。

831
00:41:46,110 --> 00:41:48,310
阿維，這是怎麼回事？

832
00:41:48,310 --> 00:41:51,380
>> 觀眾：你應該把回報
while循環的外面真的嗎？

833
00:41:51,380 --> 00:41:53,900

834
00:41:53,900 --> 00:41:54,400
>> JASON HIRSCHHORN：我不知道。

835
00:41:54,400 --> 00:41:54,780
難道你要我？

836
00:41:54,780 --> 00:41:55,520
>> 觀眾：沒關係。

837
00:41:55,520 --> 00:41:56,350
號

838
00:41:56,350 --> 00:41:57,180
>> JASON HIRSCHHORN：AKSHAR？

839
00:41:57,180 --> 00:41:59,460
>> 觀眾：我覺得你的意思是
把返回false在年底

840
00:41:59,460 --> 00:42:02,230
while循環。

841
00:42:02,230 --> 00:42:03,270
>> JASON HIRSCHHORN：那麼，
你希望它去？

842
00:42:03,270 --> 00:42:05,270
>> 觀眾：像while循環之外。

843
00:42:05,270 --> 00:42:08,800
所以，如果你退出while循環的方式
你已經走到了盡頭，並

844
00:42:08,800 --> 00:42:09,980
什麼也沒有發生過。

845
00:42:09,980 --> 00:42:10,410
>> JASON HIRSCHHORN：確定。

846
00:42:10,410 --> 00:42:12,340
那麼，我們在做什麼在這裡？

847
00:42:12,340 --> 00:42:13,702
>> 觀眾：你返回false
有作為。

848
00:42:13,702 --> 00:42:15,040
>> JASON HIRSCHHORN：哦，我們
這樣做在這兩個地方？

849
00:42:15,040 --> 00:42:15,650
>> 觀眾：是啊。

850
00:42:15,650 --> 00:42:16,900
>> JASON HIRSCHHORN：確定。

851
00:42:16,900 --> 00:42:24,840

852
00:42:24,840 --> 00:42:26,160
我們是否應該去？

853
00:42:26,160 --> 00:42:26,980
哦，我的天啊。

854
00:42:26,980 --> 00:42:27,290
對不起。

855
00:42:27,290 --> 00:42:28,480
我的屏幕道歉。

856
00:42:28,480 --> 00:42:30,530
那種它嚇壞了我們。

857
00:42:30,530 --> 00:42:31,520
因此，選擇一個選項。

858
00:42:31,520 --> 00:42:35,260
零，每代碼，退出程序。

859
00:42:35,260 --> 00:42:36,700
一要插入一些東西。

860
00:42:36,700 --> 00:42:37,990
讓我們來插入三個。

861
00:42:37,990 --> 00:42:42,900

862
00:42:42,900 --> 00:42:45,380
插入未成功。

863
00:42:45,380 --> 00:42:46,500
我要打印出來。

864
00:42:46,500 --> 00:42:48,050
我沒有任何東西。

865
00:42:48,050 --> 00:42:48,450
確定。

866
00:42:48,450 --> 00:42:50,250
也許這只是一個僥倖。

867
00:42:50,250 --> 00:42:52,810
插一句。

868
00:42:52,810 --> 00:42:55,770
沒有成功。

869
00:42:55,770 --> 00:42:57,470
確定。

870
00:42:57,470 --> 00:43:02,400
讓我們通過GDB真的快速運行
要看看是怎麼回事。

871
00:43:02,400 --> 00:43:06,055
>> 還記得GDB /姓名您的
計劃將引領我們進入GDB。

872
00:43:06,055 --> 00:43:07,610
是很多來處理？

873
00:43:07,610 --> 00:43:08,560
閃爍的？

874
00:43:08,560 --> 00:43:10,400
也許吧。

875
00:43:10,400 --> 00:43:12,760
閉上你的眼睛，並採取一些深
如果你厭倦了喘氣，呼吸的

876
00:43:12,760 --> 00:43:13,580
看著它。

877
00:43:13,580 --> 00:43:14,200
我在廣發行。

878
00:43:14,200 --> 00:43:15,830
什麼是我做的第一件事在廣發行？

879
00:43:15,830 --> 00:43:17,050
我們必須搞清楚
這是怎麼回事。

880
00:43:17,050 --> 00:43:17,310
讓我們來看看。

881
00:43:17,310 --> 00:43:21,650
我們有六分鐘圖
發生了什麼事情。

882
00:43:21,650 --> 00:43:22,900
突破為主。

883
00:43:22,900 --> 00:43:25,950

884
00:43:25,950 --> 00:43:28,130
然後我該怎麼辦？

885
00:43:28,130 --> 00:43:29,180
卡洛斯？

886
00:43:29,180 --> 00:43:31,060
運行。

887
00:43:31,060 --> 00:43:32,250
確定。

888
00:43:32,250 --> 00:43:34,160
讓我們選擇一個選項。

889
00:43:34,160 --> 00:43:36,330
又是什麼Ñ辦？

890
00:43:36,330 --> 00:43:38,480
下一步。

891
00:43:38,480 --> 00:43:38,950
是啊。

892
00:43:38,950 --> 00:43:39,740
>> 觀眾：你沒提 - 

893
00:43:39,740 --> 00:43:45,230
沒有你說的那個頭，那是
初始化為null開頭。

894
00:43:45,230 --> 00:43:47,140
不過，我想你說還行。

895
00:43:47,140 --> 00:43:50,040

896
00:43:50,040 --> 00:43:52,640
>> JASON HIRSCHHORN：讓我們去 - 讓我們來看看
在GDB中，然後我們就回去。

897
00:43:52,640 --> 00:43:54,910
但它聽起來像你已經有
一些想法發生了什麼事情。

898
00:43:54,910 --> 00:43:58,340
因此，我們要插入一些東西。

899
00:43:58,340 --> 00:43:59,390
確定。

900
00:43:59,390 --> 00:44:00,150
我們已經插入。

901
00:44:00,150 --> 00:44:00,770
請輸入一個整數。

902
00:44:00,770 --> 00:44:01,990
我們會插入三個。

903
00:44:01,990 --> 00:44:03,000
然後我在這行。

904
00:44:03,000 --> 00:44:07,030
我該如何去開始調試
插入已知的功能？

905
00:44:07,030 --> 00:44:08,280
哦，我的天啊。

906
00:44:08,280 --> 00:44:10,990

907
00:44:10,990 --> 00:44:12,240
這是一個很多。

908
00:44:12,240 --> 00:44:14,372

909
00:44:14,372 --> 00:44:16,445
是嚇壞了很多嗎？

910
00:44:16,445 --> 00:44:19,696

911
00:44:19,696 --> 00:44:21,680
>> 觀眾：哦，它死了。

912
00:44:21,680 --> 00:44:22,930
>> JASON HIRSCHHORN：我剛
拉出來。

913
00:44:22,930 --> 00:44:27,364

914
00:44:27,364 --> 00:44:28,310
確定。

915
00:44:28,310 --> 00:44:29,560
>> 觀眾：也許這是
導線的另一端。

916
00:44:29,560 --> 00:44:37,000

917
00:44:37,000 --> 00:44:39,470
>> JASON HIRSCHHORN：哇。

918
00:44:39,470 --> 00:44:42,330
因此，底線 - 

919
00:44:42,330 --> 00:44:43,470
你說什麼？

920
00:44:43,470 --> 00:44:46,040
>> 觀眾：我說的技術上的諷刺
困難在這個類中。

921
00:44:46,040 --> 00:44:46,410
>> JASON HIRSCHHORN：我知道。

922
00:44:46,410 --> 00:44:48,660
如果我有過這部分控制權。

923
00:44:48,660 --> 00:44:49,910
[聽不清]

924
00:44:49,910 --> 00:44:54,430

925
00:44:54,430 --> 00:44:55,400
這聽起來不錯。

926
00:44:55,400 --> 00:44:58,680
為什麼你們不開始思考
我們可能做錯了，

927
00:44:58,680 --> 00:45:01,140
我們將回到90秒。

928
00:45:01,140 --> 00:46:18,160

929
00:46:18,160 --> 00:46:23,010
>> Avica，我要問你怎麼走
裡面insert_node調試它。

930
00:46:23,010 --> 00:46:28,940

931
00:46:28,940 --> 00:46:31,460
所以這是我們最後離開的。

932
00:46:31,460 --> 00:46:35,110
我怎麼進去insert_node，Avica，
檢查是怎麼回事？

933
00:46:35,110 --> 00:46:36,360
什麼GDB命令？

934
00:46:36,360 --> 00:46:41,050

935
00:46:41,050 --> 00:46:42,390
休息也不會帶我裡面。

936
00:46:42,390 --> 00:46:46,200

937
00:46:46,200 --> 00:46:47,130
請問侯爵夫人知道嗎？

938
00:46:47,130 --> 00:46:48,240
>> 觀眾：是什麼？

939
00:46:48,240 --> 00:46:51,780
>> JASON HIRSCHHORN：什麼GDB命令
我用走這個函數裡面？

940
00:46:51,780 --> 00:46:52,070
>> 觀眾：步驟？

941
00:46:52,070 --> 00:46:55,140
>> JASON HIRSCHHORN：通過步驟
S.這裡面需要我。

942
00:46:55,140 --> 00:46:55,476
確定。

943
00:46:55,476 --> 00:46:58,040
New_node mallocing一些空間。

944
00:46:58,040 --> 00:46:59,120
這一切看起來像它去。

945
00:46:59,120 --> 00:47:00,370
讓我們來看看new_node。

946
00:47:00,370 --> 00:47:03,270

947
00:47:03,270 --> 00:47:05,410
它得到了一些內存地址。

948
00:47:05,410 --> 00:47:07,440
讓我們來看看 - 

949
00:47:07,440 --> 00:47:08,500
這是正確的。

950
00:47:08,500 --> 00:47:12,220
所以，這裡的一切似乎
可以正常工作。

951
00:47:12,220 --> 00:47:14,530
>> 觀眾：有什麼區別
之間的P和顯示器？

952
00:47:14,530 --> 00:47:16,160
>> JASON HIRSCHHORN：P代表打印。

953
00:47:16,160 --> 00:47:19,310
所以你問有什麼
那這之間的區別？

954
00:47:19,310 --> 00:47:22,330
在這種情況下，沒有什麼。

955
00:47:22,330 --> 00:47:26,960
但一般有
一些差異。

956
00:47:26,960 --> 00:47:28,220
而且你應該看看在GDB手冊。

957
00:47:28,220 --> 00:47:29,560
但在這種情況下，沒有什麼。

958
00:47:29,560 --> 00:47:31,460
我們傾向於使用打印，但因為
我們並不需要做得更多，不

959
00:47:31,460 --> 00:47:33,960
打印單個值。

960
00:47:33,960 --> 00:47:34,640
>> 確定。

961
00:47:34,640 --> 00:47:40,300
因此，我們對我們的代碼80行，
設置節點* CURR等於列表。

962
00:47:40,300 --> 00:47:42,500
讓我們打印出CURR。

963
00:47:42,500 --> 00:47:45,260

964
00:47:45,260 --> 00:47:46,840
它等於列表。

965
00:47:46,840 --> 00:47:48,850
甜蜜。

966
00:47:48,850 --> 00:47:49,340
等待。

967
00:47:49,340 --> 00:47:50,590
它等於什麼。

968
00:47:50,590 --> 00:47:53,680

969
00:47:53,680 --> 00:47:56,190
這看起來不正確。

970
00:47:56,190 --> 00:47:56,840
我們走吧。

971
00:47:56,840 --> 00:47:59,470
這是因為在GDB中，右，如果
這是你在這行

972
00:47:59,470 --> 00:48:00,330
還沒有執行。

973
00:48:00,330 --> 00:48:03,100
所以，你需要實際輸入
執行下一行

974
00:48:03,100 --> 00:48:05,230
之前看到它的結果。

975
00:48:05,230 --> 00:48:06,680
所以，我們在這裡。

976
00:48:06,680 --> 00:48:09,490
我們只是執行這條線，
以前等於null。

977
00:48:09,490 --> 00:48:13,590
如此反复，如果我們以前的打印
我們將不會看到什麼奇怪。

978
00:48:13,590 --> 00:48:18,680
但是，如果我們實際執行的
行，那麼我們會看到

979
00:48:18,680 --> 00:48:20,380
即該行的工作。

980
00:48:20,380 --> 00:48:21,060
>> 因此，我們有CURR。

981
00:48:21,060 --> 00:48:23,180
這些都是很好的。

982
00:48:23,180 --> 00:48:24,010
對不對？

983
00:48:24,010 --> 00:48:28,130
現在，我們在這條線就在這裡。

984
00:48:28,130 --> 00:48:29,310
雖然CURR不等於空。

985
00:48:29,310 --> 00:48:31,110
那麼，有哪些呢CURR相等？

986
00:48:31,110 --> 00:48:32,450
我們只是看到它等於空。

987
00:48:32,450 --> 00:48:33,210
我們把它打印出來。

988
00:48:33,210 --> 00:48:35,110
我會再次把它打印出來。

989
00:48:35,110 --> 00:48:36,720
所以是while循環
去執行？

990
00:48:36,720 --> 00:48:37,270
>> 觀眾：號

991
00:48:37,270 --> 00:48:39,790
>> JASON HIRSCHHORN：所以，當我輸入了
行，你看我們跳了一路

992
00:48:39,790 --> 00:48:41,390
下到谷底，返回false。

993
00:48:41,390 --> 00:48:44,520
然後我們要返回false
然後回到我們的節目和

994
00:48:44,520 --> 00:48:48,020
最終打印出來，就像我們所看到的，
插入沒有成功。

995
00:48:48,020 --> 00:48:51,010
因此，任何人有什麼什麼想法
我們需要做些什麼來解決呢？

996
00:48:51,010 --> 00:48:54,200

997
00:48:54,200 --> 00:48:57,570
我要等到我看到
一對夫婦的手走了。

998
00:48:57,570 --> 00:48:58,830
我們沒有執行這個。

999
00:48:58,830 --> 00:49:01,660
請記住，這是第一次
我們正在做的事情。

1000
00:49:01,660 --> 00:49:02,430
我不打算做一對夫婦。

1001
00:49:02,430 --> 00:49:03,670
我打算做幾個。

1002
00:49:03,670 --> 00:49:04,830
因為一對夫婦意味著兩。

1003
00:49:04,830 --> 00:49:07,620
我等了兩個多。

1004
00:49:07,620 --> 00:49:10,690
>> 第一插入，CURR，
默認情況下等於null。

1005
00:49:10,690 --> 00:49:14,050
而這個循環只執行
如果CURR不為null。

1006
00:49:14,050 --> 00:49:18,740
所以，我怎麼能解決這個問題呢？

1007
00:49:18,740 --> 00:49:19,990
我看見三只手。

1008
00:49:19,990 --> 00:49:28,490

1009
00:49:28,490 --> 00:49:29,780
我等了三個多。

1010
00:49:29,780 --> 00:49:33,460

1011
00:49:33,460 --> 00:49:35,940
馬庫斯，你有什麼感想？

1012
00:49:35,940 --> 00:49:37,730
>> 觀眾：好吧，如果你需要它
執行一次以上，你只是

1013
00:49:37,730 --> 00:49:39,948
將其更改為一個do-whil​​e循環。

1014
00:49:39,948 --> 00:49:41,250
>> JASON HIRSCHHORN：確定。

1015
00:49:41,250 --> 00:49:44,240
這將解決我們的問題有關係嗎？

1016
00:49:44,240 --> 00:49:47,750
>> 觀眾：在這種情況下，不因
事實上，該列表為空。

1017
00:49:47,750 --> 00:49:52,150
所以，那麼你可能只需要添加
聲明說，如果循環退出

1018
00:49:52,150 --> 00:49:55,312
那麼你必須要在年底
在列表中，此時您

1019
00:49:55,312 --> 00:49:56,562
只需將其插入。

1020
00:49:56,562 --> 00:49:58,920

1021
00:49:58,920 --> 00:49:59,680
>> JASON HIRSCHHORN：我喜歡這樣。

1022
00:49:59,680 --> 00:50:00,500
這是有道理的。

1023
00:50:00,500 --> 00:50:03,390
如果循環退出 - 

1024
00:50:03,390 --> 00:50:04,800
因為它會在這裡返回false。

1025
00:50:04,800 --> 00:50:08,220
所以，如果退出循環，然後我們在
該列表的末尾，或者也許是

1026
00:50:08,220 --> 00:50:10,690
啟動列表中，如果有什麼的
它，這是相同的端部。

1027
00:50:10,690 --> 00:50:12,770
所以，現在我們要插入
這裡的東西。

1028
00:50:12,770 --> 00:50:17,380
那麼，如何該代碼看，馬庫斯？

1029
00:50:17,380 --> 00:50:21,600
>> 觀眾：如果你已經拿到了節點
malloced，你可以只說

1030
00:50:21,600 --> 00:50:25,400
new_node  - >下一次等於null，因為
它必須是在末端。

1031
00:50:25,400 --> 00:50:27,510
或new_node  - >下一個等於null。

1032
00:50:27,510 --> 00:50:27,765
>> JASON HIRSCHHORN：確定。

1033
00:50:27,765 --> 00:50:28,190
抱歉。

1034
00:50:28,190 --> 00:50:35,760
New_node  - >下一個等於null
因為我們是在最後。

1035
00:50:35,760 --> 00:50:36,460
不把它英寸

1036
00:50:36,460 --> 00:50:37,710
我們如何把它在列表中？

1037
00:50:37,710 --> 00:50:46,130

1038
00:50:46,130 --> 00:50:46,460
右。

1039
00:50:46,460 --> 00:50:47,750
這只是設置它等於。

1040
00:50:47,750 --> 00:50:50,940
沒有我們如何做實際上
把它在列表中？

1041
00:50:50,940 --> 00:50:54,170
什麼是指向
列表的末尾？

1042
00:50:54,170 --> 00:50:56,090
>> 觀眾：頭。

1043
00:50:56,090 --> 00:50:57,566
>> JASON HIRSCHHORN：對不起？

1044
00:50:57,566 --> 00:50:59,440
>> 觀眾：頭指向
到該列表的末尾。

1045
00:50:59,440 --> 00:51:01,480
>> JASON HIRSCHHORN：如果有什麼的
列表中，頭是指向

1046
00:51:01,480 --> 00:51:04,170
列表的末尾。

1047
00:51:04,170 --> 00:51:06,920
所以說要工作
首先插入。

1048
00:51:06,920 --> 00:51:09,810
怎麼樣，如果有一對夫婦
列表中的東西呢？

1049
00:51:09,810 --> 00:51:12,470
不是我們不想設置
頭等於new_node。

1050
00:51:12,470 --> 00:51:13,790
我們究竟想幹什麼呢？

1051
00:51:13,790 --> 00:51:15,610
是嗎？

1052
00:51:15,610 --> 00:51:16,860
可能是以前的。

1053
00:51:16,860 --> 00:51:23,560

1054
00:51:23,560 --> 00:51:24,810
將這項工作？

1055
00:51:24,810 --> 00:51:28,950

1056
00:51:28,950 --> 00:51:33,050
回想一下，以前只是
一個指針指向一個節點。

1057
00:51:33,050 --> 00:51:34,770
和以前的是一個局部變量。

1058
00:51:34,770 --> 00:51:38,080
所以，這條線將設置一個局部變量，
以前，等於或

1059
00:51:38,080 --> 00:51:39,380
指向該新節點。

1060
00:51:39,380 --> 00:51:41,500
這實際上不會把它
在我們的名單，雖然。

1061
00:51:41,500 --> 00:51:44,330
我們如何把它在我們的名單？

1062
00:51:44,330 --> 00:51:45,620
Akchar？

1063
00:51:45,620 --> 00:51:46,870
>> 觀眾：我覺得你
做電流>下一個。

1064
00:51:46,870 --> 00:51:50,186

1065
00:51:50,186 --> 00:51:52,550
>> JASON HIRSCHHORN：確定。

1066
00:51:52,550 --> 00:51:54,010
CURR  - >下一個。

1067
00:51:54,010 --> 00:51:58,768
所以，再一次，我們是下來的唯一理由
這裡是有哪些呢電流等於？

1068
00:51:58,768 --> 00:51:59,760
>> 觀眾：等於null。

1069
00:51:59,760 --> 00:52:01,790
>> JASON HIRSCHHORN：還等什麼
發生，如果我們做空 - >下一個？

1070
00:52:01,790 --> 00:52:02,810
我們究竟要得到什麼？

1071
00:52:02,810 --> 00:52:04,060
我們會得到一個段錯誤。

1072
00:52:04,060 --> 00:52:06,600

1073
00:52:06,600 --> 00:52:08,880
>> 觀眾：做CURR等於null。

1074
00:52:08,880 --> 00:52:10,760
>> JASON HIRSCHHORN：這是同樣的事情
如前一個，不過，因為有

1075
00:52:10,760 --> 00:52:12,820
我們設置一個局部變量
等於這個新的節點。

1076
00:52:12,820 --> 00:52:16,680

1077
00:52:16,680 --> 00:52:20,920
讓我們回到我們的圖片
中插入一些東西。

1078
00:52:20,920 --> 00:52:25,500
說我們要插入在最後
列表中的，所以就在這裡。

1079
00:52:25,500 --> 00:52:30,010
我們有一個當前指針這是
指著空，以前的點

1080
00:52:30,010 --> 00:52:32,800
這是指向8

1081
00:52:32,800 --> 00:52:35,330
那麼，我們需要什麼更新，AVI？

1082
00:52:35,330 --> 00:52:36,680
>> 觀眾：上一頁 - >下一個？

1083
00:52:36,680 --> 00:52:41,980
>> JASON HIRSCHHORN：上 - >下一個是什麼
我們要更新，因為這

1084
00:52:41,980 --> 00:52:44,960
實際上在插入
該列表的末尾。

1085
00:52:44,960 --> 00:52:47,220
我們仍然有一個缺陷，不過，
那我們要碰上。

1086
00:52:47,220 --> 00:52:50,090
那是什麼錯誤？

1087
00:52:50,090 --> 00:52:50,790
是嗎？

1088
00:52:50,790 --> 00:52:53,860
>> 觀眾：這將返回
假在這種情況下？

1089
00:52:53,860 --> 00:52:56,380
>> JASON HIRSCHHORN：哦，是的
要返回false。

1090
00:52:56,380 --> 00:52:57,430
但還有一個問題。

1091
00:52:57,430 --> 00:52:58,930
所以，我們需要把返回true。

1092
00:52:58,930 --> 00:53:01,370
>> 觀眾：以前還是否相等
在列表的頂部空？

1093
00:53:01,370 --> 00:53:03,645
>> JASON HIRSCHHORN：所以以前仍
等於null在開始的時候。

1094
00:53:03,645 --> 00:53:07,480

1095
00:53:07,480 --> 00:53:10,440
那麼，如何才能克服呢？

1096
00:53:10,440 --> 00:53:10,950
是嗎？

1097
00:53:10,950 --> 00:53:15,280
>> 觀眾：我覺得你可以做一個檢查
前while循環，看它是否是

1098
00:53:15,280 --> 00:53:16,610
一個空的列表。

1099
00:53:16,610 --> 00:53:17,000
>> JASON HIRSCHHORN：確定。

1100
00:53:17,000 --> 00:53:17,710
因此，讓我們去這裡。

1101
00:53:17,710 --> 00:53:18,530
做一個檢查。

1102
00:53:18,530 --> 00:53:19,380
如果 - 

1103
00:53:19,380 --> 00:53:20,770
>> 觀眾：所以，如果頭
等於等於null。

1104
00:53:20,770 --> 00:53:24,300

1105
00:53:24,300 --> 00:53:26,320
>> JASON HIRSCHHORN：如果頭
等於等於null  - 

1106
00:53:26,320 --> 00:53:27,790
這會告訴我們，如果它是一個空列表。

1107
00:53:27,790 --> 00:53:31,090
>> 觀眾：然後你
做頭等於新的。

1108
00:53:31,090 --> 00:53:34,740
>> JASON HIRSCHHORN：頭
等於new_node？

1109
00:53:34,740 --> 00:53:35,730
還有什麼我們需要做什麼？

1110
00:53:35,730 --> 00:53:37,020
>> 觀眾：然後你返回true。

1111
00:53:37,020 --> 00:53:37,535
>> JASON HIRSCHHORN：不太。

1112
00:53:37,535 --> 00:53:38,785
我們缺少的一個步驟。

1113
00:53:38,785 --> 00:53:41,590

1114
00:53:41,590 --> 00:53:43,710
>> 觀眾：New_node未來
有指向空。

1115
00:53:43,710 --> 00:53:44,570
>> JASON HIRSCHHORN：沒錯，奧爾登。

1116
00:53:44,570 --> 00:53:46,600
然後我們就可以返回true。

1117
00:53:46,600 --> 00:53:47,560
確定。

1118
00:53:47,560 --> 00:53:51,630
但它仍然是一個好主意，做的事情
在列表的最後，對不對？

1119
00:53:51,630 --> 00:53:51,950
好的。

1120
00:53:51,950 --> 00:53:54,450
我們仍然可能真正得到
到該列表的末尾。

1121
00:53:54,450 --> 00:53:57,870
因此，這是代碼罰款，如果我們在
列表結束，還有一些

1122
00:53:57,870 --> 00:53:59,120
列表中的東西呢？

1123
00:53:59,120 --> 00:54:01,830

1124
00:54:01,830 --> 00:54:02,040
對不對？

1125
00:54:02,040 --> 00:54:03,540
因為我們還有馬庫斯的想法。

1126
00:54:03,540 --> 00:54:06,870
我們可能會退出這個循環，因為
我們在列表的末尾。

1127
00:54:06,870 --> 00:54:09,308
所以，我們還是希望這
這裡的代碼了嗎？

1128
00:54:09,308 --> 00:54:10,520
>> 觀眾：是的。

1129
00:54:10,520 --> 00:54:11,000
>> JASON HIRSCHHORN：是啊。

1130
00:54:11,000 --> 00:54:14,190
什麼我們需要改變這？

1131
00:54:14,190 --> 00:54:15,440
真的。

1132
00:54:15,440 --> 00:54:19,580

1133
00:54:19,580 --> 00:54:21,640
這聽起來不錯
大家這麼遠嗎？

1134
00:54:21,640 --> 00:54:22,420
任何人有任何 - 

1135
00:54:22,420 --> 00:54:23,480
AVI，你有什麼要補充的嗎？

1136
00:54:23,480 --> 00:54:23,920
>> 觀眾：號

1137
00:54:23,920 --> 00:54:25,276
>> JASON HIRSCHHORN：確定。

1138
00:54:25,276 --> 00:54:27,010
因此，我們已經做了一些改動。

1139
00:54:27,010 --> 00:54:29,540
我們已經我們之前做這個檢查
在去為一個空列表。

1140
00:54:29,540 --> 00:54:31,790
因此，我們採取了一個空列表的照顧。

1141
00:54:31,790 --> 00:54:35,500
在這裡，我們把插入的護理
一些在列表的末尾。

1142
00:54:35,500 --> 00:54:38,930
因此，它似乎是這個while循環回吐
處理後事之間，

1143
00:54:38,930 --> 00:54:41,920
某處在列表中，如果有
在列表中的東西。

1144
00:54:41,920 --> 00:54:42,280
>> 確定。

1145
00:54:42,280 --> 00:54:44,310
讓我們再次運行這個程序。

1146
00:54:44,310 --> 00:54:50,170

1147
00:54:50,170 --> 00:54:50,755
沒有成功。

1148
00:54:50,755 --> 00:54:52,190
>> 觀眾：你沒能成功。

1149
00:54:52,190 --> 00:54:53,940
>> JASON HIRSCHHORN：哦，
我沒有做它。

1150
00:54:53,940 --> 00:54:56,250
好點，邁克爾。

1151
00:54:56,250 --> 00:54:57,500
讓我們添加鏈接的化妝。

1152
00:54:57,500 --> 00:55:01,590

1153
00:55:01,590 --> 00:55:04,830
第87行有一個錯誤。

1154
00:55:04,830 --> 00:55:05,420
第87行。

1155
00:55:05,420 --> 00:55:06,600
奧爾登，這是你給我就行了。

1156
00:55:06,600 --> 00:55:08,962
什麼是錯的？

1157
00:55:08,962 --> 00:55:10,710
>> 觀眾：它必須為null。

1158
00:55:10,710 --> 00:55:11,000
>> JASON HIRSCHHORN：優秀。

1159
00:55:11,000 --> 00:55:11,630
完全正確。

1160
00:55:11,630 --> 00:55:13,290
它應為null。

1161
00:55:13,290 --> 00:55:15,210
讓我們再次做。

1162
00:55:15,210 --> 00:55:17,220
編譯。

1163
00:55:17,220 --> 00:55:17,890
確定。

1164
00:55:17,890 --> 00:55:19,400
讓我們來插入三個。

1165
00:55:19,400 --> 00:55:20,570
該插入是成功的。

1166
00:55:20,570 --> 00:55:21,660
讓我們把它打印出來。

1167
00:55:21,660 --> 00:55:23,590
哦，如果我們能檢查。

1168
00:55:23,590 --> 00:55:25,500
但我們沒有這樣做的
但打印功能。

1169
00:55:25,500 --> 00:55:27,840
讓我們進入別的東西。

1170
00:55:27,840 --> 00:55:29,090
我們應該怎樣輸入？

1171
00:55:29,090 --> 00:55:31,120

1172
00:55:31,120 --> 00:55:31,940
>> 對象：七。

1173
00:55:31,940 --> 00:55:33,340
>> JASON HIRSCHHORN：七？

1174
00:55:33,340 --> 00:55:34,590
>> 觀眾：是的。

1175
00:55:34,590 --> 00:55:38,680

1176
00:55:38,680 --> 00:55:39,780
>> JASON HIRSCHHORN：我們有一個賽格故障。

1177
00:55:39,780 --> 00:55:43,760
因此，我們得到了一個，但我們清楚地
不能得到兩個。

1178
00:55:43,760 --> 00:55:45,690
它是5:07。

1179
00:55:45,690 --> 00:55:48,370
這樣我們就可以調試這個
三分鐘。

1180
00:55:48,370 --> 00:55:51,240
但我要離開這裡，我們
並移動到哈希表。

1181
00:55:51,240 --> 00:55:54,290
但同樣，答案這個代碼
我將通過電子郵件發送給您的一點。

1182
00:55:54,290 --> 00:55:55,440
我們非常接近它。

1183
00:55:55,440 --> 00:55:58,300
我強烈鼓勵你找出
這是怎麼回事，並解決它。

1184
00:55:58,300 --> 00:56:02,400
所以我會向您發送電子郵件將該代碼作為
加上良好的解決方案 - 

1185
00:56:02,400 --> 00:56:03,670
提供可能的解決以後。

1186
00:56:03,670 --> 00:56:05,110
首先這個代碼。

1187
00:56:05,110 --> 00:56:08,290
>> 另一件事我想我們以前做的
終點是我們還沒有釋放任何東西。

1188
00:56:08,290 --> 00:56:10,370
所以我想告訴你什麼
Valgrind的樣子。

1189
00:56:10,370 --> 00:56:14,310
如果我們運行Valgrind的邊界
在我們的節目，。/掛鉤。

1190
00:56:14,310 --> 00:56:22,540
再次，根據這張幻燈片，我們
應與某些類型的Valgrind的運行

1191
00:56:22,540 --> 00:56:26,410
選項，在這種情況
 - 洩漏檢查=滿。

1192
00:56:26,410 --> 00:56:27,660
因此，讓我們寫的valgrind
 - 洩漏檢查=滿。

1193
00:56:27,660 --> 00:56:31,910

1194
00:56:31,910 --> 00:56:35,080
因此，這將運行Valgrind的
在我們的節目。

1195
00:56:35,080 --> 00:56:37,000
而現在的程序實際運行。

1196
00:56:37,000 --> 00:56:40,190
所以，我們要運行它，就像
之前，把東西英寸

1197
00:56:40,190 --> 00:56:40,830
我打算把三個。

1198
00:56:40,830 --> 00:56:41,790
這一工程。

1199
00:56:41,790 --> 00:56:43,202
我不會嘗試把某事
別的，因為我們要

1200
00:56:43,202 --> 00:56:44,710
得到在這種情況下一個段錯誤。

1201
00:56:44,710 --> 00:56:46,700
所以我只是要退出。

1202
00:56:46,700 --> 00:56:50,160
>> 現在你看到這兒
洩漏和堆總結。

1203
00:56:50,160 --> 00:56:52,310
這些都是好東西，
你想看看。

1204
00:56:52,310 --> 00:56:56,780
因此堆匯總 - 它說，在使用
在出口 - 在一個塊中8個字節。

1205
00:56:56,780 --> 00:56:58,370
一個塊是
節點我們malloced。

1206
00:56:58,370 --> 00:57:02,230
Michael，你說一個節點是前八
叮咬，因為它具有整數

1207
00:57:02,230 --> 00:57:02,680
和指針。

1208
00:57:02,680 --> 00:57:04,550
所以這是我們的節點。

1209
00:57:04,550 --> 00:57:08,170
然後它說，我們使用的malloc
七次，我們釋放

1210
00:57:08,170 --> 00:57:08,940
東西六次。

1211
00:57:08,940 --> 00:57:13,680
但我們從來沒有所謂的自由，所以我沒有
知道這是什麼說什麼。

1212
00:57:13,680 --> 00:57:18,490
>> 但我只想說，當你的
程序運行時，malloc的是被稱為

1213
00:57:18,490 --> 00:57:20,330
在其他一些地方，我們
不必擔心。

1214
00:57:20,330 --> 00:57:22,460
所以malloc的可能是所謂的
在一些地方。

1215
00:57:22,460 --> 00:57:24,480
我們並不需要擔心的地方。

1216
00:57:24,480 --> 00:57:26,240
但是，這真的是我們。

1217
00:57:26,240 --> 00:57:27,380
這第一行是我們。

1218
00:57:27,380 --> 00:57:28,320
我們離開了該塊。

1219
00:57:28,320 --> 00:57:30,330
而且你可以看到，這裡
在洩漏概要。

1220
00:57:30,330 --> 00:57:31,950
仍可達 - 

1221
00:57:31,950 --> 00:57:32,930
在一個塊中8個字節。

1222
00:57:32,930 --> 00:57:34,100
這意味著，存儲器 - 

1223
00:57:34,100 --> 00:57:35,730
我們已經洩露內存。

1224
00:57:35,730 --> 00:57:37,570
肯定丟失了 - 

1225
00:57:37,570 --> 00:57:38,770
有些東西失去了為好。

1226
00:57:38,770 --> 00:57:40,590
一般來說，你不會
看不到任何東西在那裡。

1227
00:57:40,590 --> 00:57:44,780
仍然是可到達的地方一般
你會看到的東西，在那裡你會想

1228
00:57:44,780 --> 00:57:48,900
看看，看看代碼你應該
已釋放，但你忘了釋放。

1229
00:57:48,900 --> 00:57:53,170
>> 然後，如果這是不是這種情況，
如果我們做了免費的一切，

1230
00:57:53,170 --> 00:57:54,360
我們可以檢查。

1231
00:57:54,360 --> 00:57:57,330
讓我們只運行程序
不把任何東西。

1232
00:57:57,330 --> 00:57:59,800
你會看到這兒使用在出口 - 

1233
00:57:59,800 --> 00:58:01,310
在零塊零字節。

1234
00:58:01,310 --> 00:58:06,310
這意味著我們已經一無所有
當這個程序退出。

1235
00:58:06,310 --> 00:58:12,090
所以，在轉彎前pset6，運行Valgrind的
並確保你沒有

1236
00:58:12,090 --> 00:58:15,310
任何內存洩漏的程序。

1237
00:58:15,310 --> 00:58:17,910
如果您有Valgrind的任何問題，
隨意伸手。

1238
00:58:17,910 --> 00:58:18,700
但是，這是你如何使用它。

1239
00:58:18,700 --> 00:58:20,890
很簡單 - 看看你
有在使用中退出 - 

1240
00:58:20,890 --> 00:58:22,270
在任何阻止任何字節。

1241
00:58:22,270 --> 00:58:27,890

1242
00:58:27,890 --> 00:58:29,580
>> 所以，我們正在努力插入節點上。

1243
00:58:29,580 --> 00:58:33,840
我有其他兩個函數在這裡 - 
打印節點和自由節點。

1244
00:58:33,840 --> 00:58:37,780
再次，這些功能是
將是對你有好處練習

1245
00:58:37,780 --> 00:58:40,990
因為他們會幫你不僅
這些樣品的練習，但也

1246
00:58:40,990 --> 00:58:42,180
關於這個問題集。

1247
00:58:42,180 --> 00:58:44,230
他們非常緊密映射到的東西
你將要做的

1248
00:58:44,230 --> 00:58:45,010
問題集。

1249
00:58:45,010 --> 00:58:47,640
但我想，以確保
我們接觸的一切。

1250
00:58:47,640 --> 00:58:50,400
和哈希表也是至關重要的
我們正在做的這節

1251
00:58:50,400 --> 00:58:51,980
星期 - 或在習題集。

1252
00:58:51,980 --> 00:58:55,200
>> 所以，我們要完成的部分
談論哈希表。

1253
00:58:55,200 --> 00:58:58,140
如果您發現我犯了一個
小哈希表。

1254
00:58:58,140 --> 00:59:00,020
這不是我們所談論
但是，關於。

1255
00:59:00,020 --> 00:59:03,540
我們談論的是一個不同的
類型的哈希表。

1256
00:59:03,540 --> 00:59:07,300
並在其核心，一個哈希表
是不是僅此而已

1257
00:59:07,300 --> 00:59:08,860
陣列加一個散列函數。

1258
00:59:08,860 --> 00:59:11,150
我們要談的一點只是為了
確保每個人都明白一個

1259
00:59:11,150 --> 00:59:12,110
散列函數是。

1260
00:59:12,110 --> 00:59:15,420
而我現在告訴你，這是
無非兩件事 - 

1261
00:59:15,420 --> 00:59:18,590
數組和散列函數。

1262
00:59:18,590 --> 00:59:20,716
和這裡的步驟，通過
而這個操作。

1263
00:59:20,716 --> 00:59:31,560

1264
00:59:31,560 --> 00:59:32,810
>> 還有我們的數組。

1265
00:59:32,810 --> 00:59:38,460

1266
00:59:38,460 --> 00:59:39,460
還有我們的函數。

1267
00:59:39,460 --> 00:59:43,180
特別是，散列函數需要
做了幾件事情與此有關。

1268
00:59:43,180 --> 00:59:45,040
我要特別談談
關於這個問題集。

1269
00:59:45,040 --> 00:59:46,450
它可能會
走在一個字符串。

1270
00:59:46,450 --> 00:59:50,570

1271
00:59:50,570 --> 00:59:51,770
和什麼樣了回來？

1272
00:59:51,770 --> 00:59:52,640
是什麼數據類型？

1273
00:59:52,640 --> 00:59:54,260
奧爾登？

1274
00:59:54,260 --> 00:59:55,760
您的散列函數返回？

1275
00:59:55,760 --> 00:59:58,760
一個整數。

1276
00:59:58,760 --> 01:00:01,700
原來這就是散列
表由 - 

1277
01:00:01,700 --> 01:00:05,430
在陣列形式的表
和散列函數。

1278
01:00:05,430 --> 01:00:06,010
它是如何工作的？

1279
01:00:06,010 --> 01:00:07,300
它的工作分三個步驟。

1280
01:00:07,300 --> 01:00:08,740
我們給它一個關鍵。

1281
01:00:08,740 --> 01:00:11,470
在這種情況下，我們給它一個字符串。

1282
01:00:11,470 --> 01:00:18,140
我們每步1調用哈希函數
對關鍵，我們得到的一個值。

1283
01:00:18,140 --> 01:00:20,310
>> 具體來說，我們會說
我們得到的整數。

1284
01:00:20,310 --> 01:00:25,630
該整數，也有非常具體的
限制到什麼是整數都可以。

1285
01:00:25,630 --> 01:00:28,880
在這個例子中，我們的陣
是大小三。

1286
01:00:28,880 --> 01:00:32,330
因此，可以認為整數是什麼數字。

1287
01:00:32,330 --> 01:00:35,970
什麼是有效值範圍
該整數，這個返回類型

1288
01:00:35,970 --> 01:00:37,220
散列函數？

1289
01:00:37,220 --> 01:00:40,440

1290
01:00:40,440 --> 01:00:42,110
零，一和二。

1291
01:00:42,110 --> 01:00:46,060
散列函數的一點是要
找出該數組中的位置

1292
01:00:46,060 --> 01:00:47,790
在那裡我們的關鍵是怎麼回事。

1293
01:00:47,790 --> 01:00:51,290
只有三種可能
地方在這裡 - 

1294
01:00:51,290 --> 01:00:52,130
零個，一個或兩個。

1295
01:00:52,130 --> 01:00:55,360
所以這個功能更好的回報
零個，一個或兩個。

1296
01:00:55,360 --> 01:00:58,740
此數組中一些有效的指數。

1297
01:00:58,740 --> 01:01:02,770
>> 然後不同的地方返回，
你可以看到有數組開放

1298
01:01:02,770 --> 01:01:03,730
括弧中的值。

1299
01:01:03,730 --> 01:01:05,800
這就是我們把鑰匙。

1300
01:01:05,800 --> 01:01:11,280
所以我們扔在南瓜，
我們得到了零。

1301
01:01:11,280 --> 01:01:15,540
在陣列支架0，我們把南瓜。

1302
01:01:15,540 --> 01:01:21,070
我們扔在貓，我們走出之一。

1303
01:01:21,070 --> 01:01:24,110
我們把貓的之一。

1304
01:01:24,110 --> 01:01:25,480
我們把蜘蛛。

1305
01:01:25,480 --> 01:01:26,710
我們得到了兩次。

1306
01:01:26,710 --> 01:01:30,200
我們把蜘蛛在陣列上的兩個。

1307
01:01:30,200 --> 01:01:32,300
這將是很好，如果
它的工作就像那個。

1308
01:01:32,300 --> 01:01:35,570
但不幸的是，正如我們將看到的，
這是一個比較複雜一點。

1309
01:01:35,570 --> 01:01:37,570
>> 在我們那裡，任何問題
關於這個基本

1310
01:01:37,570 --> 01:01:38,820
建立一個哈希表？

1311
01:01:38,820 --> 01:01:49,050

1312
01:01:49,050 --> 01:01:51,940
這是確切的圖像
我們畫在黑板上。

1313
01:01:51,940 --> 01:01:55,420
但由於我們畫在黑板上，我
我不打算再進入它。

1314
01:01:55,420 --> 01:02:00,430
從本質上講鍵，神奇的黑盒子 - 
或者在這種情況下，深青色盒 - 一個

1315
01:02:00,430 --> 01:02:02,410
散列函數把它們放在水桶。

1316
01:02:02,410 --> 01:02:04,690
而在這個例子中，我們是
不把這個名字。

1317
01:02:04,690 --> 01:02:07,880
我們把相關的電話
名稱中的桶數。

1318
01:02:07,880 --> 01:02:10,430
但你很可能只是
把名字中的水桶。

1319
01:02:10,430 --> 01:02:12,950
>> 這是什麼只是一個圖片
我們畫在黑板上。

1320
01:02:12,950 --> 01:02:14,460
我們有潛在的隱患，雖然。

1321
01:02:14,460 --> 01:02:17,470
而且有兩個特別
幻燈片，我想去過。

1322
01:02:17,470 --> 01:02:20,230
第一個是對
散列函數。

1323
01:02:20,230 --> 01:02:22,620
所以我問的問題，什麼
做一個好的哈希函數？

1324
01:02:22,620 --> 01:02:24,220
我給出兩個答案。

1325
01:02:24,220 --> 01:02:26,630
首先是它的確定性。

1326
01:02:26,630 --> 01:02:29,660
在哈希函數的情況下，
這是什麼意思？

1327
01:02:29,660 --> 01:02:37,840

1328
01:02:37,840 --> 01:02:39,282
是嗎？

1329
01:02:39,282 --> 01:02:42,850
>> 觀眾：它可以找到
指數在常數時間？

1330
01:02:42,850 --> 01:02:43,810
>> JASON HIRSCHHORN：那
是不是這個意思。

1331
01:02:43,810 --> 01:02:44,725
但是這是一個很好的猜測。

1332
01:02:44,725 --> 01:02:46,100
別人有一個猜想
到這意味著什麼？

1333
01:02:46,100 --> 01:02:47,780
一個好的哈希函數
是確定的？

1334
01:02:47,780 --> 01:02:48,280
安妮？

1335
01:02:48,280 --> 01:02:51,680
>> 觀眾：那一個鍵只能映射
哈希表在同一個地方。

1336
01:02:51,680 --> 01:02:53,070
>> JASON HIRSCHHORN：這是
完全正確。

1337
01:02:53,070 --> 01:02:57,430
每當你把南瓜，
它總是返回零。

1338
01:02:57,430 --> 01:03:01,660
如果你把南瓜和您的散列
函數返回零，但有一個

1339
01:03:01,660 --> 01:03:06,060
返回的東西概率
其他大於零 - 

1340
01:03:06,060 --> 01:03:09,280
所以也許它可以返回人們有時
或其他兩次 - 

1341
01:03:09,280 --> 01:03:11,100
這不是一個好的哈希函數。

1342
01:03:11,100 --> 01:03:11,800
你說得對。

1343
01:03:11,800 --> 01:03:15,680
您的散列函數應該返回
完全相同的整數，在這種情況下，為

1344
01:03:15,680 --> 01:03:17,780
完全相同的字符串。

1345
01:03:17,780 --> 01:03:22,210
>> 也許它會返回完全相同的整數
對於完全相同的字符串

1346
01:03:22,210 --> 01:03:24,430
不分大小寫的。

1347
01:03:24,430 --> 01:03:27,980
但在這種情況下，它仍然
確定性，因為多東西

1348
01:03:27,980 --> 01:03:29,350
被映射到相同的值。

1349
01:03:29,350 --> 01:03:30,170
這很好。

1350
01:03:30,170 --> 01:03:32,615
只要僅有一個
輸出對於一個給定的輸入。

1351
01:03:32,615 --> 01:03:35,630

1352
01:03:35,630 --> 01:03:36,350
>> 確定。

1353
01:03:36,350 --> 01:03:38,340
第二件事是，它
返回的有效索引。

1354
01:03:38,340 --> 01:03:40,220
我們長大了前面。

1355
01:03:40,220 --> 01:03:41,860
該散列函數 - 

1356
01:03:41,860 --> 01:03:43,710
男孩哦 - 

1357
01:03:43,710 --> 01:03:46,840
散列函數應該
返回的有效索引。

1358
01:03:46,840 --> 01:03:47,740
所以說 - 

1359
01:03:47,740 --> 01:03:48,990
讓我們回到這個例子。

1360
01:03:48,990 --> 01:03:52,580

1361
01:03:52,580 --> 01:03:57,540
我的散列函數計數
字母的單詞。

1362
01:03:57,540 --> 01:03:58,380
這就是散列函數。

1363
01:03:58,380 --> 01:03:59,740
並返回該整數。

1364
01:03:59,740 --> 01:04:04,280
所以，如果我有A字，它的
要返回之一。

1365
01:04:04,280 --> 01:04:06,900
並且它會放一個就在這裡。

1366
01:04:06,900 --> 01:04:09,430
如果我把這個詞蝙蝠？

1367
01:04:09,430 --> 01:04:11,310
這將返回三個。

1368
01:04:11,310 --> 01:04:12,560
哪裡蝙蝠去了？

1369
01:04:12,560 --> 01:04:18,730

1370
01:04:18,730 --> 01:04:19,750
>> 它不適合。

1371
01:04:19,750 --> 01:04:21,000
但它需要去的地方。

1372
01:04:21,000 --> 01:04:23,340
這是我的哈希表畢竟，和
一切都需要去的地方。

1373
01:04:23,340 --> 01:04:24,590
那麼，應該蝙蝠去了？

1374
01:04:24,590 --> 01:04:28,020

1375
01:04:28,020 --> 01:04:28,710
有什麼想法？

1376
01:04:28,710 --> 01:04:29,450
猜測？

1377
01:04:29,450 --> 01:04:30,280
良好的猜測？

1378
01:04:30,280 --> 01:04:31,220
>> 對象：零。

1379
01:04:31,220 --> 01:04:32,120
>> JASON HIRSCHHORN：為什麼零？

1380
01:04:32,120 --> 01:04:35,990
>> 觀眾：因為3
模三是零？

1381
01:04:35,990 --> 01:04:38,620
>> JASON HIRSCHHORN：三
模3是零。

1382
01:04:38,620 --> 01:04:40,810
這是一個偉大的猜想，
這就是正確的。

1383
01:04:40,810 --> 01:04:43,870
因此，在這種情況下，它應該
大概走為零。

1384
01:04:43,870 --> 01:04:51,080
所以一個好的方法，以確保此哈希
函數只返回有效索引的

1385
01:04:51,080 --> 01:04:54,580
由該表的大小以模它。

1386
01:04:54,580 --> 01:04:57,360
如果通過模本的任何回報
3，你總是會得到

1387
01:04:57,360 --> 01:05:00,930
零個，一個，和2之間的東西。

1388
01:05:00,930 --> 01:05:05,160
如果這個總是返回七人，
你總是模三個人，你是

1389
01:05:05,160 --> 01:05:06,030
總是會得到同樣的事情。

1390
01:05:06,030 --> 01:05:09,270
>> 所以它仍然確定性
如果你取模。

1391
01:05:09,270 --> 01:05:11,420
但是，這將確保您
從來沒有得到的東西 - 

1392
01:05:11,420 --> 01:05:12,940
無效的行業。

1393
01:05:12,940 --> 01:05:16,840
通常，模應該發生
您的哈希函數裡面。

1394
01:05:16,840 --> 01:05:18,240
所以，你不必擔心這一點。

1395
01:05:18,240 --> 01:05:20,555
你只要能保證
這是一個有效的指數。

1396
01:05:20,555 --> 01:05:23,700

1397
01:05:23,700 --> 01:05:26,700
這方面的問題
潛在的缺陷？

1398
01:05:26,700 --> 01:05:36,590

1399
01:05:36,590 --> 01:05:39,060
>> 確定。

1400
01:05:39,060 --> 01:05:40,290
我們在那裡去。

1401
01:05:40,290 --> 01:05:42,890
下一個潛在的缺陷，並
這是大的。

1402
01:05:42,890 --> 01:05:46,880
如果哪兩個鍵地圖
為相同的值？

1403
01:05:46,880 --> 01:05:49,350
因此，有兩種方法來處理這個問題。

1404
01:05:49,350 --> 01:05:53,140

1405
01:05:53,140 --> 01:05:56,020
第一個被稱為線性
探測時，我敢

1406
01:05:56,020 --> 01:05:57,300
不打算走了過來。

1407
01:05:57,300 --> 01:06:01,120
但是你應該熟悉如何
的作品，這是什麼。

1408
01:06:01,120 --> 01:06:05,610
>> 第二個我打算走了過來
因為這是一個多

1409
01:06:05,610 --> 01:06:08,290
人們可能會最終決定
在他們的問題集中使用。

1410
01:06:08,290 --> 01:06:09,820
當然，你不必。

1411
01:06:09,820 --> 01:06:15,280
但對於習題集，很多人
傾向於選擇創建一個哈希表

1412
01:06:15,280 --> 01:06:17,950
有獨立的鏈接來實現
他們的字典。

1413
01:06:17,950 --> 01:06:21,390
所以，我們要投奔這是什麼意思
創建一個哈希表

1414
01:06:21,390 --> 01:06:23,890
單獨的鏈接。

1415
01:06:23,890 --> 01:06:26,260
>> 所以我把南瓜。

1416
01:06:26,260 --> 01:06:29,560
它返回零。

1417
01:06:29,560 --> 01:06:31,410
我把南瓜在這裡。

1418
01:06:31,410 --> 01:06:35,880

1419
01:06:35,880 --> 01:06:37,930
然後我把 - 

1420
01:06:37,930 --> 01:06:39,922
什麼是另一個萬聖節為主題的東西嗎？

1421
01:06:39,922 --> 01:06:42,200
>> 觀眾：糖果。

1422
01:06:42,200 --> 01:06:42,770
>> JASON HIRSCHHORN：糖果！

1423
01:06:42,770 --> 01:06:43,910
這是一個偉大的。

1424
01:06:43,910 --> 01:06:47,760
我把糖果和糖果
也使我為零。

1425
01:06:47,760 --> 01:06:49,350
我該怎麼辦？

1426
01:06:49,350 --> 01:06:51,940
任何想法？

1427
01:06:51,940 --> 01:06:53,940
因為那種大家都知道
什麼單獨的鏈接是。

1428
01:06:53,940 --> 01:06:55,190
因此，任何想法怎麼辦？

1429
01:06:55,190 --> 01:06:58,170

1430
01:06:58,170 --> 01:06:59,110
是啊。

1431
01:06:59,110 --> 01:07:03,810
>> 觀眾：把字符串
實際上哈希表中。

1432
01:07:03,810 --> 01:07:08,910
>> JASON HIRSCHHORN：所以我們要
繪製好主意在這裡。

1433
01:07:08,910 --> 01:07:09,340
確定。

1434
01:07:09,340 --> 01:07:12,290
>> 觀眾：有哈希表
[聽不清]

1435
01:07:12,290 --> 01:07:16,640
指向指針
一個列表的開頭。

1436
01:07:16,640 --> 01:07:20,930
然後有南瓜是第一值
在鍊錶和糖果是

1437
01:07:20,930 --> 01:07:22,800
在該鍊錶中的第二個值。

1438
01:07:22,800 --> 01:07:23,420
>> JASON HIRSCHHORN：確定。

1439
01:07:23,420 --> 01:07:24,670
馬庫斯，這是優秀的。

1440
01:07:24,670 --> 01:07:26,160
我要打破下來。

1441
01:07:26,160 --> 01:07:28,890
馬庫斯是說不要
覆蓋南瓜。

1442
01:07:28,890 --> 01:07:30,660
這將是壞。

1443
01:07:30,660 --> 01:07:33,640
不要把糖果別的地方。

1444
01:07:33,640 --> 01:07:35,390
我們打算把兩者為零。

1445
01:07:35,390 --> 01:07:37,770
但我們要處理
這使他們由零

1446
01:07:37,770 --> 01:07:39,395
創建列表為零。

1447
01:07:39,395 --> 01:07:42,430
我們要創建的列表
一切映射到零。

1448
01:07:42,430 --> 01:07:47,960
我們學會了創造的最佳方式
可以增長和收縮的清單

1449
01:07:47,960 --> 01:07:49,840
動態不在
另一個數組。

1450
01:07:49,840 --> 01:07:51,510
所以不是一個多維數組。

1451
01:07:51,510 --> 01:07:54,080
但只創建一個鍊錶。

1452
01:07:54,080 --> 01:07:55,330
>> 那麼，他提出 - 

1453
01:07:55,330 --> 01:07:57,950

1454
01:07:57,950 --> 01:07:59,200
我會得到一個新的 - 

1455
01:07:59,200 --> 01:08:15,380

1456
01:08:15,380 --> 01:08:19,689
是創建一個指針數組，
的指針數組。

1457
01:08:19,689 --> 01:08:20,580
確定。

1458
01:08:20,580 --> 01:08:24,180
任何想法或暗示的是什麼類型的
這個指針應該是什麼？

1459
01:08:24,180 --> 01:08:26,290
馬庫斯？

1460
01:08:26,290 --> 01:08:27,250
>> 觀眾：指針來 - 

1461
01:08:27,250 --> 01:08:28,609
>> JASON HIRSCHHORN：因為你
說一個鍊錶，所以 - 

1462
01:08:28,609 --> 01:08:29,520
>> 觀眾：節點的指針？

1463
01:08:29,520 --> 01:08:30,670
>> JASON HIRSCHHORN：節點的指針。

1464
01:08:30,670 --> 01:08:32,830
如果東西在我們的鏈接
列表是節點，那麼他們

1465
01:08:32,830 --> 01:08:34,370
應該是節點的指針。

1466
01:08:34,370 --> 01:08:35,939
又哪裡等於最初？

1467
01:08:35,939 --> 01:08:36,990
>> 觀眾：空。

1468
01:08:36,990 --> 01:08:38,240
>> JASON HIRSCHHORN：無。

1469
01:08:38,240 --> 01:08:44,540

1470
01:08:44,540 --> 01:08:46,080
所以這是我們的空的東西。

1471
01:08:46,080 --> 01:08:47,170
南瓜返回零。

1472
01:08:47,170 --> 01:08:48,569
我們該怎麼辦？

1473
01:08:48,569 --> 01:08:49,609
通過它走我嗎？

1474
01:08:49,609 --> 01:08:50,810
其實，馬庫斯已經給了我。

1475
01:08:50,810 --> 01:08:52,439
別人走我走過它。

1476
01:08:52,439 --> 01:08:54,760
我們做什麼，當我們 - 

1477
01:08:54,760 --> 01:08:56,609
這看起來非常相似，
我們只是在做。

1478
01:08:56,609 --> 01:08:57,396
阿維。

1479
01:08:57,396 --> 01:08:59,090
>> 觀眾：我要去參加一個猜測。

1480
01:08:59,090 --> 01:09:01,250
所以，當你得到糖果。

1481
01:09:01,250 --> 01:09:01,640
>> JASON HIRSCHHORN：是啊。

1482
01:09:01,640 --> 01:09:03,120
好了，我們得到了南瓜。

1483
01:09:03,120 --> 01:09:03,870
讓我們得到我們的第一個。

1484
01:09:03,870 --> 01:09:04,324
我們得到了南瓜。

1485
01:09:04,324 --> 01:09:04,779
>> 觀眾：確定。

1486
01:09:04,779 --> 01:09:05,880
南瓜返回零。

1487
01:09:05,880 --> 01:09:08,770
所以你把它放在那。

1488
01:09:08,770 --> 01:09:10,810
或者實際上，你把它
在鍊錶。

1489
01:09:10,810 --> 01:09:13,550
>> JASON HIRSCHHORN：我們如何
把它放在鍊錶？

1490
01:09:13,550 --> 01:09:15,479
>> 觀眾：呵呵，實際的語法？

1491
01:09:15,479 --> 01:09:16,240
>> JASON HIRSCHHORN：只是走 - 

1492
01:09:16,240 --> 01:09:16,740
多說了。

1493
01:09:16,740 --> 01:09:19,310
我們該怎麼辦？

1494
01:09:19,310 --> 01:09:22,100
>> 觀眾：你剛才插入
它作為第一個節點。

1495
01:09:22,100 --> 01:09:22,675
>> JASON HIRSCHHORN：確定。

1496
01:09:22,675 --> 01:09:29,069
因此，我們有我們的節點，南瓜。

1497
01:09:29,069 --> 01:09:31,560
現在我怎麼插入？

1498
01:09:31,560 --> 01:09:34,590

1499
01:09:34,590 --> 01:09:37,090
>> 觀眾：你分配
它的指針。

1500
01:09:37,090 --> 01:09:37,970
>> JASON HIRSCHHORN：哪個指標？

1501
01:09:37,970 --> 01:09:39,620
>> 觀眾：零指針。

1502
01:09:39,620 --> 01:09:41,420
>> JASON HIRSCHHORN：那麼，
確實這一點呢？

1503
01:09:41,420 --> 01:09:42,810
>> 觀眾：為NULL現在。

1504
01:09:42,810 --> 01:09:43,529
>> JASON HIRSCHHORN：嗯，
它指向空。

1505
01:09:43,529 --> 01:09:44,499
但我把南瓜。

1506
01:09:44,499 --> 01:09:46,053
那麼，它應該指向？

1507
01:09:46,053 --> 01:09:46,880
>> 觀眾：南瓜。

1508
01:09:46,880 --> 01:09:47,399
>> JASON HIRSCHHORN：南瓜。

1509
01:09:47,399 --> 01:09:48,760
沒錯。

1510
01:09:48,760 --> 01:09:50,010
所以這個指向南瓜。

1511
01:09:50,010 --> 01:09:52,500

1512
01:09:52,500 --> 01:09:54,250
並在執行此指針
在南瓜呢？

1513
01:09:54,250 --> 01:09:57,986

1514
01:09:57,986 --> 01:09:58,340
至

1515
01:09:58,340 --> 01:09:58,590
>> 觀眾：空。

1516
01:09:58,590 --> 01:09:59,210
>> JASON HIRSCHHORN：為NULL。

1517
01:09:59,210 --> 01:10:00,460
沒錯。

1518
01:10:00,460 --> 01:10:03,570

1519
01:10:03,570 --> 01:10:05,140
所以我們剛才插入的東西
成該鏈接的表。

1520
01:10:05,140 --> 01:10:07,210
我們只是寫了這個代碼來做到這一點。

1521
01:10:07,210 --> 01:10:09,520
幾乎我們幾乎得到了它
完全破解。

1522
01:10:09,520 --> 01:10:10,790
現在我們插入的糖果。

1523
01:10:10,790 --> 01:10:13,480
我們的糖果也變為零。

1524
01:10:13,480 --> 01:10:16,100
所以，我們做糖果什麼？

1525
01:10:16,100 --> 01:10:18,790
>> 觀眾：這取決於是否
不是我們試圖對它進行排序。

1526
01:10:18,790 --> 01:10:19,640
>> JASON HIRSCHHORN：這是
完全正確。

1527
01:10:19,640 --> 01:10:21,070
這取決於是否不
我們正在試圖對它進行排序。

1528
01:10:21,070 --> 01:10:22,660
讓我們假設我們不是
要排序。

1529
01:10:22,660 --> 01:10:24,880
>> 觀眾：那麼，正如我們所討論
之前，它最簡單的只是把它

1530
01:10:24,880 --> 01:10:28,590
在一開始使指針
從零點到糖果。

1531
01:10:28,590 --> 01:10:29,020
>> JASON HIRSCHHORN：確定。

1532
01:10:29,020 --> 01:10:29,380
堅持住。

1533
01:10:29,380 --> 01:10:30,630
我創建的糖果就在這裡。

1534
01:10:30,630 --> 01:10:34,030

1535
01:10:34,030 --> 01:10:35,150
所以這個指針 - 

1536
01:10:35,150 --> 01:10:37,590
>> 觀眾：是啊，現在應該
是指向糖果。

1537
01:10:37,590 --> 01:10:40,580
再有從指針
糖果點南瓜。

1538
01:10:40,580 --> 01:10:43,140

1539
01:10:43,140 --> 01:10:44,560
>> JASON HIRSCHHORN：像這樣？

1540
01:10:44,560 --> 01:10:47,380
並說我們得到了另一個
東西映射到零？

1541
01:10:47,380 --> 01:10:48,660
>> 觀眾：嗯，你只是
做同樣的事情？

1542
01:10:48,660 --> 01:10:50,290
>> JASON HIRSCHHORN：做同樣的事情。

1543
01:10:50,290 --> 01:10:53,700
所以在這種情況下，如果不
要保持它整理了

1544
01:10:53,700 --> 01:10:55,270
聽起來相當簡單。

1545
01:10:55,270 --> 01:10:59,920
我們帶指針的指數
我們的哈希函數由下式給出。

1546
01:10:59,920 --> 01:11:03,830
我們有一點我們的新節點。

1547
01:11:03,830 --> 01:11:07,830
然後不管它是指向
以前 - 

1548
01:11:07,830 --> 01:11:10,620
在這種情況下空，在
第二種情況南瓜 - 

1549
01:11:10,620 --> 01:11:15,310
，不管它的指向
以前，我們添加到下一個的

1550
01:11:15,310 --> 01:11:17,810
我們的新節點。

1551
01:11:17,810 --> 01:11:19,650
我們要插入一些
在開始。

1552
01:11:19,650 --> 01:11:22,900
事實上，這是不是簡單多了
試圖保持列表排序。

1553
01:11:22,900 --> 01:11:25,340
但同樣，搜索會
更複雜的在這裡。

1554
01:11:25,340 --> 01:11:28,300
我們總是要走到最後。

1555
01:11:28,300 --> 01:11:29,650
>> 確定。

1556
01:11:29,650 --> 01:11:32,750
關於單獨的鏈接有問題嗎？

1557
01:11:32,750 --> 01:11:34,690
該怎麼做？

1558
01:11:34,690 --> 01:11:35,820
請立即問他們。

1559
01:11:35,820 --> 01:11:39,260
我真的想確保你的所有
明白這一點之前，我們把頭伸出。

1560
01:11:39,260 --> 01:11:48,410

1561
01:11:48,410 --> 01:11:52,060
>> 觀眾：你為什麼把南瓜
和糖果到相同的

1562
01:11:52,060 --> 01:11:54,108
哈希表的一部分？

1563
01:11:54,108 --> 01:11:55,860
>> JASON HIRSCHHORN：好問題。

1564
01:11:55,860 --> 01:11:59,140
為什麼我們把它們放在同一個
哈希表的一部分？

1565
01:11:59,140 --> 01:12:03,200
那麼，在這種情況下，我們的散列函數
返回零為他們兩個。

1566
01:12:03,200 --> 01:12:05,310
因此，他們需要去的指數為零
因為這就是我們要

1567
01:12:05,310 --> 01:12:07,420
找他們，如果我們曾經
想看看他們。

1568
01:12:07,420 --> 01:12:11,750
再次，用線性探測方法
我們不會把他們兩個零。

1569
01:12:11,750 --> 01:12:13,900
但在不同的鏈方法，
我們打算把他們兩個零

1570
01:12:13,900 --> 01:12:16,620
然後創建一個列表銷為零。

1571
01:12:16,620 --> 01:12:20,140
>> 我們不希望覆蓋南瓜
只是對於因為那時我們將

1572
01:12:20,140 --> 01:12:21,860
假設是南瓜
從來沒有插入。

1573
01:12:21,860 --> 01:12:25,230
如果我們只是一味地一件事在
這將是壞的位置。

1574
01:12:25,230 --> 01:12:28,590
那麼就沒有
我們曾經的機會 - 

1575
01:12:28,590 --> 01:12:31,660
如果我們曾經有一個重複的，那麼我們
只會抹掉我們的初始值。

1576
01:12:31,660 --> 01:12:34,090
所以這就是為什麼我們這樣做的方法。

1577
01:12:34,090 --> 01:12:36,580
或者，這就是為什麼我們選擇了 - 但同樣，我們
選擇了不同的鏈接方式，

1578
01:12:36,580 --> 01:12:39,670
它還有許多其他的方法
人們可以選擇。

1579
01:12:39,670 --> 01:12:41,185
這是否回答你的問題？

1580
01:12:41,185 --> 01:12:41,660
>> 確定。

1581
01:12:41,660 --> 01:12:42,910
卡洛斯。

1582
01:12:42,910 --> 01:12:46,130

1583
01:12:46,130 --> 01:12:47,720
線性探測將涉及 - 

1584
01:12:47,720 --> 01:12:51,913
如果我們發現了一個碰撞為零，我們
看起來在一個景點，看是否

1585
01:12:51,913 --> 01:12:54,310
它是開放的，並把它放在那裡。

1586
01:12:54,310 --> 01:12:57,320
然後我們來看看在未來的體育和
看看是否是公開的，把它放在那裡。

1587
01:12:57,320 --> 01:12:59,780
因此，我們發現下一個可用的
開放式現場，把它放在那裡。

1588
01:12:59,780 --> 01:13:02,580

1589
01:13:02,580 --> 01:13:03,890
還有沒有其他問題？

1590
01:13:03,890 --> 01:13:05,370
是啊，AVI。

1591
01:13:05,370 --> 01:13:07,490
>> 觀眾：作為一個跟進的是，
你是什​​麼下一個景點是什麼意思？

1592
01:13:07,490 --> 01:13:10,250
在哈希表或鍊錶。

1593
01:13:10,250 --> 01:13:12,100
>> JASON HIRSCHHORN：對於線性
編程，無鍊錶。

1594
01:13:12,100 --> 01:13:13,400
哈希表上的下一個點。

1595
01:13:13,400 --> 01:13:13,820
>> 觀眾：確定。

1596
01:13:13,820 --> 01:13:17,570
因此，哈希表會
初始化為大小 - 

1597
01:13:17,570 --> 01:13:19,560
像串數
你被插入？

1598
01:13:19,560 --> 01:13:22,170
>> JASON HIRSCHHORN：你會
希望它是真正的大。

1599
01:13:22,170 --> 01:13:23,910
是。

1600
01:13:23,910 --> 01:13:27,900
這裡就是我們的圖片
只是畫在黑板上。

1601
01:13:27,900 --> 01:13:29,470
再次，我們有一個碰撞就在這裡。

1602
01:13:29,470 --> 01:13:30,710
在152。

1603
01:13:30,710 --> 01:13:33,570
你會看到我們創建
鍊錶關閉它。

1604
01:13:33,570 --> 01:13:38,200

1605
01:13:38,200 --> 01:13:41,850
再次，哈希表單獨鏈接
做法是不是你

1606
01:13:41,850 --> 01:13:45,590
要為設置問題
6不過是一個很多

1607
01:13:45,590 --> 01:13:47,100
學生傾向於採取。

1608
01:13:47,100 --> 01:13:51,140
所以，關於這一點，讓我們簡要談
之前，我們把頭伸出約問題6，

1609
01:13:51,140 --> 01:13:52,160
然後我會跟大家分享一個故事。

1610
01:13:52,160 --> 01:13:55,120
我們有三分鐘。

1611
01:13:55,120 --> 01:13:55,750
>> 問題組六。

1612
01:13:55,750 --> 01:13:57,790
你有四個功能 - 

1613
01:13:57,790 --> 01:14:02,430
負載，檢查，尺寸和卸載。

1614
01:14:02,430 --> 01:14:03,380
負載 - 

1615
01:14:03,380 --> 01:14:07,120
好了，我們已經去
過載剛才。

1616
01:14:07,120 --> 01:14:09,330
我們畫了負載在黑板上。

1617
01:14:09,330 --> 01:14:13,230
我們甚至開始編碼了很多
插入一個鍊錶。

1618
01:14:13,230 --> 01:14:18,020
所以負載不大於多
我們剛才一直在做。

1619
01:14:18,020 --> 01:14:21,070
>> 入住的是，一旦你有
裝的東西。

1620
01:14:21,070 --> 01:14:22,580
這是相同的過程，因為這。

1621
01:14:22,580 --> 01:14:26,845
在那裡你把相同的前兩部分
事到哈希函數

1622
01:14:26,845 --> 01:14:29,190
並獲得其值。

1623
01:14:29,190 --> 01:14:30,700
但是現在我們還沒有插入。

1624
01:14:30,700 --> 01:14:33,350
現在，我們正在尋找它。

1625
01:14:33,350 --> 01:14:37,130
我的示例代碼寫的尋找
東西在一個鍊錶。

1626
01:14:37,130 --> 01:14:38,250
我鼓勵你練習了。

1627
01:14:38,250 --> 01:14:43,000
但直覺發現的東西是
非常類似於插入的東西。

1628
01:14:43,000 --> 01:14:46,540
事實上，我們發現畫的圖片
東西在一個鍊錶，移動

1629
01:14:46,540 --> 01:14:48,910
通過直到你到了年底。

1630
01:14:48,910 --> 01:14:52,430
如果你到了結束，不能
找到它，那麼它不存在。

1631
01:14:52,430 --> 01:14:55,400
所以這是支票，基本上。

1632
01:14:55,400 --> 01:14:57,030
>> 下一個是大小。

1633
01:14:57,030 --> 01:14:57,910
讓我們跳過大小。

1634
01:14:57,910 --> 01:15:00,040
最後，你已經卸載。

1635
01:15:00,040 --> 01:15:02,890
卸載是我們還沒有得出
在董事會或編碼呢。

1636
01:15:02,890 --> 01:15:05,990
但我鼓勵你去嘗試它的編碼
在我們的樣本鍊錶的例子。

1637
01:15:05,990 --> 01:15:11,440
但直覺上卸載
類似於自由 - 

1638
01:15:11,440 --> 01:15:14,010
或者我的意思是類似的檢查。

1639
01:15:14,010 --> 01:15:17,350
除了現在每次你要時間
通過，你不能簡單地檢查，

1640
01:15:17,350 --> 01:15:19,090
看看你是否有你的價值在那裡。

1641
01:15:19,090 --> 01:15:22,490
但你服用的節點，
釋放它，基本上。

1642
01:15:22,490 --> 01:15:23,610
這就是卸載要求你這樣做。

1643
01:15:23,610 --> 01:15:24,670
免費一切你malloced。

1644
01:15:24,670 --> 01:15:27,480
所以，你經歷了整個名單
再次，要通過整個哈希

1645
01:15:27,480 --> 01:15:27,760
表一次。

1646
01:15:27,760 --> 01:15:29,240
這個時候不檢查
看看那裡的東西。

1647
01:15:29,240 --> 01:15:31,080
剛解放那裡的東西。

1648
01:15:31,080 --> 01:15:33,260
>> 終於大小。

1649
01:15:33,260 --> 01:15:34,350
大小應該得到實施。

1650
01:15:34,350 --> 01:15:35,590
如果不實現規模 - 

1651
01:15:35,590 --> 01:15:36,250
我會說像這樣。

1652
01:15:36,250 --> 01:15:39,740
如果你沒有在完全相同實現規模
一行代碼，包括

1653
01:15:39,740 --> 01:15:43,760
return語句，你是
不正確地做大小。

1654
01:15:43,760 --> 01:15:47,170
因此，請確保大小，完整的設計
點，你做的只有一個

1655
01:15:47,170 --> 01:15:49,970
行代碼，其中包括
return語句。

1656
01:15:49,970 --> 01:15:52,450
>> 並且不收拾然而，Akchar。

1657
01:15:52,450 --> 01:15:53,700
做事勤奮。

1658
01:15:53,700 --> 01:15:55,820

1659
01:15:55,820 --> 01:16:01,300
我想說謝謝你們
前來部分。

1660
01:16:01,300 --> 01:16:02,550
有一個快樂的萬聖節。

1661
01:16:02,550 --> 01:16:05,300

1662
01:16:05,300 --> 01:16:05,960
這是我的服裝。

1663
01:16:05,960 --> 01:16:08,850
我會在週四穿著這
如果我看到你在上班時間。

1664
01:16:08,850 --> 01:16:14,640
如果您想了解更多一些
背景為這件衣服，覺得

1665
01:16:14,640 --> 01:16:19,135
免費檢查出2011條
關於為什麼我一個故事

1666
01:16:19,135 --> 01:16:20,900
穿著南瓜服裝。

1667
01:16:20,900 --> 01:16:23,680
它是一個悲傷的故事。

1668
01:16:23,680 --> 01:16:27,050
所以一定要確保你有
附近的一些組織。

1669
01:16:27,050 --> 01:16:28,680
但是，如果您有任何
的問題，我會堅持圍繞

1670
01:16:28,680 --> 01:16:29,960
後段之外。

1671
01:16:29,960 --> 01:16:31,510
祝你好運問題組六。

1672
01:16:31,510 --> 01:16:33,540
和往常一樣，如果您有任何
的問題，讓我知道。

1673
01:16:33,540 --> 01:16:35,584