1
00:00:00,000 --> 00:00:11,460

2
00:00:11,460 --> 00:00:12,250
>> 国宝马兰所有权利。

3
00:00:12,250 --> 00:00:13,860
欢迎回到CS50。

4
00:00:13,860 --> 00:00:16,190
这是第8周开始。

5
00:00:16,190 --> 00:00:21,320
记得这个问题集5结束
带着一点点的挑战。

6
00:00:21,320 --> 00:00:25,210
因此，假如你恢复你所有的
教学研究员和加利福尼亚州的照片

7
00:00:25,210 --> 00:00:30,480
在card.raw文件，你有资格
现在发现所有的那些人，

8
00:00:30,480 --> 00:00:34,510
一个幸运的获胜者将步行回家与
这些东西，飞跃运动

9
00:00:34,510 --> 00:00:37,450
你可以使用最后的设备
项目，例如。

10
00:00:37,450 --> 00:00:39,860
>> ，每一年，这会导致
有点cre​​epiness。

11
00:00:39,860 --> 00:00:43,480
所以我想我会做什么是购
与您指出

12
00:00:43,480 --> 00:00:47,370
来回走了过
后期工作人员名单。

13
00:00:47,370 --> 00:00:51,110
举例来说，就在昨天晚上，报价
引文结束，从一名工作人员

14
00:00:51,110 --> 00:00:55,000
成员，“我只是一个学生敲
我的门，跟我拍一张照片。

15
00:00:55,000 --> 00:00:59,020
潜行者，我告诉你。“开始了
相当的描述，然后我们感动

16
00:00:59,020 --> 00:01:02,830
就到了，一个小时左右后，“我有一个
后部分学生在等着我

17
00:01:02,830 --> 00:01:06,080
他有我们的名字和照片
几张纸。“所有权利。

18
00:01:06,080 --> 00:01:09,230
所以组织，但不
这一切令人毛骨悚然。

19
00:01:09,230 --> 00:01:12,520
>> 那么，“我是出城的这个周末，
当我回来的时候，有一个在

20
00:01:12,520 --> 00:01:12,630
我的

21
00:01:12,630 --> 00:01:16,740
卧室里。“[笑]

22
00:01:16,740 --> 00:01:20,410
国宝的马兰：下报价从工作人员
成员，“一个学生来我家

23
00:01:20,410 --> 00:01:25,330
萨默维尔今早凌晨4点“。
工作人员，“我得到了我的酒店在圣

24
00:01:25,330 --> 00:01:30,016
旧金山和一名学生被等待
我在大堂有三个数码单反相机“。

25
00:01:30,016 --> 00:01:31,510
相机类型。

26
00:01:31,510 --> 00:01:34,980
“我什至不对员工这学期，
但学生闯进我家

27
00:01:34,980 --> 00:01:40,480
早晨和记录了整个事情
与谷歌的玻璃。“最后，

28
00:01:40,480 --> 00:01:43,650
“至少12人翘首
等待着我，当我离开了我

29
00:01:43,650 --> 00:01:44,800
豪华轿车，然后我

30
00:01:44,800 --> 00:01:46,970
醒了。“所有权利。

31
00:01:46,970 --> 00:01:57,690
因此，在拍摄的照片中，你可能
回想一下，这家伙在这里，你是谁

32
00:01:57,690 --> 00:02:01,850
可能知道米洛香蕉，谁住
劳伦·卡瓦略，我们的头

33
00:02:01,850 --> 00:02:02,905
教学研究员。

34
00:02:02,905 --> 00:02:05,170
米洛，米洛，来这里的孩子。

35
00:02:05,170 --> 00:02:06,320
米洛。

36
00:02:06,320 --> 00:02:08,650
米洛。

37
00:02:08,650 --> 00:02:12,230
你要知道，他的穿着谷歌的玻璃，所以
我们会告诉你这一切之后。

38
00:02:12,230 --> 00:02:16,190
因此，这是米洛，如果你想
后来与他拍一张照片。

39
00:02:16,190 --> 00:02:18,240
如果你想看看
在那里的观众。

40
00:02:18,240 --> 00:02:19,430
确定。

41
00:02:19,430 --> 00:02:20,200
这是很好的素材。

42
00:02:20,200 --> 00:02:22,556
嗯，香蕉米洛。

43
00:02:22,556 --> 00:02:23,941
哦，不做到这一点。

44
00:02:23,941 --> 00:02:29,020
>> [笑]

45
00:02:29,020 --> 00:02:29,470
>> 确定。

46
00:02:29,470 --> 00:02:34,550
所以一个单词，然后是什么样的未来，
因为当我们开始转型，

47
00:02:34,550 --> 00:02:38,410
具体而言，这个星期在从C
命令行环境PHP和

48
00:02:38,410 --> 00:02:42,720
JavaScript和SQL，HTML和CSS
一个基于网络的环境中，我们将

49
00:02:42,720 --> 00:02:44,490
你的所有装备
更多知识

50
00:02:44,490 --> 00:02:46,010
潜在的最终项目。

51
00:02:46,010 --> 00:02:49,240
为此，当然是有
传统举行研讨会

52
00:02:49,240 --> 00:02:50,950
上切线主题的
当然。

53
00:02:50,950 --> 00:02:54,330
非常相关的编程和
应用开发等等，但

54
00:02:54,330 --> 00:02:57,010
不一定探索
当然自己的教学大纲。

55
00:02:57,010 --> 00:03:00,250
>> 所以，如果你可能有兴趣在一个
今年的研讨会，

56
00:03:00,250 --> 00:03:02,530
注册cs50.net/seminar。

57
00:03:02,530 --> 00:03:06,170
有旧研讨会
在cs50.net/seminars。

58
00:03:06,170 --> 00:03:10,620
和今年迄今名册
惊人的Web应用程序使用Ruby on

59
00:03:10,620 --> 00:03:13,580
导轨，这是一种替代
语言PHP。

60
00:03:13,580 --> 00:03:14,900
计算语言学。

61
00:03:14,900 --> 00:03:18,710
到iOS，这是
平台，用于iPhone和

62
00:03:18,710 --> 00:03:19,850
iPad的发展。

63
00:03:19,850 --> 00:03:22,890
JavaScript的Web应用程序的，我们将讨论
，但在本次研讨会中，你会去

64
00:03:22,890 --> 00:03:24,070
的更多细节。

65
00:03:24,070 --> 00:03:27,390
>> 蹦蹦运动，所以我们实际上也有
我们的朋友从大跃进运动，

66
00:03:27,390 --> 00:03:29,160
公司本身，加入我们的行列。

67
00:03:29,160 --> 00:03:31,800
明天，其实，为客户提供
一个动手的研讨会，如果

68
00:03:31,800 --> 00:03:33,320
你的兴趣。

69
00:03:33,320 --> 00:03:38,770
meteor.js，另一种技术
而不是在浏览器中使用JavaScript，

70
00:03:38,770 --> 00:03:39,970
但在服务器上。

71
00:03:39,970 --> 00:03:42,110
Node.js的，这是非常
在该静脉。

72
00:03:42,110 --> 00:03:43,650
圆滑的Andr​​oid设计。

73
00:03:43,650 --> 00:03:46,990
Android的一个非常受欢迎的替代
的iOS和Windows Phone

74
00:03:46,990 --> 00:03:48,790
和其他移动平台。

75
00:03:48,790 --> 00:03:51,180
和Web安全主动防御。

76
00:03:51,180 --> 00:03:54,590
>> 因此，事实上，如果你想
搞这个，让我

77
00:03:54,590 --> 00:03:55,840
注意到这一点。

78
00:03:55,840 --> 00:03:57,790
我们非常高兴地说，
我们的朋友在大跃进

79
00:03:57,790 --> 00:03:59,140
运动，这是一个启动 - 

80
00:03:59,140 --> 00:04:01,300
这个装置实际上只是来到
出几个月前 - 

81
00:04:01,300 --> 00:04:05,960
慷慨捐赠30个此类设备
类尽可能多的学生，如果

82
00:04:05,960 --> 00:04:08,670
你想借硬件
朝学期结束，并用它来

83
00:04:08,670 --> 00:04:10,390
实际的最终项目。

84
00:04:10,390 --> 00:04:11,890
他们支持的语言数量。

85
00:04:11,890 --> 00:04:16,040
他们没有，他们没有PHP的，所以
实现一个或多个这些研讨会

86
00:04:16,040 --> 00:04:16,899
可能证明的兴趣。

87
00:04:16,899 --> 00:04:19,730
和所有的人将被拍摄下来的
倘若你是不是能够

88
00:04:19,730 --> 00:04:21,380
亲自出席。

89
00:04:21,380 --> 00:04:25,000
通过时间表公布
电子邮件作为我们巩固客房。

90
00:04:25,000 --> 00:04:28,460
>> 最后，如​​果你去
projects.cs.50.net，这是一个网站

91
00:04:28,460 --> 00:04:31,450
我们维持每年我们邀请
人们从社会，教师，

92
00:04:31,450 --> 00:04:36,420
部门，人员，并且都
在CS50至外侧的

93
00:04:36,420 --> 00:04:37,730
提出项目设想。

94
00:04:37,730 --> 00:04:39,050
学生群体感兴趣的东西。

95
00:04:39,050 --> 00:04:40,600
部门关心的事情。

96
00:04:40,600 --> 00:04:43,990
因此，不要打开，如果你在挣扎
与你的不确定性

97
00:04:43,990 --> 00:04:46,700
自己想解决的。

98
00:04:46,700 --> 00:04:51,760
>> 所以我们推出了一个可以说是最后一次
比我们更复杂的数据结构

99
00:04:51,760 --> 00:04:53,300
在过去的几周里看到。

100
00:04:53,300 --> 00:04:56,550
我们一直在使用数组漂亮
高兴地作为一个有用的，如果

101
00:04:56,550 --> 00:04:58,160
简单化的数据结构。

102
00:04:58,160 --> 00:05:00,570
然后，我们介绍了这些，
当然链表。

103
00:05:00,570 --> 00:05:05,470
到底是什么东西的动机之一
引入这个数据结构？

104
00:05:05,470 --> 00:05:06,930
是吗？

105
00:05:06,930 --> 00:05:07,250
那是什么？

106
00:05:07,250 --> 00:05:08,080
>> 观众：动态大小。

107
00:05:08,080 --> 00:05:09,040
>> 大卫马兰：动态尺寸。

108
00:05:09,040 --> 00:05:11,890
因此，而数组中，你必须
知道它的大小时提前

109
00:05:11,890 --> 00:05:12,740
你分配。

110
00:05:12,740 --> 00:05:14,380
链表，你不这样做
要知道。

111
00:05:14,380 --> 00:05:17,610
你可以只是malloc的，或更普遍的，
增拨

112
00:05:17,610 --> 00:05:20,720
节点，可以这么说，任何时候，你
要插入更多的数据。

113
00:05:20,720 --> 00:05:22,670
节点没有预定的意义。

114
00:05:22,670 --> 00:05:25,580
这只是一个普通术语，描述
我们某种容器

115
00:05:25,580 --> 00:05:29,610
使用我们的数据结构存储
一些感兴趣的项目，在这个

116
00:05:29,610 --> 00:05:31,750
情况是整数。

117
00:05:31,750 --> 00:05:33,160
>> 但是总是有一个权衡。

118
00:05:33,160 --> 00:05:38,070
因此，我们得到的数据的大小动态
结构，但我们付出什么样的价格？

119
00:05:38,070 --> 00:05:40,040
链表的缺点是什么？

120
00:05:40,040 --> 00:05:41,006
是吗？

121
00:05:41,006 --> 00:05:41,980
>> 观众：需要更多的内存。

122
00:05:41,980 --> 00:05:44,240
>> 国宝马兰：它需要更多的
内存，究竟怎么了？

123
00:05:44,240 --> 00:05:46,440
>> 观众：[听不清]。

124
00:05:46,440 --> 00:05:47,050
>> DAVID马兰：没错。

125
00:05:47,050 --> 00:05:50,460
所以，现在我们已经指针
额外的内存，我们以前

126
00:05:50,460 --> 00:05:53,040
并不需要，因为优势
一个数组，当然是

127
00:05:53,040 --> 00:05:54,860
一切连片，
背靠背，

128
00:05:54,860 --> 00:05:56,380
为您提供了随机访问。

129
00:05:56,380 --> 00:06:00,710
因为只需使用方括号
符号，或更技术上的指针

130
00:06:00,710 --> 00:06:03,580
算术，很简单，此外，
你可以访问任何

131
00:06:03,580 --> 00:06:05,700
在固定时间内的元素。

132
00:06:05,700 --> 00:06:08,975
而事实上，这是一种暗示
另一个价格，我们正在与支付

133
00:06:08,975 --> 00:06:09,760
链表。

134
00:06:09,760 --> 00:06:13,890
>> 会发生什么情况的运行时间
像搜索，如果我想

135
00:06:13,890 --> 00:06:17,270
找到一些价值和内部
链表？

136
00:06:17,270 --> 00:06:20,290
成为我的运行时间是什么？

137
00:06:20,290 --> 00:06:21,560
大O的n。

138
00:06:21,560 --> 00:06:24,060
如果它的排序？

139
00:06:24,060 --> 00:06:25,440
如果数据结构的排序？

140
00:06:25,440 --> 00:06:28,640
我可以做的更好的比大
n为O的搜索？

141
00:06:28,640 --> 00:06:31,700
没有，因为在最坏的情况下，它可能会
很好地进行排序，但数量

142
00:06:31,700 --> 00:06:32,950
你要找的可能是很大的。

143
00:06:32,950 --> 00:06:35,370
它可能是第100号，
可能发生的事情是所有

144
00:06:35,370 --> 00:06:36,410
在结束的方式。

145
00:06:36,410 --> 00:06:39,950
因为你只能访问一个链接
在本实施的喜爱

146
00:06:39,950 --> 00:06:42,690
其第一个节点的方式，你
依然是那样的运气了。

147
00:06:42,690 --> 00:06:47,450
你必须遍历整个事情
从第一次到最后，为了找到

148
00:06:47,450 --> 00:06:49,150
像100那么大价值。

149
00:06:49,150 --> 00:06:51,350
或确定，如果它是
甚至没有。

150
00:06:51,350 --> 00:06:55,960
>> 因此，我们不能做什么算法在数据
结构看起来像这样吗？

151
00:06:55,960 --> 00:06:59,460
我们不能这样做，因为二进制搜索
二进制搜索需要，我们有

152
00:06:59,460 --> 00:07:00,740
随机访问。

153
00:07:00,740 --> 00:07:04,500
我们只能从位置到飞跃
的位置，而无需遵循

154
00:07:04,500 --> 00:07:07,080
这些面包屑的形式
所有这些指针。

155
00:07:07,080 --> 00:07:08,300
>> 现在，我们怎么实现呢？

156
00:07:08,300 --> 00:07:12,830
那么，如果我们到屏幕上，在这里，如果
我们可以很快地重新实现此数据

157
00:07:12,830 --> 00:07:13,440
结构 - 

158
00:07:13,440 --> 00:07:15,670
我的笔迹​​不是所有的
在这里，伟大的，但我们会尽力。

159
00:07:15,670 --> 00:07:22,030
所以typedef结构，什么我
要调用这个东西在这里？

160
00:07:22,030 --> 00:07:22,960
节点。

161
00:07:22,960 --> 00:07:24,580
因此，我将让我们开始。

162
00:07:24,580 --> 00:07:27,860
而现在，需要将里面的
该单独的数据结构

163
00:07:27,860 --> 00:07:28,430
链表？

164
00:07:28,430 --> 00:07:29,950
多少个字段？

165
00:07:29,950 --> 00:07:30,450
>> 所以两个。

166
00:07:30,450 --> 00:07:31,570
一个是很容易的。

167
00:07:31,570 --> 00:07:33,050
所以INT N。

168
00:07:33,050 --> 00:07:35,930
我们可以称之为ñ我们想要的东西，
但它应该是一个int，如果我们

169
00:07:35,930 --> 00:07:37,660
实现链表为整数。

170
00:07:37,660 --> 00:07:41,920
现在什么第二
现场有吗？

171
00:07:41,920 --> 00:07:43,460
结构节点。

172
00:07:43,460 --> 00:07:50,570
所以，如果我做节点，然后我
可以调用这个也是我想做的事情，

173
00:07:50,570 --> 00:07:53,510
但仅仅是明确的，我会打电话
未来，因为我们一直在做的事情。

174
00:07:53,510 --> 00:07:55,270
然后我会关闭我的花括号。

175
00:07:55,270 --> 00:08:00,700
>> 而现在，作为最后一次，
我把节点。

176
00:08:00,700 --> 00:08:03,830
但是，如果我声明，这是作为一个
节点，我为什么懒得如此

177
00:08:03,830 --> 00:08:07,320
详细在这里宣布结构
节点下，而不是

178
00:08:07,320 --> 00:08:09,210
只是节点*？

179
00:08:09,210 --> 00:08:09,904
是吗？

180
00:08:09,904 --> 00:08:12,810
>> 观众：[听不清]。

181
00:08:12,810 --> 00:08:14,050
>> DAVID马兰：没错。

182
00:08:14,050 --> 00:08:14,530
没错。

183
00:08:14,530 --> 00:08:18,320
由于C真的需要你从字面上
只看到的定义节点

184
00:08:18,320 --> 00:08:21,230
一路下来这里，你可以不
是指它在这里。

185
00:08:21,230 --> 00:08:24,760
因此，我们有这种先发制人
声明在这里，这是无可否认

186
00:08:24,760 --> 00:08:25,390
更详细。

187
00:08:25,390 --> 00:08:27,810
节点结构，这意味着
我们现在可以访问它

188
00:08:27,810 --> 00:08:29,760
内部的数据结构。

189
00:08:29,760 --> 00:08:33,370
>> 顺便说一句，因为这是
现在成为一个更主观一点，

190
00:08:33,370 --> 00:08:36,230
明星可以在技术上走在这里，
它可以去这里，它可以

191
00:08:36,230 --> 00:08:37,179
甚至在中间。

192
00:08:37,179 --> 00:08:39,890
我们已经通过，在风格指南
当然，把公约

193
00:08:39,890 --> 00:08:42,299
星旁边的数据
型，在这种情况下，

194
00:08:42,299 --> 00:08:43,460
将结构节点。

195
00:08:43,460 --> 00:08:46,620
但实现大量课本
在线参考，事实上，你可能会

196
00:08:46,620 --> 00:08:48,450
看到它的另一侧。

197
00:08:48,450 --> 00:08:52,200
但是，仅仅实现这两个实际上会
工作，你应该仅仅是

198
00:08:52,200 --> 00:08:52,970
一致的。

199
00:08:52,970 --> 00:08:53,580
>> 好的。

200
00:08:53,580 --> 00:08:55,630
所以这是我们的宣言
结构节点。

201
00:08:55,630 --> 00:08:59,430
但后来我们开始做更多
复杂的事情。

202
00:08:59,430 --> 00:09:03,410
例如，我们决定引进
如哈希表的东西。

203
00:09:03,410 --> 00:09:08,160
因此，这里是一个哈希表大小为n，
索引从0到n的左上方

204
00:09:08,160 --> 00:09:09,690
减去1的左下角。

205
00:09:09,690 --> 00:09:11,640
这可能是一个散列
表中的任何东西。

206
00:09:11,640 --> 00:09:15,340
但我们讨论了什么事情
使用一个哈希表怎么样？

207
00:09:15,340 --> 00:09:18,370
存储是什么？

208
00:09:18,370 --> 00:09:18,800
>> 名称。

209
00:09:18,800 --> 00:09:20,870
我们可以做名字，如
我们做了最后一次。

210
00:09:20,870 --> 00:09:22,200
真的，你可以存储任何东西。

211
00:09:22,200 --> 00:09:24,640
我们将再次看到这
PHP和JavaScript中。

212
00:09:24,640 --> 00:09:28,550
哈希表是一个很好的瑞士排序
瑞士军刀，允许你存储

213
00:09:28,550 --> 00:09:33,690
几乎任何你想要的内侧
它的关联值的键。

214
00:09:33,690 --> 00:09:34,770
键与值。

215
00:09:34,770 --> 00:09:37,800
>> 现在，在这个简单的情况下，我们的
只是数字键。

216
00:09:37,800 --> 00:09:40,380
我们正在实施一个哈希
表中为一个数组。

217
00:09:40,380 --> 00:09:43,500
等键是0，
1，2，等等。

218
00:09:43,500 --> 00:09:47,200
因此，我们作为人类，最后决定
本周，你知道吗，如果我们

219
00:09:47,200 --> 00:09:50,410
去商店名称，让我们只是
随意，但相当合理的，

220
00:09:50,410 --> 00:09:54,680
假设Alice，一个名字，
只是索引为0。

221
00:09:54,680 --> 00:09:58,030
鲍勃，一个B的名字，将被索引
为1，等等。

222
00:09:58,030 --> 00:10:02,490
因此，我们不得不投入之间的映射，
是字符串，和散列

223
00:10:02,490 --> 00:10:04,560
的位置，这是数字的。

224
00:10:04,560 --> 00:10:07,740
>> 因此，该过程通常被称为
哈希函数，你可以真正

225
00:10:07,740 --> 00:10:09,130
在代码中实现它。

226
00:10:09,130 --> 00:10:12,080
如果我想实现的哈希函数
这不正是我们

227
00:10:12,080 --> 00:10:17,070
刚刚描述的从去年的时候，我可能会
声明一个函数，它作为

228
00:10:17,070 --> 00:10:18,330
例如输入 - 

229
00:10:18,330 --> 00:10:22,190
，让我们做到这一点在此
屏幕在这里。

230
00:10:22,190 --> 00:10:26,180
如果我想实现一个哈希
的功能，我可能会说，

231
00:10:26,180 --> 00:10:27,410
这样的事情。

232
00:10:27,410 --> 00:10:29,030
>> 这将返回一个int。

233
00:10:29,030 --> 00:10:33,600
这将被称为哈希，它是
要接受的参数是一个

234
00:10:33,600 --> 00:10:38,920
字符串，或者我们可以更恰当，
说的char *，我们会打电话给它s。

235
00:10:38,920 --> 00:10:43,840
然后这一切功​​能，
最终，返回一个int。

236
00:10:43,840 --> 00:10:45,990
现在，它是如何可能
不那么清晰。

237
00:10:45,990 --> 00:10:49,510
我要实现这个没有任何
现在形成的错误检查。

238
00:10:49,510 --> 00:10:55,740
我只是一味地说，返回
无论是在s支架0，减，

239
00:10:55,740 --> 00:10:58,850
比方说，资本用分号。

240
00:10:58,850 --> 00:10:59,960
>> 完全打破。

241
00:10:59,960 --> 00:11:02,620
它并不完美，因为
一，什么如果s是空？

242
00:11:02,620 --> 00:11:04,000
不好的事情将要发生。

243
00:11:04,000 --> 00:11:07,940
二，如果在此的第一个字母
名字是不是一个大写字母？

244
00:11:07,940 --> 00:11:09,860
这不会变成
出。

245
00:11:09,860 --> 00:11:11,970
这可能是一个小写字母
不是一个字母。

246
00:11:11,970 --> 00:11:15,520
所以完全改进的余地，
但是这是基本的想法。

247
00:11:15,520 --> 00:11:19,010
>> 我们上周口头
只是一个过程的映射爱丽丝

248
00:11:19,010 --> 00:11:23,360
0和Bob 1可以表示
当然更公式为C

249
00:11:23,360 --> 00:11:24,320
在这里发挥作用。

250
00:11:24,320 --> 00:11:28,630
再次调用哈希，将一个字符串作为
输入，然后莫名其妙地做一些事情

251
00:11:28,630 --> 00:11:31,020
与该输入信号以产生一个输出。

252
00:11:31,020 --> 00:11:34,130
不像我们的黑箱描述
长期以来，我们已经完成了。

253
00:11:34,130 --> 00:11:36,550
我不知道如何，这可能是
引擎盖下工作。

254
00:11:36,550 --> 00:11:40,120
>> 对于问题集6，面临的挑战之一
是你来决定什么

255
00:11:40,120 --> 00:11:41,920
您的哈希函数是什么？

256
00:11:41,920 --> 00:11:45,760
这是怎么回事，里面那个黑
框，据推测，它会是一个

257
00:11:45,760 --> 00:11:50,380
比这更有趣一点，
肯定更容易出错

258
00:11:50,380 --> 00:11:53,180
这个特殊的检查比
实现。

259
00:11:53,180 --> 00:11:54,580
>> 但可能会出现问题，对不对？

260
00:11:54,580 --> 00:11:57,760
如果我们有一个数据结构，例如
一，什么是一个问题

261
00:11:57,760 --> 00:12:01,600
你可以运行到随着时间的推移，当您插入
越来越多的名字进入

262
00:12:01,600 --> 00:12:02,880
哈希表？

263
00:12:02,880 --> 00:12:04,630
你得到的碰撞，对不对？

264
00:12:04,630 --> 00:12:07,560
如果你有爱丽丝和亚伦，
两个人的名字发生

265
00:12:07,560 --> 00:12:08,190
开始与A？

266
00:12:08,190 --> 00:12:11,660
这引出了一个问题，在那里你
把第二个这样的名字？

267
00:12:11,660 --> 00:12:15,050
>> 那么，你可能天真地把它
鲍勃属于的地方，但随后鲍勃是

268
00:12:15,050 --> 00:12:17,300
拧种，如果您尝试
插入他的名字旁边，

269
00:12:17,300 --> 00:12:18,240
有没有他的空间。

270
00:12:18,240 --> 00:12:21,400
所以，你不妨把鲍勃·查理在哪里，
你能想象这个非常迅速

271
00:12:21,400 --> 00:12:23,020
下放成有点乱。

272
00:12:23,020 --> 00:12:25,600
线性的东西到底是哪里你
只需要搜索整个事情

273
00:12:25,600 --> 00:12:28,190
寻找Alice或Bob
或亚伦查理。

274
00:12:28,190 --> 00:12:33,230
>> 因此，而不是我们提出的，而不是只
线性开放空间探测的

275
00:12:33,230 --> 00:12:36,450
横卧在那里，我们的名字
提出一个票友的方法。

276
00:12:36,450 --> 00:12:41,740
哈希表仍与实现
的索引数组，但数据不同的

277
00:12:41,740 --> 00:12:44,500
现在，这些指数分别为指针。

278
00:12:44,500 --> 00:12:47,360
指点一下吗？

279
00:12:47,360 --> 00:12:48,730
链表的指针。

280
00:12:48,730 --> 00:12:53,330
>> 因为召回链表是
真的只是一个指针，指向一个节点，

281
00:12:53,330 --> 00:12:57,110
节点具有一个下一个域，该节点
有一个下一个域，等等。

282
00:12:57,110 --> 00:13:00,690
所以，你现在觉得这个数组
作为一个哈希表的左手侧

283
00:13:00,690 --> 00:13:01,820
导致一个链表。

284
00:13:01,820 --> 00:13:07,000
如果你得到一个优势是
Alice和亚伦之间的碰撞，

285
00:13:07,000 --> 00:13:09,300
你是做什么的
第二个这样的人吗？

286
00:13:09,300 --> 00:13:14,150
你只重视他或她的
端，甚至开始

287
00:13:14,150 --> 00:13:15,490
该链表。

288
00:13:15,490 --> 00:13:17,340
>> 而实际上，让我们只是面条通过
第二。

289
00:13:17,340 --> 00:13:18,640
哪里最有意义？

290
00:13:18,640 --> 00:13:22,060
如果我插入爱丽丝和她结束
第一的位置，然后我尝试

291
00:13:22,060 --> 00:13:25,310
插入亚伦的名字，而且也
显然是一个碰撞，我应该把

292
00:13:25,310 --> 00:13:27,400
他开始时
链表？

293
00:13:27,400 --> 00:13:30,944
这是在那个第一的位置，
或在结束了吗？

294
00:13:30,944 --> 00:13:31,440
>> 观众：[听不清]。

295
00:13:31,440 --> 00:13:31,990
>> DAVID马兰：OK。

296
00:13:31,990 --> 00:13:32,490
我听说开始。

297
00:13:32,490 --> 00:13:33,903
为什么在开始？

298
00:13:33,903 --> 00:13:34,750
>> 观众：[听不清]。

299
00:13:34,750 --> 00:13:34,940
>> DAVID马兰：OK。

300
00:13:34,940 --> 00:13:36,520
它是按字母顺序排列的，所以这是很好的。

301
00:13:36,520 --> 00:13:37,330
这是一个很好的属性。

302
00:13:37,330 --> 00:13:39,335
它会来救我的潜在的一段时间。

303
00:13:39,335 --> 00:13:43,290
它不会让我做二进制搜索，但我
可能至少能够打出来

304
00:13:43,290 --> 00:13:47,340
一个循环，如果我知道，好了，我的方式
过去亚伦将在此

305
00:13:47,340 --> 00:13:48,310
链表排序。

306
00:13:48,310 --> 00:13:50,360
我没有浪费我的时间寻找
所有的方式结束。

307
00:13:50,360 --> 00:13:51,530
所以这是合理的。

308
00:13:51,530 --> 00:13:54,710
你为什么要插入
在碰撞的名字

309
00:13:54,710 --> 00:13:56,660
列表开始？

310
00:13:56,660 --> 00:13:57,397
那是什么？

311
00:13:57,397 --> 00:13:58,680
>> 观众：[听不清]。

312
00:13:58,680 --> 00:14:00,820
>> 国宝马兰：这可能需要很长一段时间
得到的列表末尾。

313
00:14:00,820 --> 00:14:02,490
而事实上，长。

314
00:14:02,490 --> 00:14:04,920
越多的名字你插入
开始，不再

315
00:14:04,920 --> 00:14:06,280
链要得到的。

316
00:14:06,280 --> 00:14:07,890
的时间越长，挂钩
列表会得到什么。

317
00:14:07,890 --> 00:14:09,420
所以，你真的只是
浪费你的时间。

318
00:14:09,420 --> 00:14:14,070
也许你更好的维护
恒定的插入时间，大O 1，

319
00:14:14,070 --> 00:14:18,470
始终把碰撞名
该链表的开头，

320
00:14:18,470 --> 00:14:21,230
而不是尽可能多担心
关于排序。

321
00:14:21,230 --> 00:14:22,600
>> 什么是最好的答案吗？

322
00:14:22,600 --> 00:14:23,320
目前还不清楚。

323
00:14:23,320 --> 00:14:26,140
一种取决于什么
分布模式是什么

324
00:14:26,140 --> 00:14:27,850
你的名字插入。

325
00:14:27,850 --> 00:14:29,430
这不一定
一个明显的答案。

326
00:14:29,430 --> 00:14:33,100
但在这里，再次
设计的机会。

327
00:14:33,100 --> 00:14:37,220
>> 因此，我们再看着这件事情，
真正的另一大机遇

328
00:14:37,220 --> 00:14:38,180
为对集6。

329
00:14:38,180 --> 00:14:41,770
与实现，如果你还没有的话，
的Zamyla潜入这两个哈希

330
00:14:41,770 --> 00:14:43,260
表和尝试，更详细。

331
00:14:43,260 --> 00:14:45,630
和视频演练的是
嵌入在对一套规范。

332
00:14:45,630 --> 00:14:46,590
这是特里 - 

333
00:14:46,590 --> 00:14:51,670
T-R-I-E。什么是有趣的
这是运行时间

334
00:14:51,670 --> 00:14:59,510
寻找一个名字，像麦克斯韦
最后一次，是大O是什么？

335
00:14:59,510 --> 00:15:01,040
那是什么？

336
00:15:01,040 --> 00:15:01,920
>> 观众：数字字母。

337
00:15:01,920 --> 00:15:02,550
>> 国宝马兰：字母数。

338
00:15:02,550 --> 00:15:03,210
我听说了两件事情。

339
00:15:03,210 --> 00:15:04,630
字母和恒定的时间数。

340
00:15:04,630 --> 00:15:05,540
所以，让我们与第一。

341
00:15:05,540 --> 00:15:06,410
的字母数。

342
00:15:06,410 --> 00:15:10,195
那么，这样的数据结构，召回，
像一棵树，一个家庭树，每个

343
00:15:10,195 --> 00:15:12,860
的节点组成的数组。

344
00:15:12,860 --> 00:15:16,300
这些数组指针
其他这样的节点，或其他这样的

345
00:15:16,300 --> 00:15:17,670
树中的数组。

346
00:15:17,670 --> 00:15:22,890
>> 因此，如果我们想要再确定
麦克斯韦是否是在这里，我可能去

347
00:15:22,890 --> 00:15:26,890
第一阵列，​​在最顶部的
树中，所谓的根，顶部

348
00:15:26,890 --> 00:15:30,521
特里，然后按照米指针，
然后是一个指针，那么x，

349
00:15:30,521 --> 00:15:31,710
W，E，L，L。

350
00:15:31,710 --> 00:15:34,910
然后当我看到一些特殊的符号，
在这里表示为三角形。

351
00:15:34,910 --> 00:15:38,480
在代码中，你会看到我们建议您
为bool实施，只是说是

352
00:15:38,480 --> 00:15:40,540
或没有，一个字在这里停止。

353
00:15:40,540 --> 00:15:45,270
>> 那么，一旦我们去参加M-à-X-W-E-L-L，
感觉就像七，也许

354
00:15:45,270 --> 00:15:48,910
八，如果我们走过去吧，八
步骤找麦克斯韦。

355
00:15:48,910 --> 00:15:53,050
还是让我们叫它K.但记得最后
的时候，我认为，如果有

356
00:15:53,050 --> 00:15:57,540
切实的最大长度上
字，像40一些奇怪的字符，

357
00:15:57,540 --> 00:16:00,810
最大长度意味着
一个恒定值。

358
00:16:00,810 --> 00:16:05,770
所以真的，是的，这是技术上的大O
8或7，或真大O K.，但

359
00:16:05,770 --> 00:16:09,420
如果有一个有限的上限是什么
K表，这是一个常数。

360
00:16:09,420 --> 00:16:12,080
所以它的大O 1
在一天结束时。

361
00:16:12,080 --> 00:16:13,040
>> 不是在现实世界中。

362
00:16:13,040 --> 00:16:15,960
当你真正开始看
时钟程序的运行。

363
00:16:15,960 --> 00:16:20,690
这绝对是有点
比真正的恒定速度较慢

364
00:16:20,690 --> 00:16:21,840
时间与步骤。

365
00:16:21,840 --> 00:16:25,540
这将是七八步，
但仍然好得多

366
00:16:25,540 --> 00:16:30,080
比大O n表示这样的算法
的大小取决于什么

367
00:16:30,080 --> 00:16:31,220
的数据结构。

368
00:16:31,220 --> 00:16:34,970
>> 请注意，这里的上攻，我们可以插入
百万名到这个

369
00:16:34,970 --> 00:16:38,170
数据结构，但很多步
它是要带我们去找到

370
00:16:38,170 --> 00:16:40,480
麦克斯韦在这种情况下？

371
00:16:40,480 --> 00:16:40,780
没有。

372
00:16:40,780 --> 00:16:41,820
他不受影响。

373
00:16:41,820 --> 00:16:45,480
到今天为止，我不认为我们已经看到了
的一个例子的数据结构或

374
00:16:45,480 --> 00:16:48,560
完全的算法
不受外部

375
00:16:48,560 --> 00:16:50,040
这样的行为。

376
00:16:50,040 --> 00:16:51,160
但是，这不能是惊人的。

377
00:16:51,160 --> 00:16:52,900
这不能是唯一的解决方案
对于p-集

378
00:16:52,900 --> 00:16:53,570
>> 而事实并非如此。

379
00:16:53,570 --> 00:16:55,980
这不一定是数据
结构应该吸引到，

380
00:16:55,980 --> 00:16:58,220
因为像哈希表，权衡。

381
00:16:58,220 --> 00:17:00,500
你付出的代价是什么？

382
00:17:00,500 --> 00:17:00,940
内存。

383
00:17:00,940 --> 00:17:02,890
我的意思是，这是一个穷凶极恶
的内存量。

384
00:17:02,890 --> 00:17:05,569
你不能完全看到它，因为这里
这幅画的作者

385
00:17:05,569 --> 00:17:09,420
显然截断所有阵列
和我们没有看到很多A的

386
00:17:09,420 --> 00:17:12,700
B的和C和Q和Y
和Z的这些数组中。

387
00:17:12,700 --> 00:17:13,630
但是，他们在那里。

388
00:17:13,630 --> 00:17:17,660
>> 每个节点是一个整体的阵列
约26或更多的字节，每个字节

389
00:17:17,660 --> 00:17:19,170
这代表一个字母。

390
00:17:19,170 --> 00:17:22,920
在我们的案例中，这样我们就可以支持27
单引号的问题集。

391
00:17:22,920 --> 00:17:27,030
因此，这个数据结构是真的，
非常密集和广泛。

392
00:17:27,030 --> 00:17:30,880
这本身最终可能会放缓
下来的东西，或者至少是成本你

393
00:17:30,880 --> 00:17:32,240
更多的空间。

394
00:17:32,240 --> 00:17:34,020
但同样，我们可以得出
这里的比较。

395
00:17:34,020 --> 00:17:39,190
>> 回忆了一段时间后，我们取得了很大成就
更令人兴奋的运行时间排序

396
00:17:39,190 --> 00:17:42,880
当我们使用归并排序，但价格
我们实现N个记录n为合并支付

397
00:17:42,880 --> 00:17:46,930
排序要求，我们花
什么资源？

398
00:17:46,930 --> 00:17:47,690
更多的空间。

399
00:17:47,690 --> 00:17:50,530
我们需要一个辅助阵列
复制人，就像

400
00:17:50,530 --> 00:17:51,620
我们在这里做的，在舞台上。

401
00:17:51,620 --> 00:17:55,880
如此反复，没有明显的赢家，
只是主观设计

402
00:17:55,880 --> 00:17:57,710
作出的决定。

403
00:17:57,710 --> 00:17:58,060
>> 好的。

404
00:17:58,060 --> 00:17:59,130
因此，这个怎么样？

405
00:17:59,130 --> 00:18:02,050
任何人都承认，D-霍尔？

406
00:18:02,050 --> 00:18:02,440
确定。

407
00:18:02,440 --> 00:18:03,170
所以，我们三个做。

408
00:18:03,170 --> 00:18:03,750
奥美大厦。

409
00:18:03,750 --> 00:18:05,070
因此，这是奥美的餐饮。

410
00:18:05,070 --> 00:18:09,650
我敢打赌，所有食堂
这样的托盘堆。

411
00:18:09,650 --> 00:18:11,950
这实际上是代表
的东西，我们已经

412
00:18:11,950 --> 00:18:13,050
显然已经看到。

413
00:18:13,050 --> 00:18:14,850
我们把它称为名副其实的堆栈。

414
00:18:14,850 --> 00:18:18,970
栈，您
计算机的内存，数据去

415
00:18:18,970 --> 00:18:20,460
当功能被调用。

416
00:18:20,460 --> 00:18:23,410
>> 例如，什么样的东西去
相对于在堆栈上

417
00:18:23,410 --> 00:18:27,420
我们已经讨论过的内存布局
在过去的几周？

418
00:18:27,420 --> 00:18:28,736
那是什么？

419
00:18:28,736 --> 00:18:29,670
>> 观众：函数调用。

420
00:18:29,670 --> 00:18:30,260
>> DAVID马兰：对不起。

421
00:18:30,260 --> 00:18:31,210
>> 观众：函数调用。

422
00:18:31,210 --> 00:18:33,590
>> DAVID马兰：通话功能，但
具体而言，每个里面有什么

423
00:18:33,590 --> 00:18:35,340
这些帧？

424
00:18:35,340 --> 00:18:37,220
什么样的东西呢？

425
00:18:37,220 --> 00:18:37,460
嗯。

426
00:18:37,460 --> 00:18:38,500
因此，局部变量。

427
00:18:38,500 --> 00:18:43,080
任何时候，我们需要一些本地存储，
像一个说法，或INT I，或int

428
00:18:43,080 --> 00:18:45,940
温度，或任何地方
变量，我们已经

429
00:18:45,940 --> 00:18:47,210
将在堆栈上。

430
00:18:47,210 --> 00:18:49,610
我们称之为堆栈，因为
该分层想法。

431
00:18:49,610 --> 00:18:52,940
的比赛只是一种现实，
其概念。

432
00:18:52,940 --> 00:18:56,650
>> 但事实证明，一摞还可以
被看作是一个数据结构，一个

433
00:18:56,650 --> 00:19:00,110
替代一个数组，另一种
链表。

434
00:19:00,110 --> 00:19:02,770
概念上的东西更有趣
仍然可以

435
00:19:02,770 --> 00:19:06,030
那些采用
的东西，但它是一个不同类型的

436
00:19:06,030 --> 00:19:09,140
数据结构的支持，真的，
只有两个操作。

437
00:19:09,140 --> 00:19:11,000
但是，您可以添加票友
功能不止这些。

438
00:19:11,000 --> 00:19:12,180
但这些都是基础知识 - 

439
00:19:12,180 --> 00:19:13,510
push和pop。

440
00:19:13,510 --> 00:19:19,240
>> 用栈的想法是，如果我
这里有，带或不带安南伯格

441
00:19:19,240 --> 00:19:22,880
知道，一个托盘从隔壁
数字9就可以了。

442
00:19:22,880 --> 00:19:23,870
所以只是一个int。

443
00:19:23,870 --> 00:19:26,990
我要推到数据
结构，目前是空的。

444
00:19:26,990 --> 00:19:28,790
考虑这个堆栈的底部。

445
00:19:28,790 --> 00:19:33,150
我会推到9号
堆叠，而现在它就在那里。

446
00:19:33,150 --> 00:19:36,040
>> 但有趣的关于堆栈
是，如果我现在要推

447
00:19:36,040 --> 00:19:40,210
其他一些值，比如17，我推
入堆栈，我要做的事情

448
00:19:40,210 --> 00:19:43,290
直观的东西，我只是
说得不对，我们人类

449
00:19:43,290 --> 00:19:45,180
会倾向于把它之上。

450
00:19:45,180 --> 00:19:48,850
但是，什么是有趣
，我怎么在9？

451
00:19:48,850 --> 00:19:50,670
你知道，我不是没有做一些努力。

452
00:19:50,670 --> 00:19:54,070
>> 那么，什么是有趣的
堆栈，设计，

453
00:19:54,070 --> 00:19:56,330
这是一个后进先出的数据结构。

454
00:19:56,330 --> 00:19:59,680
傻的方式描述
后进先出。

455
00:19:59,680 --> 00:20:03,280
所以最后一个数字
在这个时候的时间是17。

456
00:20:03,280 --> 00:20:07,540
所以，如果我想流行的东西
栈，它只能是17。

457
00:20:07,540 --> 00:20:11,890
所以这是一个强制性的顺序
这里的操作，其中的最后一个项目

458
00:20:11,890 --> 00:20:14,260
在成为第一个出。

459
00:20:14,260 --> 00:20:16,440
因此，首字母缩写词，后进先出法。

460
00:20:16,440 --> 00:20:19,160
>> 那么，为什么会这样有用吗？

461
00:20:19,160 --> 00:20:22,690
是的语境中，你
我想这样的一个数据结构？

462
00:20:22,690 --> 00:20:24,810
那么，它肯定是有用的
内的一台计算机。

463
00:20:24,810 --> 00:20:29,050
所以操作系统显然使用此
一种数据结构栈。

464
00:20:29,050 --> 00:20:32,800
我们还会看到同样的想法
当它涉及到网页。

465
00:20:32,800 --> 00:20:35,890
因此，本周和下周超越，
而当你开始实现Web

466
00:20:35,890 --> 00:20:39,490
称为HTML页面的语言，你可以
实际使用的数据结构，如

467
00:20:39,490 --> 00:20:42,690
这是为了确定的页面
是正确的格式。

468
00:20:42,690 --> 00:20:47,170
因为我们会看到所有的网页遵循
一种层次，压痕

469
00:20:47,170 --> 00:20:52,030
在一天结束时，将是
引擎盖下的树结构。

470
00:20:52,030 --> 00:20:53,620
所以，更多的只是一点点。

471
00:20:53,620 --> 00:20:56,560
>> 但现在，让我们提出一个
此刻，我们怎么可能去

472
00:20:56,560 --> 00:20:58,830
相当于一个堆栈是什么？

473
00:20:58,830 --> 00:21:03,370
最后，我提议，我们实施
像这样的代码堆栈。

474
00:21:03,370 --> 00:21:07,990
因此，堆栈里面它都将有
两件事情，一个数组，称为托盘

475
00:21:07,990 --> 00:21:09,510
只是要符合演示。

476
00:21:09,510 --> 00:21:12,660
和该阵列中的每个项目
将是一个int类型的。

477
00:21:12,660 --> 00:21:14,740
和能力大概是什么？

478
00:21:14,740 --> 00:21:18,796
因为我没有写
这里完整定义。

479
00:21:18,796 --> 00:21:21,535
>> 这可能是最大的
数组的大小。

480
00:21:21,535 --> 00:21:25,150
而且它可能急剧宣布
上面的文件顶部的定义，一些

481
00:21:25,150 --> 00:21:28,450
所隐含类型的常量
单纯的资本。

482
00:21:28,450 --> 00:21:32,250
所以某处容量定义
作为可能的最大尺寸。

483
00:21:32,250 --> 00:21:35,590
同时，内部的数据结构
被称为一个堆栈将有

484
00:21:35,590 --> 00:21:38,630
只是一个整数
只是作为大小。

485
00:21:38,630 --> 00:21:43,400
>> 所以，如果我现在代表这
形象，让我们假设，这

486
00:21:43,400 --> 00:21:48,070
全黑方块代表我的筹码。

487
00:21:48,070 --> 00:21:50,070
在它的内部有两个变量。

488
00:21:50,070 --> 00:21:54,780
所以我要画
第一个作为大小。

489
00:21:54,780 --> 00:21:57,420
第二个我要去
以画为一个数组。

490
00:21:57,420 --> 00:22:01,060
>> 但只是为了让事情变得有序，
通常我会画一个像数组

491
00:22:01,060 --> 00:22:04,910
这一点，但它是一种很好的
如果我们匹配的现实，或

492
00:22:04,910 --> 00:22:06,230
相匹配的心智模式。

493
00:22:06,230 --> 00:22:12,880
所以，让我来代替数组绘制
垂直，这仅仅是再次，

494
00:22:12,880 --> 00:22:13,840
艺术家的演绎。

495
00:22:13,840 --> 00:22:16,610
并不真正的问题是什么呢
引擎盖下。

496
00:22:16,610 --> 00:22:20,350
我们会说，在默认情况下，
容量将是三个。

497
00:22:20,350 --> 00:22:23,480
因此，这将是位置0，这
将位置1，本

498
00:22:23,480 --> 00:22:25,740
将位置2。

499
00:22:25,740 --> 00:22:29,330
>> 如果我贿赂应力球，
有人想拿出并运行

500
00:22:29,330 --> 00:22:30,870
登上这里只是一瞬间吗？

501
00:22:30,870 --> 00:22:31,960
OK，首先看到你的手。

502
00:22:31,960 --> 00:22:33,950
上来吧。

503
00:22:33,950 --> 00:22:36,500
好的。

504
00:22:36,500 --> 00:22:38,760
所以我相信这是史蒂芬。

505
00:22:38,760 --> 00:22:40,035
上来吧。

506
00:22:40,035 --> 00:22:40,770
好的。

507
00:22:40,770 --> 00:22:46,760
>> 但是，假定现在我们后退到初始
世界的状态，我

508
00:22:46,760 --> 00:22:52,180
刚刚宣布堆栈，它是
将是三能力。

509
00:22:52,180 --> 00:22:54,470
但规模尚未确定。

510
00:22:54,470 --> 00:22:56,100
托盘尚未确定。

511
00:22:56,100 --> 00:22:57,300
因此，一对夫妇的问题先。

512
00:22:57,300 --> 00:23:01,310
让我给你话筒，这样你就可以
更积极参加。

513
00:23:01,310 --> 00:23:05,190
>> 那么，什么是大小里面在这一刻
如果所有我做过的时间

514
00:23:05,190 --> 00:23:09,340
宣布栈
一行代码？

515
00:23:09,340 --> 00:23:10,100
>> 史蒂芬：不多。

516
00:23:10,100 --> 00:23:12,080
>> 国宝MALAN：OK，不多。

517
00:23:12,080 --> 00:23:14,410
大家知不知道里面有什么大小，
我们不知道里面有什么

518
00:23:14,410 --> 00:23:16,330
这个数组在这里？

519
00:23:16,330 --> 00:23:18,630
>> 史蒂芬：随机码，对不对？

520
00:23:18,630 --> 00:23:20,220
只是 - 

521
00:23:20,220 --> 00:23:23,230
>> 国宝马兰：是的，我要
调用它的代码，但随机 - 

522
00:23:23,230 --> 00:23:23,820
>> 史蒂芬：事情。

523
00:23:23,820 --> 00:23:28,290
>> 国宝马兰：就像是随机的事情

524
00:23:28,290 --> 00:23:28,870
>> 史蒂芬：位。

525
00:23:28,870 --> 00:23:29,530
>> 国宝MALAN：位，对不对？

526
00:23:29,530 --> 00:23:31,190
因此，垃圾值，对不对？

527
00:23:31,190 --> 00:23:33,470
因此，0和1的排列。

528
00:23:33,470 --> 00:23:35,920
以前的惯例遗迹
此内存。

529
00:23:35,920 --> 00:23:38,150
我们真的不知道什么值
，所以我们通常吸引他们

530
00:23:38,150 --> 00:23:38,930
问号。

531
00:23:38,930 --> 00:23:41,990
>> 所以，首先我们推测
想在这里做 - 

532
00:23:41,990 --> 00:23:46,630
让我给这个领域里面
有一个名字 - 托盘。

533
00:23:46,630 --> 00:23:49,540
我们应该怎么想必初始化
如果我们想大小

534
00:23:49,540 --> 00:23:51,040
开始使用该协议栈？

535
00:23:51,040 --> 00:23:53,070
>> 史蒂芬：纸盒子3。

536
00:23:53,070 --> 00:23:53,910
>> 国宝马兰：那么，“确定”。

537
00:23:53,910 --> 00:23:56,710
很明显，容量声明
其他地方为三个。

538
00:23:56,710 --> 00:23:58,570
而这正是我用过
分配数组。

539
00:23:58,570 --> 00:24:03,535
大小要参阅多少
盘目前在栈上。

540
00:24:03,535 --> 00:24:03,880
>> 史蒂芬：零。

541
00:24:03,880 --> 00:24:04,460
>> DAVID马兰，因此，它应该是零。

542
00:24:04,460 --> 00:24:07,760
因此，继续前进，并与任何手指，
大小绘制一个零。

543
00:24:07,760 --> 00:24:08,440
好的。

544
00:24:08,440 --> 00:24:10,920
所以，现在，这里面有什么
在这里，我们不知道。

545
00:24:10,920 --> 00:24:12,160
这些真的只是垃圾值。

546
00:24:12,160 --> 00:24:14,800
因此，我们可以得出问号，但
让我们保持板面干净

547
00:24:14,800 --> 00:24:16,300
因为它并不重要
那里有什么。

548
00:24:16,300 --> 00:24:19,130
我们不需要初始化数组
什么，因为如果我们知道，

549
00:24:19,130 --> 00:24:23,100
堆栈的大小是零，好，我们
不应被看什么

550
00:24:23,100 --> 00:24:25,590
反正在这个数组
这个时间点。

551
00:24:25,590 --> 00:24:29,970
>> 所以，现在想我推
数9入堆栈。

552
00:24:29,970 --> 00:24:33,750
我们应该如何更新数据结构
这个黑盒子里面？

553
00:24:33,750 --> 00:24:35,540
什么样的价值观需要改变吗？

554
00:24:35,540 --> 00:24:36,200
>> 史蒂芬： - 

555
00:24:36,200 --> 00:24:37,400
大小？

556
00:24:37,400 --> 00:24:37,650
>> DAVID马兰：OK。

557
00:24:37,650 --> 00:24:38,770
大小应该变成什么样？

558
00:24:38,770 --> 00:24:39,580
>> 史蒂芬：大小将是一个。

559
00:24:39,580 --> 00:24:39,870
>> DAVID马兰：OK。

560
00:24:39,870 --> 00:24:41,110
因此，大小应成为一体。

561
00:24:41,110 --> 00:24:42,540
所以你可以在一对夫妇的方式做到这一点。

562
00:24:42,540 --> 00:24:46,920
让我给你，现在你的
手指是一个橡皮擦。

563
00:24:46,920 --> 00:24:47,260
好的。

564
00:24:47,260 --> 00:24:49,960
那么现在你的手指一刷。

565
00:24:49,960 --> 00:24:50,330
好的。

566
00:24:50,330 --> 00:24:52,820
现在有什么改变，
很明显，在数据结构中？

567
00:24:52,820 --> 00:24:57,060
>> 史蒂芬：我们打算从
底部9。

568
00:24:57,060 --> 00:24:57,760
>> 国宝马兰：9。

569
00:24:57,760 --> 00:24:58,420
好，好。

570
00:24:58,420 --> 00:25:01,550
所以还是什么都无所谓的
一个或两个位置，因为他们是

571
00:25:01,550 --> 00:25:04,520
垃圾值，但我们不应该打扰
因为大小是寻找

572
00:25:04,520 --> 00:25:07,540
告诉我们，只有第一个元素
实际上是合法的。

573
00:25:07,540 --> 00:25:10,400
所以现在我推17到列表中。

574
00:25:10,400 --> 00:25:11,830
这个画面会发生什么事？

575
00:25:11,830 --> 00:25:14,720
>> 史蒂芬：那么大小是要去两个。

576
00:25:14,720 --> 00:25:15,300
>> DAVID马兰：OK。

577
00:25:15,300 --> 00:25:16,070
你橡皮擦 - 

578
00:25:16,070 --> 00:25:16,810
哎呀。

579
00:25:16,810 --> 00:25:18,026
你是一个橡皮擦。

580
00:25:18,026 --> 00:25:18,840
>> 史蒂芬：橡皮擦。

581
00:25:18,840 --> 00:25:19,720
>> DAVID马兰：你刷。

582
00:25:19,720 --> 00:25:20,560
>> 史蒂芬：刷机。

583
00:25:20,560 --> 00:25:20,920
>> DAVID马兰：OK。

584
00:25:20,920 --> 00:25:21,600
还有什么？

585
00:25:21,600 --> 00:25:22,600
>> 史蒂芬：那么，我们 - 

586
00:25:22,600 --> 00:25:22,915
>> 国宝马兰：我们推17。

587
00:25:22,915 --> 00:25:24,760
>> 史蒂芬：我们坚持17之上，所以 - 

588
00:25:24,760 --> 00:25:25,710
>> 国宝马兰：OK，好。

589
00:25:25,710 --> 00:25:27,040
>> 史蒂芬 - 砸下来。

590
00:25:27,040 --> 00:25:27,530
>> 国宝马兰所有权利。

591
00:25:27,530 --> 00:25:27,940
它变得容易。

592
00:25:27,940 --> 00:25:29,300
我不会帮你这个时候。

593
00:25:29,300 --> 00:25:30,510
推22。

594
00:25:30,510 --> 00:25:31,720
>> 史蒂芬：完成。

595
00:25:31,720 --> 00:25:34,870
成为一个橡皮擦。

596
00:25:34,870 --> 00:25:37,340
我成为一刷。

597
00:25:37,340 --> 00:25:39,340
然后我把22。

598
00:25:39,340 --> 00:25:40,100
>> 国宝马兰：22。

599
00:25:40,100 --> 00:25:40,620
优秀的。

600
00:25:40,620 --> 00:25:41,380
所以有更多的时间。

601
00:25:41,380 --> 00:25:44,280
我现在要推
入堆栈26。

602
00:25:44,280 --> 00:25:46,350
>> 史蒂芬：哦。

603
00:25:46,350 --> 00:25:50,278
噢，天哪。

604
00:25:50,278 --> 00:25:52,520
你真的让我猝不及防。

605
00:25:52,520 --> 00:25:53,703
>> 国宝马兰：你也没
看到这一切吗？

606
00:25:53,703 --> 00:25:55,930
>> 史蒂芬：我没有看到这一切。

607
00:25:55,930 --> 00:25:58,756
我们可以重新初始容量？

608
00:25:58,756 --> 00:25:59,790
>> DAVID马兰：这是一个很好的问题。

609
00:25:59,790 --> 00:26:02,360
所以我们自己画
这里的一个角落里。

610
00:26:02,360 --> 00:26:06,740
史蒂芬真的是没有利好出尽
因为我们这个数组分配

611
00:26:06,740 --> 00:26:09,130
静态的，可以这么说，里面
的数据结构。

612
00:26:09,130 --> 00:26:12,170
我们已经基本上硬编码
它是大小为3。

613
00:26:12,170 --> 00:26:14,170
因此，我们不能真的重新分配。

614
00:26:14,170 --> 00:26:20,020
>> 我们可以，如果我们回去，我们
重新定义托盘是一个指针，

615
00:26:20,020 --> 00:26:22,300
然后，我们使用malloc手的内存。

616
00:26:22,300 --> 00:26:25,050
因为如果我们得到了内存
通过malloc堆，

617
00:26:25,050 --> 00:26:26,430
然后释放它。

618
00:26:26,430 --> 00:26:29,630
但在此之前，我们可以释放它
重新分配一个更大的内存块，

619
00:26:29,630 --> 00:26:31,330
更新指针，等等。

620
00:26:31,330 --> 00:26:33,500
但现在，这是真的
最好的，我们能做到。

621
00:26:33,500 --> 00:26:36,360
push和pop大概是
有一些错误的信号。

622
00:26:36,360 --> 00:26:40,270
>> 因此，举例来说，我们实施
推可以返回一个布尔值

623
00:26:40,270 --> 00:26:42,390
以前返回真实的，真实的，真实的。

624
00:26:42,390 --> 00:26:48,390
但第四次，这将有
返回false，例如。

625
00:26:48,390 --> 00:26:48,540
好的。

626
00:26:48,540 --> 00:26:49,540
非常出色。

627
00:26:49,540 --> 00:26:50,060
恭喜。

628
00:26:50,060 --> 00:26:52,160
你赚你的压力，今天的球。

629
00:26:52,160 --> 00:26:53,110
>> [掌声]

630
00:26:53,110 --> 00:26:54,382
>> 史蒂芬：谢谢。

631
00:26:54,382 --> 00:26:55,680
>> DAVID马兰：谢谢你。

632
00:26:55,680 --> 00:26:59,740
OK，所以这似乎是没有太大的
向前迈进了一步，对不对？

633
00:26:59,740 --> 00:27:01,410
我们描述的数据结构。

634
00:27:01,410 --> 00:27:02,320
这是令人信服的，对不对？

635
00:27:02,320 --> 00:27:03,200
操作系统喜欢它。

636
00:27:03,200 --> 00:27:06,360
显然，网络可以利用这个
和其他应用程序依旧。

637
00:27:06,360 --> 00:27:10,870
但是我们是一个愚蠢的限制
备份排序本周二的限制

638
00:27:10,870 --> 00:27:12,880
我们有固定大小的数组。

639
00:27:12,880 --> 00:27:15,010
>> 所以，确实有一对夫妇
方法我们可以解决这个问题。

640
00:27:15,010 --> 00:27:18,750
我们可以动态分配的数组，
不是由硬编码我

641
00:27:18,750 --> 00:27:22,600
在这里完成的，而是重新申报
这一点，只是很清楚，

642
00:27:22,600 --> 00:27:23,830
这样的事情。

643
00:27:23,830 --> 00:27:29,040
诠释*托盘，而不是决定
尚未容量。

644
00:27:29,040 --> 00:27:35,460
但是，当我宣布堆栈别处
在我的代码，然后，我可以调用malloc，

645
00:27:35,460 --> 00:27:38,250
得到一个块的地址
内存和I可以分配

646
00:27:38,250 --> 00:27:39,980
该地址托盘。

647
00:27:39,980 --> 00:27:43,340
>> 然后，因为它只是一大块
的记忆，我可以继续使用方

648
00:27:43,340 --> 00:27:45,450
括号表示法在通常的方式。

649
00:27:45,450 --> 00:27:49,020
这还是因为同样的原因，有此排序
阵列和功能上等同于

650
00:27:49,020 --> 00:27:50,820
的内存块来
从malloc。

651
00:27:50,820 --> 00:27:53,090
我们可以把一个像其他
使用指针运算或

652
00:27:53,090 --> 00:27:54,440
方括号。

653
00:27:54,440 --> 00:27:55,660
所以这是一种方法。

654
00:27:55,660 --> 00:28:00,120
>> 但是，是怎么回事，我们可能会实现这个
相同的数据结构，有可能？

655
00:28:00,120 --> 00:28:00,280
对吗？

656
00:28:00,280 --> 00:28:04,530
我觉得像我们刚刚解决了这个
一个星期前的问题。

657
00:28:04,530 --> 00:28:08,860
这是解决这个问题的
史蒂芬跑进？

658
00:28:08,860 --> 00:28:10,370
所以，链表，对吧。

659
00:28:10,370 --> 00:28:13,410
>> 问题是，如果我们画
自己分配到一个角落里

660
00:28:13,410 --> 00:28:17,580
提前内存太少，我们
然后以某种方式处理，很好，

661
00:28:17,580 --> 00:28:19,880
为什么不干脆避免这种情况
共发出？

662
00:28:19,880 --> 00:28:26,170
为什么不干脆宣布托盘是一个
指针指向一个节点，因此一个链表，

663
00:28:26,170 --> 00:28:30,740
然后简单地分配新的节点
每次史蒂芬需要，以适应

664
00:28:30,740 --> 00:28:32,400
成的数据结构的数目。

665
00:28:32,400 --> 00:28:34,200
>> 所以画面将不得不改变。

666
00:28:34,200 --> 00:28:38,220
它不会是清洁和
简单，只是三个整数的数组。

667
00:28:38,220 --> 00:28:42,970
现在，它的将是一个指针，指向
结构，该结构是要

668
00:28:42,970 --> 00:28:44,830
有一个int和一个next指针。

669
00:28:44,830 --> 00:28:47,670
这将导致通过该指针
另一个这样的结构

670
00:28:47,670 --> 00:28:48,600
另一个这样的结构。

671
00:28:48,600 --> 00:28:50,560
所以图片实际上会
得到一个有些混乱。

672
00:28:50,560 --> 00:28:52,950
我们早就箭头搭售
一切融合在一起。

673
00:28:52,950 --> 00:28:55,280
>> 但是，这是罚款，正确的，因为
我们已经看到了如何做到这一点。

674
00:28:55,280 --> 00:28:58,180
一旦你得到舒适
实施类似一个链接

675
00:28:58,180 --> 00:29:01,450
列表，你就必须做，如果你
选择实现一个哈希表

676
00:29:01,450 --> 00:29:05,120
单独链接的p组6，你可以
使用它作为一个构建块，或

677
00:29:05,120 --> 00:29:08,870
成分，或在Scratch说话，
程序的东西，你说，你

678
00:29:08,870 --> 00:29:12,560
创建了自己的一块拼图
然后，你可以重复使用。

679
00:29:12,560 --> 00:29:17,090
所以权衡，但潜在的解决方案
我们实际上已经看到过。

680
00:29:17,090 --> 00:29:20,560
>> 所以很多时候，你看到每
一年或两年，当苹果发布

681
00:29:20,560 --> 00:29:23,060
一些新的东西，所有的疯狂的人
外面排队的苹果

682
00:29:23,060 --> 00:29:27,050
商店买他们的边际
在硬件升级。

683
00:29:27,050 --> 00:29:30,420
我这样说，这是确定的，因为
我的那些人之一。

684
00:29:30,420 --> 00:29:35,140
那么什么样的数据结构
可能代表这个现实吗？

685
00:29:35,140 --> 00:29:36,980
>> 好吧，我们姑且称之为一个队列，一条线。

686
00:29:36,980 --> 00:29:40,270
因此，英国会调用它通常是
反正排队，所以这是一个好听的名字。

687
00:29:40,270 --> 00:29:44,960
而且，这两个操作，一个队列
应支持，我们会叫排队

688
00:29:44,960 --> 00:29:48,900
操作和出队操作，
这两种相近的

689
00:29:48,900 --> 00:29:50,120
push和pop的精神。

690
00:29:50,120 --> 00:29:54,060
这只是形式的不同
惯例，我们调用这些。

691
00:29:54,060 --> 00:29:57,680
但排队的东西意味着添加
或插入的数据结构。

692
00:29:57,680 --> 00:29:59,570
出列意味着将其删除。

693
00:29:59,570 --> 00:30:05,170
但是，而堆栈是一个后进先出的数据
结构，队列是先入

694
00:30:05,170 --> 00:30:06,740
先出的数据结构。

695
00:30:06,740 --> 00:30:10,050
>> 如果你是行的第一人，
你将是第一人获得

696
00:30:10,050 --> 00:30:12,420
脱节和购买新设备。

697
00:30:12,420 --> 00:30:18,070
试想一下，这些人会如何心烦
如果苹果，而不是用一个堆栈，

698
00:30:18,070 --> 00:30:21,250
比如，实行采摘
组成你的新玩具。

699
00:30:21,250 --> 00:30:24,310
所以队列有意义，当然，
我们能想到的各种

700
00:30:24,310 --> 00:30:27,480
应用程序，想必，队列，
尤其是当你要公平。

701
00:30:27,480 --> 00:30:30,040
那么，我们怎么可能实现这些
作为一个数据结构？

702
00:30:30,040 --> 00:30:33,680
>> 好吧，我建议，我们可能
需要做的是这种方式。

703
00:30:33,680 --> 00:30:35,225
所以我打算到现在已经有数字。

704
00:30:35,225 --> 00:30:38,190
因此，我们将保持它的简单，而不是
不一定谈托盘。

705
00:30:38,190 --> 00:30:40,220
只是数字，人们得到。

706
00:30:40,220 --> 00:30:43,760
容量是怎么回事，再次修复
人的总数，可以在

707
00:30:43,760 --> 00:30:46,900
这条线，三个或
任何其他值。

708
00:30:46,900 --> 00:30:50,760
>> 不过，我建议，我需要跟踪
的大小不仅

709
00:30:50,760 --> 00:30:52,370
队列中，有多少东西都在里面了。

710
00:30:52,370 --> 00:30:56,310
因此，大小是电流大小，容量
是的最大尺寸。

711
00:30:56,310 --> 00:30:58,540
又一次的，命名
按照惯例。

712
00:30:58,540 --> 00:31:03,680
为什么我需要一个额外的int里面
队列来跟踪谁在

713
00:31:03,680 --> 00:31:05,365
前面的行吗？

714
00:31:05,365 --> 00:31:07,930

715
00:31:07,930 --> 00:31:10,910
为什么我需要做的，在这种情况呢？

716
00:31:10,910 --> 00:31:14,750

717
00:31:14,750 --> 00:31:16,190
>> 好了，这是怎么图片
要改变呢？

718
00:31:16,190 --> 00:31:19,280
我也许可以重用
这张图片。

719
00:31:19,280 --> 00:31:21,480
让我继续前进，抹去了这里。

720
00:31:21,480 --> 00:31:24,580
我们会给这个稍微
不同的名字在这里。

721
00:31:24,580 --> 00:31:28,930
让我们摆脱了17，让我们摆脱
9，让我们摆脱了3。

722
00:31:28,930 --> 00:31:30,410
让的添加另一件事。

723
00:31:30,410 --> 00:31:34,710
我提议由我需要跟踪
列表的前面，这仅仅是

724
00:31:34,710 --> 00:31:35,570
将是一个int。

725
00:31:35,570 --> 00:31:36,550
我们要保持它的简单。

726
00:31:36,550 --> 00:31:37,740
现在没有链表。

727
00:31:37,740 --> 00:31:40,900
>> 我们得承认，我们要
颠簸起来反对这个限制。

728
00:31:40,900 --> 00:31:43,720
但什么我想看看
发生这个时间呢？

729
00:31:43,720 --> 00:31:47,240
因此，假设我继续前进，第一
人来了线，

730
00:31:47,240 --> 00:31:48,560
它是9号。

731
00:31:48,560 --> 00:31:49,680
我们确实有压力球。

732
00:31:49,680 --> 00:31:51,330
我可以说，偷两三人？

733
00:31:51,330 --> 00:31:52,690
一，二，三？

734
00:31:52,690 --> 00:31:53,120
上来吧。

735
00:31:53,120 --> 00:31:56,022
从正面看，由于
我们会让这个快。

736
00:31:56,022 --> 00:31:59,415
>> 现在你们每个人将要
线苹果的风扇男孩。

737
00:31:59,415 --> 00:32:03,970

738
00:32:03,970 --> 00:32:06,210
你会不会接受苹果的硬件
这虽然结束。

739
00:32:06,210 --> 00:32:06,500
好的。

740
00:32:06,500 --> 00:32:09,430
所以，你是9号，你
17号，22号。

741
00:32:09,430 --> 00:32:12,130
这些都是任意数字，如
学生ID或诸如此类的东西。

742
00:32:12,130 --> 00:32:14,550
在短短的时刻，让我们开始
开始添加的东西。

743
00:32:14,550 --> 00:32:16,000
我要跑董事会这次在这里。

744
00:32:16,000 --> 00:32:19,570
>> 因此，在这种情况下，我已经初始化
前面是 - 

745
00:32:19,570 --> 00:32:22,380
其实，我真的不关心什么
前面，因为大小为零。

746
00:32:22,380 --> 00:32:24,480
因此，这可能也只是
是一个问号。

747
00:32:24,480 --> 00:32:26,170
这些都是问号。

748
00:32:26,170 --> 00:32:29,880
所以，现在我们将开始看到一些
排队的人在店里。

749
00:32:29,880 --> 00:32:33,320
>> 9号，所以如果你是第一个
凌晨5点，提前去排队，

750
00:32:33,320 --> 00:32:34,210
或前一天晚上。

751
00:32:34,210 --> 00:32:34,580
确定。

752
00:32:34,580 --> 00:32:35,940
所以，现在9号是在这里。

753
00:32:35,940 --> 00:32:37,940
因此，图9是列表的前面。

754
00:32:37,940 --> 00:32:41,440
所以我要继续前进，并更新
这个电流的大小的数据

755
00:32:41,440 --> 00:32:44,740
结构不能为0了，
但为1。

756
00:32:44,740 --> 00:32:47,630
我打算把9日
列表的前面。

757
00:32:47,630 --> 00:32:51,020
让我继续前进，切换屏幕
所以我们可以看到过去我们在这里。

758
00:32:51,020 --> 00:32:53,220
>> 现在，我想要什么
放在前面？

759
00:32:53,220 --> 00:32:56,240
我要跟踪
现在前面的队列

760
00:32:56,240 --> 00:32:58,570
是在位置0。

761
00:32:58,570 --> 00:33:00,510
因为接下来会发生什么呢？

762
00:33:00,510 --> 00:33:03,000
好吧，我想现在排队
17。

763
00:33:03,000 --> 00:33:04,510
因此第一跳有线。

764
00:33:04,510 --> 00:33:07,060
再次，那种门
店会到这里来。

765
00:33:07,060 --> 00:33:08,700
所以，现在我已经增加了17。

766
00:33:08,700 --> 00:33:10,810
即使这些家伙堵
在屏幕上，这是确定的，

767
00:33:10,810 --> 00:33:12,300
因为我们可以看到它在这里。

768
00:33:12,300 --> 00:33:12,910
抱歉。

769
00:33:12,910 --> 00:33:13,810
>> 观众：我们可以移动 - 

770
00:33:13,810 --> 00:33:14,660
>> 国宝马兰：没有，这是确定的。

771
00:33:14,660 --> 00:33:16,000
在那里，这是巨大的。

772
00:33:16,000 --> 00:33:18,580
因此，图17是内部的队列。

773
00:33:18,580 --> 00:33:21,332
我需要更新哪些
现在虽然领域呢？

774
00:33:21,332 --> 00:33:23,210
OK，绝对大小。

775
00:33:23,210 --> 00:33:26,430
关于前呢？

776
00:33:26,430 --> 00:33:27,040
OK，没。

777
00:33:27,040 --> 00:33:30,200
前不应该改变，因为
不同的堆栈，我们

778
00:33:30,200 --> 00:33:31,370
要维护公平。

779
00:33:31,370 --> 00:33:35,150
因此，如果9排在第一，我们希望9
成为第一个出列

780
00:33:35,150 --> 00:33:36,420
进店。

781
00:33:36,420 --> 00:33:37,220
>> 事实上，让我们看到。

782
00:33:37,220 --> 00:33:42,235
之前，我们插入22，让我们
继续前进，出队9。

783
00:33:42,235 --> 00:33:42,970
你叫什么名字呢？

784
00:33:42,970 --> 00:33:43,680
>> 观众：杰克。

785
00:33:43,680 --> 00:33:45,440
>> 国宝马兰：杰克是怎么回事
现在被出列。

786
00:33:45,440 --> 00:33:48,050
所以你走进商店。

787
00:33:48,050 --> 00:33:49,880
并假装商店
在那边。

788
00:33:49,880 --> 00:33:51,970
所以，现在需要什么 - 二叔DIT-dit的！

789
00:33:51,970 --> 00:33:53,400
什么需要现在发生？

790
00:33:53,400 --> 00:33:54,490
设计决定。

791
00:33:54,490 --> 00:33:56,825
所以不是一个坏的本能，但 - 
你叫什么名字呢？

792
00:33:56,825 --> 00:33:57,090
>> 观众：大卫。

793
00:33:57,090 --> 00:33:57,500
>> 大卫DAVID马兰。

794
00:33:57,500 --> 00:33:58,810
所以，大卫做了什么？

795
00:33:58,810 --> 00:34:02,590
他试图修复数据排序
从他的位置的结构和移动

796
00:34:02,590 --> 00:34:04,100
进入Jake的前位置。

797
00:34:04,100 --> 00:34:06,740
这很好，如果我们愿意
接受，作为一个

798
00:34:06,740 --> 00:34:08,199
实施细节。

799
00:34:08,199 --> 00:34:11,100
但首先，让我们来更新数据
结构之前，我们做到这一点。

800
00:34:11,100 --> 00:34:14,139
因为我不喜欢的想法
人在这条线转移。

801
00:34:14,139 --> 00:34:17,360
>> 这没什么大不了的，如果大卫它
一步到位，但再次，想回

802
00:34:17,360 --> 00:34:20,360
当我们已经有8名志愿者在
阶段，我们所做的一样插入

803
00:34:20,360 --> 00:34:22,600
排序，我们不得不开始
感动身边的每一个人。

804
00:34:22,600 --> 00:34:23,790
这引起了昂贵的，对不对？

805
00:34:23,790 --> 00:34:28,330
这让我畏缩关于大O
大O N，n的平方了。

806
00:34:28,330 --> 00:34:30,650
这不是感觉像
一个理想的结果。

807
00:34:30,650 --> 00:34:32,080
>> 因此，让我们刚刚更新。

808
00:34:32,080 --> 00:34:35,120
因此，该队列的大小
不再是2。

809
00:34:35,120 --> 00:34:37,090
现在只需1。

810
00:34:37,090 --> 00:34:40,360
但是我现在可以更新的东西
我没有更新之前，

811
00:34:40,360 --> 00:34:41,130
列表的前面。

812
00:34:41,130 --> 00:34:45,420
我可以这样说，是位置1？

813
00:34:45,420 --> 00:34:49,770
所以，现在我们这里的垃圾值，
垃圾价值在这里，大卫在

814
00:34:49,770 --> 00:34:51,469
这个垃圾中间。

815
00:34:51,469 --> 00:34:54,980
但是，该数据结构
仍是完好的。

816
00:34:54,980 --> 00:34:58,540
>> 事实上，我不甚至需要
改变Jake的前数

817
00:34:58,540 --> 00:35:00,460
9，因为谁在乎。

818
00:35:00,460 --> 00:35:04,470
我有足够的信息，现在在
大小，我知道有一个人在

819
00:35:04,470 --> 00:35:05,030
此队列。

820
00:35:05,030 --> 00:35:08,340
我知道那个人
在位置1，而不是0。

821
00:35:08,340 --> 00:35:09,760
我不计数。

822
00:35:09,760 --> 00:35:11,300
所以1。

823
00:35:11,300 --> 00:35:13,410
因此，数据结构还OK。

824
00:35:13,410 --> 00:35:14,330
>> 那么，接下来会发生什么呢？

825
00:35:14,330 --> 00:35:15,010
让我们排队 - 

826
00:35:15,010 --> 00:35:15,370
你叫什么名字？

827
00:35:15,370 --> 00:35:16,160
>> 观众：Callen先生。

828
00:35:16,160 --> 00:35:16,580
>> 国宝马兰：Callen先生。

829
00:35:16,580 --> 00:35:20,770
让我们排队Callen先生，
图22是在队列中。

830
00:35:20,770 --> 00:35:22,300
所以，现在这里有什么改变吗？

831
00:35:22,300 --> 00:35:24,380
前不会
改变，很明显。

832
00:35:24,380 --> 00:35:27,160
尺寸要改变再次2。

833
00:35:27,160 --> 00:35:31,590
和22结束在这里，图9是仍然存在，
但它实际上是一个

834
00:35:31,590 --> 00:35:32,600
现在垃圾值。

835
00:35:32,600 --> 00:35:35,910
这只是杰克过去的残余。

836
00:35:35,910 --> 00:35:39,200
>> 所以，现在发生什么，如果
我队列中取出大卫？

837
00:35:39,200 --> 00:35:41,560
最后一个操作，出队的大卫。

838
00:35:41,560 --> 00:35:46,070
我们可能会改变，但我提议，让我们
做尽可能小的工作。

839
00:35:46,070 --> 00:35:50,280
现在我的数据结构去
备份的大小从2到1。

840
00:35:50,280 --> 00:35:53,730
但是，队列前面的
现在变成2。

841
00:35:53,730 --> 00:35:56,640
我不需要改变这些数字
只是还没有，因为他们是

842
00:35:56,640 --> 00:35:58,230
只是垃圾值。

843
00:35:58,230 --> 00:35:59,720
>> 但现在发生了什么？

844
00:35:59,720 --> 00:36:03,280
假设我自己排队，26？

845
00:36:03,280 --> 00:36:05,890
我觉得我属于这里。

846
00:36:05,890 --> 00:36:06,890
所以，我正在排队。

847
00:36:06,890 --> 00:36:08,760
所以我属于这里。

848
00:36:08,760 --> 00:36:11,300
而且，即使你做的不是很
欣赏这视觉在舞台上，

849
00:36:11,300 --> 00:36:15,075
因为我们有足够的空间，我应该
不会站在这里，为什么呢？

850
00:36:15,075 --> 00:36:16,290
>> 观众：你出界。

851
00:36:16,290 --> 00:36:16,370
>> 国宝马兰：右。

852
00:36:16,370 --> 00:36:16,940
我是出界。

853
00:36:16,940 --> 00:36:19,330
我已经超越索引的
此阵列的界限。

854
00:36:19,330 --> 00:36:23,420
我真的应该于一体的
三个可能的位置。

855
00:36:23,420 --> 00:36:25,150
现在，在最自然的去吗？

856
00:36:25,150 --> 00:36:27,760
我建议，我们的杠杆
每周一招。

857
00:36:27,760 --> 00:36:30,150
mod运算符，百分比。

858
00:36:30,150 --> 00:36:36,850
因为我在技术上站在
位置3，但我做的3模能力，

859
00:36:36,850 --> 00:36:40,250
SO 3，百分号，3  - 

860
00:36:40,250 --> 00:36:40,970
容量3。

861
00:36:40,970 --> 00:36:41,720
那是什么？

862
00:36:41,720 --> 00:36:43,700
什么是余
3除以3？

863
00:36:43,700 --> 00:36:44,070
0。

864
00:36:44,070 --> 00:36:48,140
>> 所以，把我杰克是，
这实际上是不错的。

865
00:36:48,140 --> 00:36:50,370
所以，现在的实施
这个东西要

866
00:36:50,370 --> 00:36:51,250
是有点头疼。

867
00:36:51,250 --> 00:36:53,740
这真的只是一条线
头痛，代码。

868
00:36:53,740 --> 00:36:56,580
但至少现在有垃圾
这里的价值，但有两个

869
00:36:56,580 --> 00:36:57,910
这里正当整数。

870
00:36:57,910 --> 00:37:04,160
我要求，现在我们已经做了
这正是我们需要做的，只要

871
00:37:04,160 --> 00:37:08,600
我们改变了杰克的
的值是26。

872
00:37:08,600 --> 00:37:12,110
>> 我们现在有足够的信息仍然
保持完整

873
00:37:12,110 --> 00:37:13,060
这样的数据结构。

874
00:37:13,060 --> 00:37:17,160
我们依然是那样的运气，当我们
要插入四个或更多的总

875
00:37:17,160 --> 00:37:20,740
元素，但我至少可以做出漂亮
有效地利用这个常数

876
00:37:20,740 --> 00:37:21,740
时间，其实。

877
00:37:21,740 --> 00:37:27,150
我不必担心转移
大家作为大卫的倾向是。

878
00:37:27,150 --> 00:37:30,816
>> 堆栈上的任何问题，
此队列？

879
00:37:30,816 --> 00:37:32,184
>> 观众：是的原因
你需要的大小，以便你知道

880
00:37:32,184 --> 00:37:34,010
在那里有一个人？

881
00:37:34,010 --> 00:37:34,770
>> DAVID马兰：没错。

882
00:37:34,770 --> 00:37:38,230
我需要知道数组的大小
因为我需要确切地知道如何

883
00:37:38,230 --> 00:37:41,940
许多这些值都是合法的，
所以，我可以找到放在哪里

884
00:37:41,940 --> 00:37:42,800
旁边的人。

885
00:37:42,800 --> 00:37:43,300
没错。

886
00:37:43,300 --> 00:37:44,580
大小是 - 

887
00:37:44,580 --> 00:37:46,360
其实，我们并没有更新。

888
00:37:46,360 --> 00:37:48,380
我自己在26加入。

889
00:37:48,380 --> 00:37:51,760
大小，而不是1，而是2。

890
00:37:51,760 --> 00:37:57,780
所以，现在这的确有助于我找到
列表头，这是不为0，不

891
00:37:57,780 --> 00:37:59,250
1，但为2。

892
00:37:59,250 --> 00:38:01,665
列表的前面
确实是22号。

893
00:38:01,665 --> 00:38:05,120
因为他排在第一，所以他应该
被允许进入商店我面前，

894
00:38:05,120 --> 00:38:08,780
尽管在视觉上，我站在
靠近商店。

895
00:38:08,780 --> 00:38:09,220
>> 没事吧？

896
00:38:09,220 --> 00:38:12,410
这些家伙的掌声鼓励
我们会让他们离开那里。

897
00:38:12,410 --> 00:38:17,090
>> [掌声]

898
00:38:17,090 --> 00:38:18,150
>> 国宝马兰：我可以让
你守托盘。

899
00:38:18,150 --> 00:38:20,760
我们可以看到发生什么，如果
你想要的，但也许不会。

900
00:38:20,760 --> 00:38:21,590
好的。

901
00:38:21,590 --> 00:38:25,380
所以，现在没有什么离开我们？

902
00:38:25,380 --> 00:38:28,900
好吧，让我建议，有一个
其他一些数据结构，我们可以

903
00:38:28,900 --> 00:38:33,810
开始加入到我们的工具包，将
实际上是非常非常相关，因为

904
00:38:33,810 --> 00:38:35,270
我们潜入网络的东西。

905
00:38:35,270 --> 00:38:38,150
这再次有某种联系
树的形式

906
00:38:38,150 --> 00:38:40,550
一种叫DOM，文件
对象模型。

907
00:38:40,550 --> 00:38:42,370
但是，我们会看到更多的
用不了多久。

908
00:38:42,370 --> 00:38:46,260
>> 让我提出的确定性
现在你可能知道什么叫树

909
00:38:46,260 --> 00:38:48,820
更多的家庭树，在那里你
在有一些祖先

910
00:38:48,820 --> 00:38:49,790
树根。

911
00:38:49,790 --> 00:38:54,480
重男轻女或女家长
树的最顶端。

912
00:38:54,480 --> 00:38:56,700
没有他们的配偶，在这种情况下。

913
00:38:56,700 --> 00:39:00,940
但是，现在我们有什么，我们会打电话给
孩子，这是挂的节点

914
00:39:00,940 --> 00:39:05,480
关闭左子或右的孩子，
这里所描述的箭头。

915
00:39:05,480 --> 00:39:10,490
>> 换句话说，在树的数据结构
电脑，一棵树零

916
00:39:10,490 --> 00:39:11,480
或多个节点。

917
00:39:11,480 --> 00:39:13,500
如果它有至少一个节点，
这就是所谓的根。

918
00:39:13,500 --> 00:39:15,700
这是视觉上的东西
我们在上面画。

919
00:39:15,700 --> 00:39:20,280
该节点，像任何其他节点，
具有零个，一个或两个，或三个，

920
00:39:20,280 --> 00:39:23,600
然而，许多孩子
数据结构支持。

921
00:39:23,600 --> 00:39:29,150
在这种情况下，根存储
值，有两个孩子，2和3，

922
00:39:29,150 --> 00:39:33,020
所以我们一般称之为左
儿童和3的右孩子。

923
00:39:33,020 --> 00:39:36,940
>> 然后当我们得到下降到5，6，
7，6可能被称为中间的孩子。

924
00:39:36,940 --> 00:39:38,940
如果你有四个孩子，
它变得扑朔迷离。

925
00:39:38,940 --> 00:39:42,260
因此，我们停止使用那种
口头上的快捷方式。

926
00:39:42,260 --> 00:39:44,580
但它确实只是一个家族树。

927
00:39:44,580 --> 00:39:48,880
和这里的叶子的节点
自己有没有孩子。

928
00:39:48,880 --> 00:39:52,540
他们挂在树的底部。

929
00:39:52,540 --> 00:39:56,940
>> 那么，我们怎么可能实现的树
具有最大限度仅有的两个孩子吗？

930
00:39:56,940 --> 00:39:58,410
我们会打电话给它一个二叉树。

931
00:39:58,410 --> 00:40:00,960
毕再次意思是两个，在该
的情况下，像二进制。

932
00:40:00,960 --> 00:40:04,830
因此，它可以具有零个，一个
两个孩子最大限度。

933
00:40:04,830 --> 00:40:08,650
>> 我会建议我们实行节点
该结构与一个整数n，

934
00:40:08,650 --> 00:40:11,910
然后两个三分球，一个叫
离开后，一个叫权。

935
00:40:11,910 --> 00:40:14,830
但这些都是刚刚好
任意约定。

936
00:40:14,830 --> 00:40:18,170
，什么是现在不错的，特别是如果你
样的挣扎概念

937
00:40:18,170 --> 00:40:21,300
递归，或认为这是不
一个真正的解决方案，任何东西，

938
00:40:21,300 --> 00:40:23,120
特别是如果你能
耗尽内存。

939
00:40:23,120 --> 00:40:26,600
现在，我们正在谈论数据
结构和算法，使

940
00:40:26,600 --> 00:40:31,030
我们遍历和操作，
事实证明，递归回来

941
00:40:31,030 --> 00:40:34,240
一个更引人注目
如果没有美丽的方式。

942
00:40:34,240 --> 00:40:38,670
>> 所以我的建议是实施
搜索功能。

943
00:40:38,670 --> 00:40:39,870
鉴于两个输入 - 

944
00:40:39,870 --> 00:40:41,570
所以认为这是一个黑盒子。

945
00:40:41,570 --> 00:40:46,560
鉴于两个输入，正和一个int
一棵树的指针，一个指向一个

946
00:40:46,560 --> 00:40:50,020
节点，还是真的一棵树的根，我
声称，该函数可以返回

947
00:40:50,020 --> 00:40:53,530
真的还是假的，值n
是这种树内。

948
00:40:53,530 --> 00:40:55,210
>> 这个黑盒子里面有什么？

949
00:40:55,210 --> 00:40:57,440
那么，四分支。

950
00:40:57,440 --> 00:40:58,385
起初只是检查。

951
00:40:58,385 --> 00:41:00,490
如果树是空的，只是返回false。

952
00:41:00,490 --> 00:41:04,580
如果没有节点，有没有N，
有没有多少，只是返回false。

953
00:41:04,580 --> 00:41:12,330
如果你正在寻找的价值，N，虽然
，不到树箭头N，

954
00:41:12,330 --> 00:41:15,180
只是要清楚，这是什么意思时，
我写的树，然后箭头

955
00:41:15,180 --> 00:41:18,150
符号，N？

956
00:41:18,150 --> 00:41:18,690
没错。

957
00:41:18,690 --> 00:41:21,970
这意味着取消引用
指针称为树。

958
00:41:21,970 --> 00:41:26,750
去那里，然后拿到里面的
节点并获取其字段名为N。

959
00:41:26,750 --> 00:41:30,810
然后比较实际n表示
通过搜索反对。

960
00:41:30,810 --> 00:41:35,390
>> 因此，如果n是小于n的值
在树节点本身，好了，

961
00:41:35,390 --> 00:41:36,720
这是什么意思？

962
00:41:36,720 --> 00:41:40,690
这乍一看没什么意思。

963
00:41:40,690 --> 00:41:40,900
对吗？

964
00:41:40,900 --> 00:41:45,560
就像当你有一个数组
值，你可能喜欢的应用二进制

965
00:41:45,560 --> 00:41:48,290
作为一种形式的分搜索
而治之。

966
00:41:48,290 --> 00:41:51,790
但假设没有什么我们需要做
二进制搜索在所有的工作

967
00:41:51,790 --> 00:41:54,510
在电话簿和
前面的例子吗？

968
00:41:54,510 --> 00:41:55,530
>> 如何进行排序。

969
00:41:55,530 --> 00:41:59,490
因此，让我们细化的定义树
这里不只是一棵树，它可以

970
00:41:59,490 --> 00:42:00,880
有任意数量的儿童。

971
00:42:00,880 --> 00:42:04,700
不只是一个二叉树，它可以
最大限度有0，1，或2。

972
00:42:04,700 --> 00:42:09,700
但是，作为一个二叉搜索树，或BST，
这仅仅是一个奇特的方式说一个

973
00:42:09,700 --> 00:42:15,430
二叉树每个节点的
左子节点，如果存在，是

974
00:42:15,430 --> 00:42:16,830
小于该节点。

975
00:42:16,830 --> 00:42:20,170
而每一个节点的右子，
如果存在，是更大的

976
00:42:20,170 --> 00:42:21,740
比该节点本身。

977
00:42:21,740 --> 00:42:25,200
>> 所以，换句话说，如果你是画
树出来，所有的数字都

978
00:42:25,200 --> 00:42:30,620
这样精心平衡，这样，如果
你有55根，33可以去

979
00:42:30,620 --> 00:42:33,090
在它的左边，因为它是小于55。

980
00:42:33,090 --> 00:42:36,430
77可以去其正确的，因为
它是大于55。

981
00:42:36,430 --> 00:42:40,750
但是现在注意到，相同的定义，
这是一个递归定义口头，

982
00:42:40,750 --> 00:42:42,600
已申请33。

983
00:42:42,600 --> 00:42:47,610
33的左子必须比它少，
和33的右子，44岁，必须

984
00:42:47,610 --> 00:42:48,580
大于它。

985
00:42:48,580 --> 00:42:51,670
>> 所以这是一个二叉搜索树，
我建议，使用一点点

986
00:42:51,670 --> 00:42:53,910
递归，我们现在能够找到N。

987
00:42:53,910 --> 00:42:59,160
因此，如果n是小于值n的
当前节点，我要去

988
00:42:59,160 --> 00:43:04,090
进取，撑船，所以说话，只是
返回任何回答是的

989
00:43:04,090 --> 00:43:08,470
为n
树的左子。

990
00:43:08,470 --> 00:43:11,370
再次注意，这个函数只是
预计节点明星，

991
00:43:11,370 --> 00:43:12,780
到一个节点的指针。

992
00:43:12,780 --> 00:43:17,360
所以，我一定可以做树
左箭头，这将导致

993
00:43:17,360 --> 00:43:18,400
去到另一个节点。

994
00:43:18,400 --> 00:43:19,480
但是，该节点是什么？

995
00:43:19,480 --> 00:43:22,820
>> 那么，根据这个声明，
剩下的只是一个指针，所以，仅仅

996
00:43:22,820 --> 00:43:27,090
意味着我通过搜索功能
不同的指针，即

997
00:43:27,090 --> 00:43:30,750
就是代表
我的左子树。

998
00:43:30,750 --> 00:43:36,040
因此，在这种情况下，指针33，如果
同时，如果是我们的样本输入

999
00:43:36,040 --> 00:43:40,740
n是大于上面的n值
当前树中的节点，那么我

1000
00:43:40,740 --> 00:43:43,370
要继续前进，平底船在其他
方向，只是说，我不

1001
00:43:43,370 --> 00:43:47,280
知道此值n是树中，
但我知道，如果它是，它是我的

1002
00:43:47,280 --> 00:43:49,090
右分支，可以这么说。

1003
00:43:49,090 --> 00:43:53,120
因此，让我叫递归搜索，
再通过一个n，但在传递

1004
00:43:53,120 --> 00:43:54,580
我的右孩子指针。

1005
00:43:54,580 --> 00:44:00,020
>> 换句话说，如果我目前在55
，我知道我在寻找99 99

1006
00:44:00,020 --> 00:44:04,270
大于55，所以就像我撕毁
电话簿星期前，我们

1007
00:44:04,270 --> 00:44:07,140
去正确的，同样是我们
要去这里。

1008
00:44:07,140 --> 00:44:11,960
我不知道，如果它是在我的右
孩子，它不是，77是有，但

1009
00:44:11,960 --> 00:44:13,210
我知道这是在那个方向。

1010
00:44:13,210 --> 00:44:18,770
因此，我呼吁搜索在我的右孩子，
77，让搜索身影从

1011
00:44:18,770 --> 00:44:24,950
如果99本任意
例如实际上是存在的。

1012
00:44:24,950 --> 00:44:26,900
>> 否则，什么是最终的情况？

1013
00:44:26,900 --> 00:44:28,620
如果树是空是一个案例。

1014
00:44:28,620 --> 00:44:31,890
如果n小于当前节点的
值是另一种情况。

1015
00:44:31,890 --> 00:44:35,120
如果n为大于当前
节点的值是第三种情况。

1016
00:44:35,120 --> 00:44:38,250
第四和最后的情况是什么？

1017
00:44:38,250 --> 00:44:39,480
我认为我们的情况下，对不对？

1018
00:44:39,480 --> 00:44:44,690
它必须是n在
当前节点我。

1019
00:44:44,690 --> 00:44:49,640
>> 所以，如果我在寻找55在这一点上
在故事中，那支

1020
00:44:49,640 --> 00:44:51,780
树将返回true。

1021
00:44:51,780 --> 00:44:55,380
那么，什么有趣的是，我们
实际上，不像周过去，我们种

1022
00:44:55,380 --> 00:44:56,740
有两个基例。

1023
00:44:56,740 --> 00:44:58,300
，他们不必
所有在顶部。

1024
00:44:58,300 --> 00:45:01,390
顶部是一个基本情况，因为如果
树是空的，有没有什么关系。

1025
00:45:01,390 --> 00:45:03,410
只是返回一个硬编码
值false。

1026
00:45:03,410 --> 00:45:07,400
>> 底部分支排序
默认情况下，如果我们检查

1027
00:45:07,400 --> 00:45:11,550
空，我们已经检查了，如果它应该是
离开了，但是它不应该是，我们已经

1028
00:45:11,550 --> 00:45:14,640
检查，如果它应该是正确的，但它
不应该的，清楚地，它必须是

1029
00:45:14,640 --> 00:45:15,870
右边我们在哪里。

1030
00:45:15,870 --> 00:45:16,780
这是一个基本情况。

1031
00:45:16,780 --> 00:45:19,920
因此，有两个递归例
夹在中间。

1032
00:45:19,920 --> 00:45:21,630
但我可以写
这在任何顺序。

1033
00:45:21,630 --> 00:45:24,520
我只是认为这样的感觉自然
首先检查可能的错误，

1034
00:45:24,520 --> 00:45:28,340
然后检查左，右检查，然后
假设你是在节点

1035
00:45:28,340 --> 00:45:30,630
你实际上是在寻找。

1036
00:45:30,630 --> 00:45:36,240
>> 那么，为什么会这样有用吗？

1037
00:45:36,240 --> 00:45:37,910
因此，原来 - 

1038
00:45:37,910 --> 00:45:42,110
让我跳一个传情
在这里，在网上。

1039
00:45:42,110 --> 00:45:44,920
我们将开始使用不是一个
在第一编程语言，但

1040
00:45:44,920 --> 00:45:46,030
标记语言。

1041
00:45:46,030 --> 00:45:48,740
一种标记语言，是一个
类似的精神编程

1042
00:45:48,740 --> 00:45:51,715
语言，但它不会给你的
能够表达自己的逻辑。

1043
00:45:51,715 --> 00:45:55,070
它只是给你的能力，
表达自己的结构。

1044
00:45:55,070 --> 00:45:57,960
>> 你想放的东西在哪里
在页面上，网页？

1045
00:45:57,960 --> 00:45:59,200
你想让它是什么颜色的？

1046
00:45:59,200 --> 00:46:00,950
你想让它什么字体大小？

1047
00:46:00,950 --> 00:46:02,970
什么话你实际上
想在网页上吗？

1048
00:46:02,970 --> 00:46:04,060
所以这是一种标记语言。

1049
00:46:04,060 --> 00:46:07,690
但然后我们会很迅速推出
JavaScript中，这是一个完全成熟的

1050
00:46:07,690 --> 00:46:08,560
编程语言。

1051
00:46:08,560 --> 00:46:12,530
在语法上非常相似的外观
C，但还会有一些

1052
00:46:12,530 --> 00:46:15,200
不错，功能更强大，更
用户友好的功能。

1053
00:46:15,200 --> 00:46:18,050
>> 和挫折
在本学期，我们会点

1054
00:46:18,050 --> 00:46:22,065
即将实施的拼写少得多
使用其他语言的代码行

1055
00:46:22,065 --> 00:46:25,580
比C本身允许的，但对于原因
我们很快就会明白。

1056
00:46:25,580 --> 00:46:27,750
这将是第一个这样的网页。

1057
00:46:27,750 --> 00:46:30,120
这将是完全给人留下深刻印象，
我们的第一个。

1058
00:46:30,120 --> 00:46:31,400
简单地说，你好世界。

1059
00:46:31,400 --> 00:46:34,010
但是，如果你从来没有见过它
之前，这是HTML，

1060
00:46:34,010 --> 00:46:35,670
超文本标记语言。

1061
00:46:35,670 --> 00:46:39,310
>> 如果你去某些菜单选项
任何浏览器，在任何网页上

1062
00:46:39,310 --> 00:46:43,160
在互联网上，你可以看到的HTML
一些人写信给

1063
00:46:43,160 --> 00:46:44,400
创建该网页。

1064
00:46:44,400 --> 00:46:47,850
它可能看起来并不
短暂或整齐。

1065
00:46:47,850 --> 00:46:51,400
但它会按照这些模式
开放式支架和斜线

1066
00:46:51,400 --> 00:46:53,660
字母和潜在的数字。

1067
00:46:53,660 --> 00:46:56,770
>> 我想我给你传情
你就可以做什么

1068
00:46:56,770 --> 00:46:57,950
后服用CS50。

1069
00:46:57,950 --> 00:47:02,620
让我去到cs.harvard.edu /抢劫，
我们自己的罗布·鲍登的主页。

1070
00:47:02,620 --> 00:47:06,080
他给我们看。

1071
00:47:06,080 --> 00:47:07,490
所以你很快就能够做到这一点。

1072
00:47:07,490 --> 00:47:10,660
此外，你听到什么
今天上午 - 

1073
00:47:10,660 --> 00:47:12,480
你今早 - 

1074
00:47:12,480 --> 00:47:13,780
>> [仓鼠跳舞音乐]

1075
00:47:13,780 --> 00:47:15,702
>>  - 你将能作出这种。

1076
00:47:15,702 --> 00:47:16,790
等待着我们在周三。

1077
00:47:16,790 --> 00:47:17,791
然后我们会看到你。

1078
00:47:17,791 --> 00:47:22,950
>> [仓鼠跳舞音乐]

1079
00:47:22,950 --> 00:47:24,300
国宝马兰：在未来CS50  - 

1080
00:47:24,300 --> 00:47:31,670