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