1
00:00:00,000 --> 00:00:11,904
>> [音乐播放]

2
00:00:11,904 --> 00:00:12,910
>> 教授：好的。

3
00:00:12,910 --> 00:00:16,730
这是CS50，这是
三星期结束。

4
00:00:16,730 --> 00:00:20,230
所以，我们今天在这里，而不是在桑德斯
剧场，而是在韦德纳图书馆。

5
00:00:20,230 --> 00:00:23,170
其内部是一个工作室
被称为豪瑟工作室，

6
00:00:23,170 --> 00:00:28,310
或者我们应该说工作室H，或应
我们say--如果你喜欢这个笑话，

7
00:00:28,310 --> 00:00:30,540
它实际上是从
同学，马克，网上，

8
00:00:30,540 --> 00:00:32,420
谁通过Twitter提出之多。

9
00:00:32,420 --> 00:00:34,270
现在，有什么很酷
是在工作室在这里

10
00:00:34,270 --> 00:00:38,410
是，我被这些绿色包围
墙，绿屏或色度，

11
00:00:38,410 --> 00:00:43,290
可以这么说，这意味着，CS50的
制作团队，我并不知道

12
00:00:43,290 --> 00:00:47,380
现在，可以把
我最在世界任何地方，

13
00:00:47,380 --> 00:00:48,660
是好还是坏。

14
00:00:48,660 --> 00:00:51,800
>> 现在是什么样的未来，问题集
二是在你的手中本周，

15
00:00:51,800 --> 00:00:53,830
但问题集
三此接下来的一周，

16
00:00:53,830 --> 00:00:56,600
你将受到挑战
所谓游戏的15

17
00:00:56,600 --> 00:00:58,960
一个老党员赞成票
你可能还记得接受

18
00:00:58,960 --> 00:01:02,030
作为一个孩子，有一大堆
可滑动的上，下的数字，

19
00:01:02,030 --> 00:01:05,790
左，右，以及有一个缺口
在拼图，您在其中

20
00:01:05,790 --> 00:01:07,840
实际上可以滑动的拼图。

21
00:01:07,840 --> 00:01:11,150
最终你收到此
拼图一些半随机的顺序，

22
00:01:11,150 --> 00:01:12,940
和目标是
顶级排序，到下，

23
00:01:12,940 --> 00:01:16,310
从左到右，从一个
一路攀升至15。

24
00:01:16,310 --> 00:01:19,360
>> 不幸的是，实施
你手边

25
00:01:19,360 --> 00:01:21,590
将是软件
根据，不是身体。

26
00:01:21,590 --> 00:01:25,280
你实际上将不得不写
代码与学生或用户可以

27
00:01:25,280 --> 00:01:26,760
打15场比赛。

28
00:01:26,760 --> 00:01:29,030
而事实上，在黑客
游戏的15版，

29
00:01:29,030 --> 00:01:32,155
你会是一个挑战来实现，
这种老派的不只是播放

30
00:01:32,155 --> 00:01:35,010
游戏，而是求解
这一点，实现上帝模式，

31
00:01:35,010 --> 00:01:38,280
可以这么说，实际上
解决这一难题的人，

32
00:01:38,280 --> 00:01:41,080
向他们提供线索，
提示后，在提示。

33
00:01:41,080 --> 00:01:42,280
因此，更多的在下周。

34
00:01:42,280 --> 00:01:43,720
但是，这是什么样的未来。

35
00:01:43,720 --> 00:01:47,610
>> 现在还记得，在本周早些时候
我们有这个悬念，如果你愿意，

36
00:01:47,610 --> 00:01:52,560
因此，我们正在做排序的最好
明智的是一个上限的大O的n

37
00:01:52,560 --> 00:01:53,210
平方。

38
00:01:53,210 --> 00:01:56,520
换句话说，冒泡排序，
选择排序，插入排序，

39
00:01:56,520 --> 00:01:59,120
所有的人，而不同
在执行过程中，

40
00:01:59,120 --> 00:02:03,480
演化成一个n平方运行
时间在非常最坏情况。

41
00:02:03,480 --> 00:02:06,010
而我们通常认为
最糟糕的情况下进行排序

42
00:02:06,010 --> 00:02:08,814
是一个你投入
是完全倒退。

43
00:02:08,814 --> 00:02:11,980
事实上，花了相当多的步骤
要实现每个算法。

44
00:02:11,980 --> 00:02:15,110
>> 现在，在类的尽头
回想一下，我们比较冒泡排序

45
00:02:15,110 --> 00:02:19,390
反对对另外一个选择排序
我们称之为合并排序的时候，

46
00:02:19,390 --> 00:02:22,120
我建议它采取
优势从一周一节课

47
00:02:22,120 --> 00:02:24,060
零，分而治之。

48
00:02:24,060 --> 00:02:28,810
并以某种方式达成某种
对数运行时间最终，

49
00:02:28,810 --> 00:02:31,024
而不是东西
这是纯粹的二次。

50
00:02:31,024 --> 00:02:33,440
而且它不是相当的对数，
这是多一点比。

51
00:02:33,440 --> 00:02:36,520
但是，如果你从类回忆，
这是更多，更快。

52
00:02:36,520 --> 00:02:38,210
让我们来看看，我们不放过​​。

53
00:02:38,210 --> 00:02:41,880

54
00:02:41,880 --> 00:02:45,370
>> 冒泡排序与选择
排序与归并排序。

55
00:02:45,370 --> 00:02:47,700
现在，他们都在运行，在
理论上讲，在同一时间。

56
00:02:47,700 --> 00:02:50,510
CPU被以相同的速度运行。

57
00:02:50,510 --> 00:02:54,990
但是你能感觉到有多无聊本
是很快将成为，

58
00:02:54,990 --> 00:02:58,790
并有多快，当我们注入
有点星期零的算法，

59
00:02:58,790 --> 00:03:00,080
我们可以加快速度。

60
00:03:00,080 --> 00:03:01,630
>> 所以标记排序看起来令人惊讶。

61
00:03:01,630 --> 00:03:05,220
我们怎样才能利用它，为了
更快速的数字进行排序。

62
00:03:05,220 --> 00:03:07,140
好吧，让我们回想起
一个成分，我们

63
00:03:07,140 --> 00:03:10,380
有回零一周，那
在电话簿中寻觅，

64
00:03:10,380 --> 00:03:12,380
并且记得，
伪代码，我们建议，

65
00:03:12,380 --> 00:03:14,560
通过它我们可以找到
有人喜欢迈克·史密斯，

66
00:03:14,560 --> 00:03:16,310
看起来有点这样的事情。

67
00:03:16,310 --> 00:03:20,820
>> 现在来具体看看
在第7行和8，以及10和11，

68
00:03:20,820 --> 00:03:25,240
这导致该循环，因此我们维持
回到第3行一次，又一次，

69
00:03:25,240 --> 00:03:26,520
然后再次。

70
00:03:26,520 --> 00:03:31,790
但事实证明，我们可以查看
这种算法，这里在伪代码中，

71
00:03:31,790 --> 00:03:33,620
一点更全面。

72
00:03:33,620 --> 00:03:35,960
事实上，我在寻找什么
在这里，屏幕上，

73
00:03:35,960 --> 00:03:41,180
是一种算法，用于搜索
迈克·史密斯在一些组页面。

74
00:03:41,180 --> 00:03:45,520
事实上，我们可以简化
算法在这些线路7和8，

75
00:03:45,520 --> 00:03:49,860
而10和11，只是这么一说，
我在这里介绍了黄色。

76
00:03:49,860 --> 00:03:52,210
换句话说，如果麦克
史密斯早在书中，

77
00:03:52,210 --> 00:03:55,004
我们并不需要指定步骤
一步现在怎么去找他。

78
00:03:55,004 --> 00:03:56,920
我们没有指定
回到3号线，

79
00:03:56,920 --> 00:03:58,960
我们为什么不只是代替，
比方说，更一般地，

80
00:03:58,960 --> 00:04:01,500
搜索麦克在
书的左半边。

81
00:04:01,500 --> 00:04:03,960
>> 相反，如果麦克
实际上后来在书中，

82
00:04:03,960 --> 00:04:07,540
为什么我们不只是引用引文结束搜索
麦克在书中的右半部分。

83
00:04:07,540 --> 00:04:11,030
换句话说，我们为什么不只是
排序撑船对自己说，

84
00:04:11,030 --> 00:04:13,130
搜索麦克在这
书的一部分，

85
00:04:13,130 --> 00:04:16,279
并把它留给我们现有的
算法告诉我们

86
00:04:16,279 --> 00:04:18,750
如何在搜索麦克
即左书的一半。

87
00:04:18,750 --> 00:04:20,750
换句话说，我们的
算法的工作无论是

88
00:04:20,750 --> 00:04:24,670
电话簿该厚度的，这
厚度，或者任何任何厚度。

89
00:04:24,670 --> 00:04:27,826
因此，我们可以递归
定义这个算法。

90
00:04:27,826 --> 00:04:29,950
换句话说，对
屏幕这里，是一个算法

91
00:04:29,950 --> 00:04:33,130
为寻找麦克·史密斯
之间的电话簿的网页。

92
00:04:33,130 --> 00:04:37,410
因此，在管线7和10所示，让我们
只说这一点。

93
00:04:37,410 --> 00:04:40,250
我用这个词了一下
以前，而事实上，递归

94
00:04:40,250 --> 00:04:42,450
是的流行语现在，
和它的这个过程

95
00:04:42,450 --> 00:04:47,210
做一些周期性通过某种方式的
使用您已有的代码，

96
00:04:47,210 --> 00:04:49,722
并再次调用它，
又一次，又一次。

97
00:04:49,722 --> 00:04:51,930
现在，这将是重要的
我们莫名其妙地底

98
00:04:51,930 --> 00:04:53,821
出来了，不这样做无限长。

99
00:04:53,821 --> 00:04:56,070
否则，我们将
有确实是一个无限循环。

100
00:04:56,070 --> 00:04:59,810
但是让我们看看我们是否能借这个想法
递归的，又做什么

101
00:04:59,810 --> 00:05:03,600
一次又一次，来解决
通过合并排序问题

102
00:05:03,600 --> 00:05:05,900
排序，更加有效。

103
00:05:05,900 --> 00:05:06,970
>> 所以，我给你归并排序。

104
00:05:06,970 --> 00:05:07,920
让我们一起来看看。

105
00:05:07,920 --> 00:05:10,850
因此，这里是伪代码，用
这是我们可以实现分选，

106
00:05:10,850 --> 00:05:12,640
采用这种算法称为归并排序。

107
00:05:12,640 --> 00:05:13,880
这是相当简单，就是。

108
00:05:13,880 --> 00:05:15,940
在n个元素的输入，
换句话说，如果你

109
00:05:15,940 --> 00:05:18,830
给定n个元素和数字
字母或任何输入是，

110
00:05:18,830 --> 00:05:22,430
如果你给定的n个元素，如果
n小于2，只是返回。

111
00:05:22,430 --> 00:05:22,930
对？

112
00:05:22,930 --> 00:05:26,430
因为，如果n小于2，即
意味着我的元素列表

113
00:05:26,430 --> 00:05:30,446
可以是0或1号，并
在这两个琐碎的情况下，

114
00:05:30,446 --> 00:05:31,570
名单已经排序。

115
00:05:31,570 --> 00:05:32,810
如果没有清单，它的排序。

116
00:05:32,810 --> 00:05:35,185
而且如果有长度的列表
1，这显然排序。

117
00:05:35,185 --> 00:05:38,280
所以该算法仅需要
真正做一些有趣的事情，

118
00:05:38,280 --> 00:05:40,870
如果我们有两个或更多的
元素给我们。

119
00:05:40,870 --> 00:05:42,440
因此，让我们来看看神奇的话。

120
00:05:42,440 --> 00:05:47,500
元件的左半其他排序，
然后排序元素的右半

121
00:05:47,500 --> 00:05:49,640
然后合并排序半。

122
00:05:49,640 --> 00:05:52,440
什么样的心态弯曲
在这里，是，我真的不

123
00:05:52,440 --> 00:05:56,190
似乎已经告诉过你
任何事情，只是还没有，对不对？

124
00:05:56,190 --> 00:05:59,560
所有我已经说过了，给定名单
n个元素，排序的左半边，

125
00:05:59,560 --> 00:06:01,800
然后右半，然后
合并排序的一半，

126
00:06:01,800 --> 00:06:03,840
但如果是实际的秘密武器？

127
00:06:03,840 --> 00:06:05,260
哪里的算法？

128
00:06:05,260 --> 00:06:09,150
那么事实证明，这两条线
首先，要素排序左前卫，

129
00:06:09,150 --> 00:06:13,970
和排序右半元件，
是递归调用，可以这么说。

130
00:06:13,970 --> 00:06:16,120
>> 毕竟，在这个
时间点上，我必须

131
00:06:16,120 --> 00:06:18,950
一种算法，用以
排序一大堆的元素？

132
00:06:18,950 --> 00:06:19,450
是。

133
00:06:19,450 --> 00:06:20,620
就是这里。

134
00:06:20,620 --> 00:06:25,180
这是就在屏幕上，并
这样我就可以使用同一套步骤

135
00:06:25,180 --> 00:06:28,500
在左半排序，
我可以右半部分。

136
00:06:28,500 --> 00:06:30,420
事实上，一次，又一次。

137
00:06:30,420 --> 00:06:34,210
因此，好歹，我们将很快
看到这种情况，归并排序的魔力

138
00:06:34,210 --> 00:06:37,967
嵌入在非常最终
线，合并排序的半部。

139
00:06:37,967 --> 00:06:39,300
而这似乎相当直观。

140
00:06:39,300 --> 00:06:41,050
你把两半，而你，
不知何故，把它们合并起来，

141
00:06:41,050 --> 00:06:43,260
我们将看到这个
具体在某一时刻。

142
00:06:43,260 --> 00:06:45,080
>> 但是，这是一个完整的算法。

143
00:06:45,080 --> 00:06:46,640
而让我们看看究竟为什么。

144
00:06:46,640 --> 00:06:50,912
那么假设我们给这些相同
八种元素在这里在屏幕上，人们

145
00:06:50,912 --> 00:06:53,120
通过八个，但他们
在看似随机的顺序。

146
00:06:53,120 --> 00:06:55,320
而这一目标的手
这些元素进行排序。

147
00:06:55,320 --> 00:06:58,280
嗯，我怎么能去
做它用，再次，

148
00:06:58,280 --> 00:07:00,407
归并排序，按本伪？

149
00:07:00,407 --> 00:07:02,740
再次，这种根深蒂固的
你的头脑，就一下。

150
00:07:02,740 --> 00:07:05,270
第一种情况是相当
琐碎，如果它小于2，

151
00:07:05,270 --> 00:07:07,060
刚回来，没有工作要做。

152
00:07:07,060 --> 00:07:09,290
所以真的有只有三个
步骤要真正记住。

153
00:07:09,290 --> 00:07:11,081
又一次，又一次，我
会希望有

154
00:07:11,081 --> 00:07:13,980
在左半排序，
排序的右半

155
00:07:13,980 --> 00:07:15,890
然后一旦其
两个半部进行排序，

156
00:07:15,890 --> 00:07:18,710
我想将它们合并在一起
成一个排序列表。

157
00:07:18,710 --> 00:07:19,940
所以记住这一点。

158
00:07:19,940 --> 00:07:21,310
>> 因此，这里的原始列表。

159
00:07:21,310 --> 00:07:23,510
让我们把这个作为
阵列，因为我们开始

160
00:07:23,510 --> 00:07:25,800
两个星期，这是一个
连续的内存块。

161
00:07:25,800 --> 00:07:28,480
在这种情况下，含有8
数字，背靠背回来。

162
00:07:28,480 --> 00:07:30,700
而且，我们现在申请归并排序。

163
00:07:30,700 --> 00:07:33,300
所以，我首先想要排序
这个列表的左边一半，

164
00:07:33,300 --> 00:07:37,370
让我们，因此，
集中4,8，6和2上。

165
00:07:37,370 --> 00:07:41,000
>> 现在，我怎么去
分拣大小4的名单？

166
00:07:41,000 --> 00:07:45,990
嗯，我必须现在考虑
排序的左半的左侧。

167
00:07:45,990 --> 00:07:47,720
再次，让我们倒带只是一瞬间。

168
00:07:47,720 --> 00:07:51,010
如果伪代码是这样的，
而我给八素，

169
00:07:51,010 --> 00:07:53,230
8显然是更大
大于或等于2。

170
00:07:53,230 --> 00:07:54,980
因此，与第一种情况下不适用。

171
00:07:54,980 --> 00:07:58,120
因此，八个元素进行排序，我第一次
排序元件的左半部，

172
00:07:58,120 --> 00:08:01,930
接着我的右半边，然后我合并
两个半排序，每个大小为4。

173
00:08:01,930 --> 00:08:02,470
行。

174
00:08:02,470 --> 00:08:07,480
>> 但如果你只是告诉我，排序
左半部分，也就是现在的大小为4，

175
00:08:07,480 --> 00:08:09,350
我怎么排序的左半边？

176
00:08:09,350 --> 00:08:11,430
好吧，如果我有一个
四个要素投入，

177
00:08:11,430 --> 00:08:14,590
我第一次排序的左
二，则对二，

178
00:08:14,590 --> 00:08:16,210
然后我把它们合并起来。

179
00:08:16,210 --> 00:08:18,700
如此反复，就显得有点
一记弯曲在这里比赛，

180
00:08:18,700 --> 00:08:21,450
那种因为你，要
还记得你在哪里的故事，

181
00:08:21,450 --> 00:08:23,620
但在一天结束时，
给定任意数量的元素，

182
00:08:23,620 --> 00:08:25,620
你首先要排序的
左半，然后右半边，

183
00:08:25,620 --> 00:08:26,661
然后把它们合并起来。

184
00:08:26,661 --> 00:08:28,630
让我们开始这样做。

185
00:08:28,630 --> 00:08:30,170
以下是八种元素的输入。

186
00:08:30,170 --> 00:08:31,910
现在，我们正在寻找的左半部分在这里。

187
00:08:31,910 --> 00:08:33,720
我怎么排序四个要素？

188
00:08:33,720 --> 00:08:35,610
嗯，我第一次排序的左半边。

189
00:08:35,610 --> 00:08:37,720
现在，我怎么排序的左半边？

190
00:08:37,720 --> 00:08:39,419
嗯，我一直在给定的两个元素。

191
00:08:39,419 --> 00:08:41,240
因此，让我们这两个元素进行排序。

192
00:08:41,240 --> 00:08:44,540
图2是大于或
等于2，当然。

193
00:08:44,540 --> 00:08:46,170
所以这第一种情况下不适用。

194
00:08:46,170 --> 00:08:49,010
>> 所以，我现在有向左排序
上半年这两个元素。

195
00:08:49,010 --> 00:08:50,870
左半部分，当然​​，仅仅是4。

196
00:08:50,870 --> 00:08:54,020
所以，我怎么排序一个元素的列表？

197
00:08:54,020 --> 00:08:57,960
现在好了，特别的基本情况
往上顶，可以这么说，适用。

198
00:08:57,960 --> 00:09:01,470
1小于2，和我的
名单确实是大小为1。

199
00:09:01,470 --> 00:09:02,747
所以我就回来。

200
00:09:02,747 --> 00:09:03,580
我没有做任何事情。

201
00:09:03,580 --> 00:09:06,770
事实上，看看我有
完成后，4已经排序。

202
00:09:06,770 --> 00:09:09,220
就像我已经
部分成功在这里。

203
00:09:09,220 --> 00:09:11,750
>> 现在看来很愚蠢
权利要求，但它是真实的。

204
00:09:11,750 --> 00:09:13,700
图4是尺寸1的列表。

205
00:09:13,700 --> 00:09:15,090
它已经排序。

206
00:09:15,090 --> 00:09:16,270
这是左半部。

207
00:09:16,270 --> 00:09:18,010
现在我排序的右半​​部分。

208
00:09:18,010 --> 00:09:22,310
我的输入是一个元素，8
同样，已经排序。

209
00:09:22,310 --> 00:09:25,170
愚蠢，太，但同样，
这一基本原则

210
00:09:25,170 --> 00:09:28,310
将会让我们现在建
在此之上成功。

211
00:09:28,310 --> 00:09:32,260
4排序，8排序，现在
什么是最后一步？

212
00:09:32,260 --> 00:09:35,330
因此第三和最后的步骤，任何
一次你排序列表，召回，

213
00:09:35,330 --> 00:09:38,310
是要合并的两半，
左和右。

214
00:09:38,310 --> 00:09:39,900
因此，让我们这样做。

215
00:09:39,900 --> 00:09:41,940
我的左半边，当然，4。

216
00:09:41,940 --> 00:09:43,310
我的右半边是8。

217
00:09:43,310 --> 00:09:44,100
>> 因此，让我们做到这一点。

218
00:09:44,100 --> 00:09:46,410
首先我要分配
一些额外的内存，

219
00:09:46,410 --> 00:09:48,680
我将在这里代表，
因为只是一个辅助阵列，

220
00:09:48,680 --> 00:09:49,660
这是足够大，以适应这一点。

221
00:09:49,660 --> 00:09:52,243
但是，你能想象延伸
该矩形的整个长度，

222
00:09:52,243 --> 00:09:53,290
如果我们需要更长时间之后。

223
00:09:53,290 --> 00:09:58,440
我如何采取4和8，和合并
尺寸1在一起的那两个名单？

224
00:09:58,440 --> 00:10:00,270
在这里，也很简单。

225
00:10:00,270 --> 00:10:03,300
4是第一位的，然后是8。

226
00:10:03,300 --> 00:10:07,130
因为如果我要排序的
左半，然后右半边，

227
00:10:07,130 --> 00:10:09,900
然后合并这两个半
同时，在有序，

228
00:10:09,900 --> 00:10:11,940
4是第一位的，然后是8。

229
00:10:11,940 --> 00:10:15,810
>> 因此，我们似乎正在取得进展，甚至
虽然我没有做任何实际工作。

230
00:10:15,810 --> 00:10:17,800
但是，请记住，我们是在故事中。

231
00:10:17,800 --> 00:10:19,360
我们最初采取了八大要素。

232
00:10:19,360 --> 00:10:21,480
我们的排序左半，这是4。

233
00:10:21,480 --> 00:10:24,450
然后，我们整理了左半
的左半部分，为2。

234
00:10:24,450 --> 00:10:25,270
在这里，我们走了。

235
00:10:25,270 --> 00:10:26,920
我们正在与该步骤完成。

236
00:10:26,920 --> 00:10:29,930
>> 因此，如果我们排序
左半边的2，现在我们

237
00:10:29,930 --> 00:10:32,130
得的2右半排序。

238
00:10:32,130 --> 00:10:35,710
这样的2的右半边是
这里这两个值，6和2。

239
00:10:35,710 --> 00:10:40,620
因此，让我们现在就采取大小的输入
2，和排序左半，然后

240
00:10:40,620 --> 00:10:42,610
右半，然后
把它们合并起来。

241
00:10:42,610 --> 00:10:45,722
那么我怎么排序大小的列表
1，仅包含数6？

242
00:10:45,722 --> 00:10:46,430
我已经做了。

243
00:10:46,430 --> 00:10:48,680
大小为1的那个列表进行排序。

244
00:10:48,680 --> 00:10:52,140
>> 我如何排序的另一个列表
尺寸如图1所示，所谓的右半。

245
00:10:52,140 --> 00:10:54,690
那么它也已经排序。

246
00:10:54,690 --> 00:10:56,190
数字2是孤独的。

247
00:10:56,190 --> 00:11:00,160
所以，现在我有两个半，左，
好吧，我需要将它们合并在一起。

248
00:11:00,160 --> 00:11:01,800
让我给自己做一些额外的空间。

249
00:11:01,800 --> 00:11:05,580
并把2在那里，
然后在那里6，从而

250
00:11:05,580 --> 00:11:10,740
排序该列表，左，右，
和合并在一起，最终。

251
00:11:10,740 --> 00:11:12,160
所以，我在稍微好一点的形状。

252
00:11:12,160 --> 00:11:16,250
我不这样做，是因为清楚4，8，2，
6是不是我想要的最终排序。

253
00:11:16,250 --> 00:11:20,640
但是我现在有2号两个列表，该
双方都分别进行了排序。

254
00:11:20,640 --> 00:11:24,580
所以，现在，如果你在你的心中的倒带
眼睛，哪里是离开我们？

255
00:11:24,580 --> 00:11:28,520
我开始与八素，然后我
又缩减到了4左半部分，

256
00:11:28,520 --> 00:11:31,386
然后2左半，和
然后为2的右半边，

257
00:11:31,386 --> 00:11:34,510
我完成了，因此，左排序
一半的2，以及2的右半

258
00:11:34,510 --> 00:11:37,800
那么什么是第三次，也是最后一步吗？

259
00:11:37,800 --> 00:11:41,290
我必须合并到一起
2号两个列表。

260
00:11:41,290 --> 00:11:42,040
因此，让我们继续前进。

261
00:11:42,040 --> 00:11:43,940
在这里，在屏幕上，给
我一些额外的内存，

262
00:11:43,940 --> 00:11:47,170
虽然在技术上，注意，我
有一大堆的空白向上顶

263
00:11:47,170 --> 00:11:47,670
那里。

264
00:11:47,670 --> 00:11:50,044
如果我想特别
有效的空间明智的，

265
00:11:50,044 --> 00:11:52,960
我刚开始运动的元素
来回，顶部和底部。

266
00:11:52,960 --> 00:11:55,460
但只是为了视觉清晰，
我打算把它放在楼下，

267
00:11:55,460 --> 00:11:56,800
让事情变得非常干净。

268
00:11:56,800 --> 00:11:58,150
>> 所以，我有大小2的两个列表。

269
00:11:58,150 --> 00:11:59,770
第一个列表有4个和8个。

270
00:11:59,770 --> 00:12:01,500
第二个列表中有2和6。

271
00:12:01,500 --> 00:12:03,950
让我们合并这些
一起排序顺序。

272
00:12:03,950 --> 00:12:09,910
当然，2，是第一位的，
然后4，然后6，然后8。

273
00:12:09,910 --> 00:12:12,560
而现在，我们似乎越来越
有趣的地方。

274
00:12:12,560 --> 00:12:15,720
的现在，我已经来分类的一半
列出，而巧合的是，这是

275
00:12:15,720 --> 00:12:18,650
所有的偶数，但
确实是，只是一个巧合。

276
00:12:18,650 --> 00:12:22,220
而我现在已经整理左
一半，所以，它的2，4，6，和8。

277
00:12:22,220 --> 00:12:23,430
没有什么是坏了。

278
00:12:23,430 --> 00:12:24,620
那感觉就像进展。

279
00:12:24,620 --> 00:12:26,650
>> 现在感觉我已经
在讨论永远的现在，

280
00:12:26,650 --> 00:12:29,850
所以剩下，如果这待观察
算法确实是更有效的。

281
00:12:29,850 --> 00:12:31,766
但是，我们正在经历
它的超级有条不紊。

282
00:12:31,766 --> 00:12:34,060
当然，一台电脑，，
会做这样的。

283
00:12:34,060 --> 00:12:34,840
因此，我们在哪里？

284
00:12:34,840 --> 00:12:36,180
我们开始与八个元素。

285
00:12:36,180 --> 00:12:37,840
我排序的4左半部。

286
00:12:37,840 --> 00:12:39,290
我似乎与完成。

287
00:12:39,290 --> 00:12:42,535
所以，现在的下一个步骤是
排序的4的右半部分。

288
00:12:42,535 --> 00:12:44,410
而这一部分，我们可以去
通过多一点

289
00:12:44,410 --> 00:12:47,140
很快，虽然你
欢迎后退或暂停，只是

290
00:12:47,140 --> 00:12:49,910
想通过它在
自己的节奏，但什么

291
00:12:49,910 --> 00:12:53,290
我们现在是一个机会，
做同样的算法在四个

292
00:12:53,290 --> 00:12:54,380
不同的号码。

293
00:12:54,380 --> 00:12:57,740
>> 因此，让我们继续前进，并专注于
右半部分，我们在这里。

294
00:12:57,740 --> 00:13:01,260
的那左半
右前卫，现在的

295
00:13:01,260 --> 00:13:04,560
左侧的左半边
一半的右半部，

296
00:13:04,560 --> 00:13:08,030
以及如何排序大小的列表
1只包含数字1？

297
00:13:08,030 --> 00:13:09,030
它已经完成。

298
00:13:09,030 --> 00:13:11,830
我该怎么做相同的列表
中只包含7尺寸1？

299
00:13:11,830 --> 00:13:12,840
它已经完成。

300
00:13:12,840 --> 00:13:16,790
步骤三本半，然后
被合并这两个元件

301
00:13:16,790 --> 00:13:20,889
成大小为2,1和7的一个新的列表。

302
00:13:20,889 --> 00:13:23,180
似乎没有所做的一切
那么多有趣的工作。

303
00:13:23,180 --> 00:13:24,346
让我们看看接下来会发生什么。

304
00:13:24,346 --> 00:13:29,210
我只是排序的左半
我原来输入的右半部分。

305
00:13:29,210 --> 00:13:32,360
现在让我们来排序的权利
半，它包含5和3。

306
00:13:32,360 --> 00:13:35,740
让我们再次看一下左边
上半年，分类，右半边，排序，

307
00:13:35,740 --> 00:13:39,120
并合并这两个在一起，
到了一些额外的空间，

308
00:13:39,120 --> 00:13:41,670
3是第一位的，然后是5。

309
00:13:41,670 --> 00:13:46,190
所以，现在，我们已经整理了
右半部分左半

310
00:13:46,190 --> 00:13:49,420
原问题的，并
右边一半的右边一半

311
00:13:49,420 --> 00:13:50,800
的原始问题。

312
00:13:50,800 --> 00:13:52,480
什么是第三步也是最后一步？

313
00:13:52,480 --> 00:13:54,854
那么这两个半融合在一起。

314
00:13:54,854 --> 00:13:57,020
因此，让我得到我自己的一些
额外的空间，但同样，我

315
00:13:57,020 --> 00:13:58,699
可以使用备用空间往上顶。

316
00:13:58,699 --> 00:14:00,490
但是，我们要保持
它简单直观。

317
00:14:00,490 --> 00:14:07,070
让我在现在1合并，并
然后3，然后5，然后7。

318
00:14:07,070 --> 00:14:10,740
现在，从而留下了我的
原问题的右半

319
00:14:10,740 --> 00:14:12,840
这是完全排序。

320
00:14:12,840 --> 00:14:13,662
>> 那么剩下？

321
00:14:13,662 --> 00:14:16,120
我觉得我一直在说的
同样的事情又一次，又一次，

322
00:14:16,120 --> 00:14:18,700
但是这反映了
事实是，我们正在使用递归。

323
00:14:18,700 --> 00:14:21,050
使用的方法
算法再次，并再次，

324
00:14:21,050 --> 00:14:23,940
对较小的子集
原来的问题。

325
00:14:23,940 --> 00:14:27,580
所以，我现在有一个左排序
原来的一半问题。

326
00:14:27,580 --> 00:14:30,847
我有一个正确排序的一半
的原始问题。

327
00:14:30,847 --> 00:14:32,180
什么是第三个也是最后一步？

328
00:14:32,180 --> 00:14:33,590
哦，这是合并。

329
00:14:33,590 --> 00:14:34,480
因此，让我们做到这一点。

330
00:14:34,480 --> 00:14:36,420
让我们来分配一些额外的
记忆，但我的上帝，我们

331
00:14:36,420 --> 00:14:37,503
可以把它的任何地方了。

332
00:14:37,503 --> 00:14:40,356
我们提供这么大的空间
给我们，但我们会保持它的简单。

333
00:14:40,356 --> 00:14:42,730
而不是回去和
第四我们原来的记忆，

334
00:14:42,730 --> 00:14:44,480
我们只能这样做
视觉这儿下面，

335
00:14:44,480 --> 00:14:47,240
完成了合并
左半和右半部分。

336
00:14:47,240 --> 00:14:49,279
>> 因此，通过合并，请问我需要做什么？

337
00:14:49,279 --> 00:14:50,820
我想借此元素的顺序。

338
00:14:50,820 --> 00:14:53,230
所以看左半边，
我看到的第一个数字是2。

339
00:14:53,230 --> 00:14:55,230
看看我的右半边，
我看到的第一个号码

340
00:14:55,230 --> 00:14:58,290
是1，所以很明显这
一些做我想剜出，

341
00:14:58,290 --> 00:15:00,430
并把第一个在我的最后名单？

342
00:15:00,430 --> 00:15:01,449
当然，1。

343
00:15:01,449 --> 00:15:02,990
现在我要问同样的问题。

344
00:15:02,990 --> 00:15:05,040
在左前卫，我已经
仍然得到了2号。

345
00:15:05,040 --> 00:15:07,490
在右半，
我已经得到了3号。

346
00:15:07,490 --> 00:15:08,930
哪一个我想选择？

347
00:15:08,930 --> 00:15:11,760
当然，数字2和
现在通知考生

348
00:15:11,760 --> 00:15:13,620
是4上的右左，3。

349
00:15:13,620 --> 00:15:15,020
让我们，当然，选择3。

350
00:15:15,020 --> 00:15:18,020
现在的候选人4
右侧的左，5。

351
00:15:18,020 --> 00:15:19,460
我们，当然，选择4。

352
00:15:19,460 --> 00:15:21,240
6上右侧的左，5。

353
00:15:21,240 --> 00:15:22,730
我们，当然，选择5。

354
00:15:22,730 --> 00:15:25,020
6上右侧的左，7。

355
00:15:25,020 --> 00:15:29,320
我们选择6，然后我们
选择7，然后我们选择8。

356
00:15:29,320 --> 00:15:30,100
瞧。

357
00:15:30,100 --> 00:15:34,370
>> 话那么一个庞大的数字之后，我们
已经整理了八种元素列表

358
00:15:34,370 --> 00:15:38,450
成一个通过八个列表，
它将与每一步增加，

359
00:15:38,450 --> 00:15:40,850
但多少时间
它带我们去做到这一点。

360
00:15:40,850 --> 00:15:43,190
嗯，我特意
奠定了东西出来形象化

361
00:15:43,190 --> 00:15:46,330
在这里，让我们可以种
看到或体会到师

362
00:15:46,330 --> 00:15:49,060
征服一个已经发生的事情。

363
00:15:49,060 --> 00:15:52,830
>> 事实上，如果你回头看看之后，
我已经离开所有这些虚线

364
00:15:52,830 --> 00:15:55,660
在占位符，就可以了，
样的，看到的，以相反的顺序，

365
00:15:55,660 --> 00:15:58,800
样的，如果你回头看的
现在的历史，我原来的名单

366
00:15:58,800 --> 00:16:00,250
是大小8，当然，。

367
00:16:00,250 --> 00:16:03,480
然后以前，我是
处理规模4的两个列表，

368
00:16:03,480 --> 00:16:08,400
然后大小为2的四个列表，
然后大小为1的八个列表。

369
00:16:08,400 --> 00:16:10,151
>> 那么，这，
样的，提醒你？

370
00:16:10,151 --> 00:16:11,858
嗯，事实上，任何
我们已经算法

371
00:16:11,858 --> 00:16:14,430
看着迄今我们
鸿沟和差距，并且差距，

372
00:16:14,430 --> 00:16:19,500
再次保持有东西，
再次，结果在这个总体思路。

373
00:16:19,500 --> 00:16:23,100
所以有什么东西
对数回事。

374
00:16:23,100 --> 00:16:26,790
而且这不是n相当日志，但
有一个对数组件

375
00:16:26,790 --> 00:16:28,280
，这是我们刚刚做。

376
00:16:28,280 --> 00:16:31,570
>> 现在，让我们来考虑，实际上是如何。

377
00:16:31,570 --> 00:16:34,481
所以日志N的，又是
一个伟大的运行时间，

378
00:16:34,481 --> 00:16:36,980
当我们不喜欢的东西
二进制搜索，因为我们现在称呼它，

379
00:16:36,980 --> 00:16:40,090
分而治之的策略
通过我们找到迈克·史密斯。

380
00:16:40,090 --> 00:16:41,020
现在技术上。

381
00:16:41,020 --> 00:16:43,640
这是n个日志基地2个，甚至
尽管大多数数学课，

382
00:16:43,640 --> 00:16:45,770
通常10是你假设的基础。

383
00:16:45,770 --> 00:16:48,940
但计算机科学家几乎总是
思考和谈论的基地2个方面，

384
00:16:48,940 --> 00:16:52,569
所以我们一般只说日志
而不是n日志基地2 N，

385
00:16:52,569 --> 00:16:55,110
但他们只有一个与
在计算机的世界一样

386
00:16:55,110 --> 00:16:57,234
科学，顺便说一句，
有一个常数因子

387
00:16:57,234 --> 00:17:01,070
两者之间的差别，因此它的
反正没有实际意义，更多的正式理由。

388
00:17:01,070 --> 00:17:04,520
>> 但现在，我们关心
大约是这样的例子。

389
00:17:04,520 --> 00:17:08,520
因此，让我们不由的例子证明，但
至少使用数字的一个例子

390
00:17:08,520 --> 00:17:10,730
手头作为一个全面的检查，如果你愿意。

391
00:17:10,730 --> 00:17:14,510
所以以前的公式是日志基地
2 n个，但什么是正在这种情况下。

392
00:17:14,510 --> 00:17:18,526
我有N个原始号码，或8
原有的一些具体。

393
00:17:18,526 --> 00:17:20,359
现在，它已经有点
一段时间，但我敢

394
00:17:20,359 --> 00:17:25,300
确保日志基地2
值8是3，

395
00:17:25,300 --> 00:17:29,630
而事实上，有什么好的关于这是
该图3是次完全数

396
00:17:29,630 --> 00:17:33,320
你可以将一个列表
又一次，又一次的长度为8，

397
00:17:33,320 --> 00:17:36,160
又一次，直到你离开
只有大小为1的列表。

398
00:17:36,160 --> 00:17:36,660
对？

399
00:17:36,660 --> 00:17:40,790
8变为4，进到2，
变为1，这是

400
00:17:40,790 --> 00:17:43,470
反光正是中
图片我们有刚才。

401
00:17:43,470 --> 00:17:47,160
那么一点点神智检查到哪里
对数是实际参与。

402
00:17:47,160 --> 00:17:50,180
>> 所以，现在，还有什么是这里涉及？ ñ。

403
00:17:50,180 --> 00:17:53,440
所以请注意，每
一次我分裂名单，

404
00:17:53,440 --> 00:17:58,260
尽管以相反的顺序历史
在这里，我还在做ñ的事情。

405
00:17:58,260 --> 00:18:02,320
要求合并的步骤，
我接触的每一个数字，

406
00:18:02,320 --> 00:18:05,060
为了将其滑入
其适当的位置。

407
00:18:05,060 --> 00:18:10,760
因此，即使这个高度
图为大小日志N或3的n个，

408
00:18:10,760 --> 00:18:13,860
具体地，换言之，
我做了三个部门在这里。

409
00:18:13,860 --> 00:18:18,800
我没有多少工作要做水平
沿着这个图表每一​​次？

410
00:18:18,800 --> 00:18:21,110
>> 好吧，我做了n步的
工作，因为如果我

411
00:18:21,110 --> 00:18:24,080
有四个元素和四个元素，
我需要将它们合并在一起。

412
00:18:24,080 --> 00:18:26,040
我需要经过
这四个和这四个，

413
00:18:26,040 --> 00:18:28,123
最终合并它们
回八素。

414
00:18:28,123 --> 00:18:32,182
相反，如果我有八手指
在这里，我不这样做，八

415
00:18:32,182 --> 00:18:34,390
fingers-- sorry--如果我
有四个手指在这里，

416
00:18:34,390 --> 00:18:37,380
这是我做的，四根手指
在这里，这是我做的，

417
00:18:37,380 --> 00:18:40,590
那么这同样
像以前的例子，如果我做

418
00:18:40,590 --> 00:18:44,010
有八个手指虽然
总的来说，我可以，那种，做的。

419
00:18:44,010 --> 00:18:47,950
我可以准确地在这里做，
那么我可以肯定

420
00:18:47,950 --> 00:18:50,370
合并所有这些名单
尺寸1在一起。

421
00:18:50,370 --> 00:18:54,050
不过，我当然要看看
在每个元素一次。

422
00:18:54,050 --> 00:18:59,640
所以该方法的高度是log N，
这个过程的宽度，可以这么说，

423
00:18:59,640 --> 00:19:02,490
为n，所以，我们似乎
有，最终，是

424
00:19:02,490 --> 00:19:06,470
大小n次的运行时间n记录。

425
00:19:06,470 --> 00:19:08,977
>> 换句话说，我们将
列表，记录了n次，

426
00:19:08,977 --> 00:19:11,810
但我们做到了每一次，我们有
触摸的每一个元素

427
00:19:11,810 --> 00:19:13,560
为了将它们合并
总之，这

428
00:19:13,560 --> 00:19:18,120
为：N步，所以我们有n次日志N，
或者作为一个计算机科学家会说，

429
00:19:18,120 --> 00:19:20,380
渐近，这
将是很大的字

430
00:19:20,380 --> 00:19:22,810
来描述的上
势必在运行的时候，

431
00:19:22,810 --> 00:19:28,010
我们正处在一个大O运行
日志N次的，可以这么说。

432
00:19:28,010 --> 00:19:31,510
>> 现在，这是显著的，因为
回顾一下运行时间分别为

433
00:19:31,510 --> 00:19:34,120
与冒泡排序和选择
排序和插入排序，

434
00:19:34,120 --> 00:19:38,200
甚至有几个人的存在，
Ñ​​平方是我们在那里的。

435
00:19:38,200 --> 00:19:39,990
你也可以，那种，看到这个在这里。

436
00:19:39,990 --> 00:19:45,720
如果n的平方显然是n倍
N，但在这里我们有N次登录N，

437
00:19:45,720 --> 00:19:48,770
我们已经知道，从周
零，即日志n时，对数，

438
00:19:48,770 --> 00:19:50,550
是不是一些线性好。

439
00:19:50,550 --> 00:19:52,930
毕竟，回忆图片
与红色和黄色的

440
00:19:52,930 --> 00:19:56,500
而绿线，我们画的
绿色对数线要低得多。

441
00:19:56,500 --> 00:20:00,920
因此，更好更快
比直黄色和红色的线，

442
00:20:00,920 --> 00:20:05,900
n次N日志，着实更好
比n次N，或N的平方。

443
00:20:05,900 --> 00:20:09,110
>> 因此，我们似乎有
识别算法合并

444
00:20:09,110 --> 00:20:11,870
那种运行在多
更快的时间，而事实上，

445
00:20:11,870 --> 00:20:16,560
这就是为什么，在本周早些时候，当
我们看到泡沫之间的较量

446
00:20:16,560 --> 00:20:20,750
排序，选择排序，并合并
排序，归并排序真的，真的赢了。

447
00:20:20,750 --> 00:20:23,660
事实上，我们甚至没有等待
对于冒泡排序和选择排序

448
00:20:23,660 --> 00:20:24,790
去完成。

449
00:20:24,790 --> 00:20:27,410
>> 现在让我们来一个其他通
在此，从一个稍微更

450
00:20:27,410 --> 00:20:31,030
正式的角度来看，只要在
情况下，这种共振效果更佳

451
00:20:31,030 --> 00:20:33,380
高于层面的讨论。

452
00:20:33,380 --> 00:20:34,880
因此，这里的算法了。

453
00:20:34,880 --> 00:20:36,770
让我们扪心自问，
什么的运行时间

454
00:20:36,770 --> 00:20:39,287
是这个算法的各个步骤？

455
00:20:39,287 --> 00:20:41,620
让我们把它分为第一
壳体和第二壳体。

456
00:20:41,620 --> 00:20:46,280
中频和ELSE在IF的情况下，
如果n小于2时，只返回。

457
00:20:46,280 --> 00:20:47,580
感觉像固定时间。

458
00:20:47,580 --> 00:20:50,970
这是，那种，像两个步骤，
如果n小于2时，然后返回。

459
00:20:50,970 --> 00:20:54,580
但是，正如我们周一表示，
固定时间，或大O 1，

460
00:20:54,580 --> 00:20:57,130
可以是两个步骤，三
步骤，甚至是1000步。

461
00:20:57,130 --> 00:20:59,870
重要的是，它的
的步骤的数目恒定。

462
00:20:59,870 --> 00:21:03,240
因此，黄色高亮伪
在这里试车时，我们会打电话给它，

463
00:21:03,240 --> 00:21:04,490
恒定的时间。

464
00:21:04,490 --> 00:21:06,780
所以更正式，和
我们将用于：此

465
00:21:06,780 --> 00:21:09,910
将在多大程度上我们
正式这种权利now-- n个T，

466
00:21:09,910 --> 00:21:15,030
一问题的运行时间
这占据N出头作为输入，

467
00:21:15,030 --> 00:21:19,150
等于大O之一，
如果n小于2。

468
00:21:19,150 --> 00:21:20,640
因此，它是有条件的。

469
00:21:20,640 --> 00:21:24,150
所以要清楚，如果n小于
2，我们有一个很短的列表，然后

470
00:21:24,150 --> 00:21:29,151
的运行时间，T的n，其中n是
1或0，在这种非常具体的情况下，

471
00:21:29,151 --> 00:21:30,650
它只是将是恒定的时间。

472
00:21:30,650 --> 00:21:32,691
这将需要一个
一步，两步，等等。

473
00:21:32,691 --> 00:21:33,950
它是一个固定的步数。

474
00:21:33,950 --> 00:21:38,840
>> 因此，多汁的部分肯定是在
在伪另一种情况。

475
00:21:38,840 --> 00:21:40,220
该ELSE情况。

476
00:21:40,220 --> 00:21:44,870
排序左元素的一半，排序权
半元件，合并排序的半部。

477
00:21:44,870 --> 00:21:46,800
多久每一这些步骤走？

478
00:21:46,800 --> 00:21:49,780
好吧，如果运行
时间到n个元素进行排序

479
00:21:49,780 --> 00:21:53,010
是，我们很叫它
一般，n个T，

480
00:21:53,010 --> 00:21:55,500
然后左排序
一半的元素

481
00:21:55,500 --> 00:21:59,720
一种是，好像是说，
ñ对T除以2，

482
00:21:59,720 --> 00:22:03,000
并且类似地排序的右半
因素之一是，那种，好像说，

483
00:22:03,000 --> 00:22:06,974
n个牛逼分2，然后
合并排序的一半。

484
00:22:06,974 --> 00:22:08,890
那么，如果我有一些
元件的数目在这里，

485
00:22:08,890 --> 00:22:11,230
样四，有的数
这里的元素，如4，

486
00:22:11,230 --> 00:22:14,650
我必须合并这四个中
在，并在各一个的这四个

487
00:22:14,650 --> 00:22:17,160
后等，从而使
最终我有八个元素。

488
00:22:17,160 --> 00:22:20,230
这感觉就像那是大O n个步骤？

489
00:22:20,230 --> 00:22:23,500
如果我有n个指和各
它们已被合并到的地方，

490
00:22:23,500 --> 00:22:25,270
这是像另一个n步。

491
00:22:25,270 --> 00:22:27,360
>> 因此，我们确实通过公式，
我们可以表达这一点，

492
00:22:27,360 --> 00:22:29,960
虽然有点scarily在第一
一目了然，但它是

493
00:22:29,960 --> 00:22:31,600
捕捉正是这样的逻辑。

494
00:22:31,600 --> 00:22:35,710
T N的运行时间，如果n
是大于或等于2。

495
00:22:35,710 --> 00:22:42,500
在这种情况下，在ELSE情况下，是正对T
除以2的n个除以2，再加上T，

496
00:22:42,500 --> 00:22:45,320
再加上大O n的一些
步线数，

497
00:22:45,320 --> 00:22:51,630
也许正是N，也许2倍
N，但它的大概，n阶。

498
00:22:51,630 --> 00:22:54,060
所以这也就是我们如何
通过公式表达这一点。

499
00:22:54,060 --> 00:22:56,809
现在，你不会不知道这一点，除非
你已经记录了它在你的心中，

500
00:22:56,809 --> 00:22:58,710
或看它在
背课本，那

501
00:22:58,710 --> 00:23:00,501
可能有一点
备忘单底，

502
00:23:00,501 --> 00:23:03,940
但这是，事实上，将要
给我们一个大O的n log n个，

503
00:23:03,940 --> 00:23:06,620
因为复发了
你现在看到的在屏幕上，

504
00:23:06,620 --> 00:23:09,550
如果你真的做到了出来，用
无限多的例子，

505
00:23:09,550 --> 00:23:13,000
或者你通过公式做了，你会
看到这一点，因为此公式

506
00:23:13,000 --> 00:23:17,100
本身是递归的，与叔
ñ过的东西就没事了，

507
00:23:17,100 --> 00:23:21,680
并在左边ñ超过T，这样可以
实际上被表达，最终

508
00:23:21,680 --> 00:23:24,339
的n log n个大去了。

509
00:23:24,339 --> 00:23:26,130
如果不相信，这是
精细现在，只要

510
00:23:26,130 --> 00:23:28,960
采取的信念，那这就是，的确，
什么复发导致，

511
00:23:28,960 --> 00:23:31,780
但是这仅仅是多了一个有点
数学方法寻找

512
00:23:31,780 --> 00:23:36,520
在合并排序的运行时间
根据它的伪孤独。

513
00:23:36,520 --> 00:23:39,030
>> 现在，让我们有点
从所有这一切歇口气，

514
00:23:39,030 --> 00:23:41,710
看一看在
某些前参议员，谁

515
00:23:41,710 --> 00:23:44,260
可能看起来有点眼熟，
谁坐下来与谷歌的埃里克

516
00:23:44,260 --> 00:23:48,410
施密特，前一段时间，接受采访
在舞台上，在一大堆的前面

517
00:23:48,410 --> 00:23:53,710
人，谈话最终约
一个话题，那是相当熟悉的现在。

518
00:23:53,710 --> 00:23:54,575
让我们一起来看看。

519
00:23:54,575 --> 00:24:01,020

520
00:24:01,020 --> 00:24:03,890
>> 埃里克·施密特：现在参议员，
你在这里在谷歌，

521
00:24:03,890 --> 00:24:09,490
我喜欢想的
总统作为一个工作面试。

522
00:24:09,490 --> 00:24:11,712
现在很难找到一份工作作为总统。

523
00:24:11,712 --> 00:24:12,670
奥巴马：对。

524
00:24:12,670 --> 00:24:13,940
埃里克·施密特：你是
该怎么办[听不清]现在。

525
00:24:13,940 --> 00:24:15,523
它也很难找到工作，在谷歌。

526
00:24:15,523 --> 00:24:17,700
奥巴马：对。

527
00:24:17,700 --> 00:24:21,330
>> 埃里克·施密特：我们有疑问，
我们要求我们的候选人的问题，

528
00:24:21,330 --> 00:24:24,310
而这一次是从拉里·施维默。

529
00:24:24,310 --> 00:24:25,890
>> 奥巴马：好。

530
00:24:25,890 --> 00:24:27,005
>> 埃里克·施密特：什么？

531
00:24:27,005 --> 00:24:28,130
你们以为我在开玩笑？

532
00:24:28,130 --> 00:24:30,590
就是这里。

533
00:24:30,590 --> 00:24:33,490
什么是最有效的方式来
排序一百万的32位整数？

534
00:24:33,490 --> 00:24:37,560

535
00:24:37,560 --> 00:24:38,979
>> 奥巴马总统：Well--

536
00:24:38,979 --> 00:24:41,020
埃里克·施密特：有时候，
也许我很抱歉，maybe--

537
00:24:41,020 --> 00:24:42,750
奥巴马总统：不，不，
不，不，不，我think--

538
00:24:42,750 --> 00:24:43,240
埃里克·施密特：这不是它 - 

539
00:24:43,240 --> 00:24:45,430
奥巴马总统：我
想想，我觉得泡沫

540
00:24:45,430 --> 00:24:46,875
排序将是错误的路要走。

541
00:24:46,875 --> 00:24:49,619

542
00:24:49,619 --> 00:24:50,535
埃里克·施密特：来吧。

543
00:24:50,535 --> 00:24:52,200
谁告诉他的？

544
00:24:52,200 --> 00:24:54,020
行。

545
00:24:54,020 --> 00:24:55,590
我没有计算机科学on--

546
00:24:55,590 --> 00:24:58,986
>> 奥巴马：我们已经
得到了在那里我们的间谍。

547
00:24:58,986 --> 00:24:59,860
教授：好的。

548
00:24:59,860 --> 00:25:03,370
让我们后面现在离开
算法理论界

549
00:25:03,370 --> 00:25:06,520
在渐近分析
物，并返回到某些主题

550
00:25:06,520 --> 00:25:09,940
从周零和一，并开始
除去一些辅助轮，

551
00:25:09,940 --> 00:25:10,450
如果你愿意。

552
00:25:10,450 --> 00:25:13,241
让你真正了解
最终从地上爬了起来，什么是

553
00:25:13,241 --> 00:25:16,805
怎么回事引擎盖下，当你
编写，编译和执行程序。

554
00:25:16,805 --> 00:25:19,680
特别记得，这是
第一个C程序中，我们看了一下，

555
00:25:19,680 --> 00:25:22,840
一个典型的，简单的程序
不爽，相对来说，

556
00:25:22,840 --> 00:25:24,620
其中，它打印，你好世界。

557
00:25:24,620 --> 00:25:27,610
而回想一下，我说，这个过程
该源代码经过

558
00:25:27,610 --> 00:25:28,430
也正是这一点。

559
00:25:28,430 --> 00:25:31,180
你把你的源代码，通过
它通过一个编译器，像锵，

560
00:25:31,180 --> 00:25:34,650
进出自带目标代码，那
可能是这样的，零和的

561
00:25:34,650 --> 00:25:37,880
计算机的CPU，中央
处理单元或脑，

562
00:25:37,880 --> 00:25:39,760
最终可以理解的。

563
00:25:39,760 --> 00:25:42,460
>> 事实证明，这是一个
过于简单的一点，

564
00:25:42,460 --> 00:25:44,480
我们现在正处在一个
位置梳理出

565
00:25:44,480 --> 00:25:46,720
要了解什么是真正被
怎么回事引擎盖下

566
00:25:46,720 --> 00:25:48,600
每次运行时间
铛，或更一般地，

567
00:25:48,600 --> 00:25:53,040
每次你犯了一个程序，
使用make和CF 50 IDE。

568
00:25:53,040 --> 00:25:56,760
尤其是，这样的东西
这首先产生，

569
00:25:56,760 --> 00:25:58,684
当你第一次编译程序。

570
00:25:58,684 --> 00:26:00,600
换句话说，当
把你的源代码

571
00:26:00,600 --> 00:26:04,390
并编译它，什么是第一
被输出由锵

572
00:26:04,390 --> 00:26:06,370
是一些被称为汇编代码。

573
00:26:06,370 --> 00:26:08,990
而事实上，它看起来完全一样。

574
00:26:08,990 --> 00:26:11,170
>> 我在跑的命令
命令行前面。

575
00:26:11,170 --> 00:26:16,260
铛破折号大写字母S的hello.c，
这个创建的文件

576
00:26:16,260 --> 00:26:19,490
我叫hello.s，
这里面都是一模一样

577
00:26:19,490 --> 00:26:22,290
这些内容，而多了几分
上述多一点的下方，

578
00:26:22,290 --> 00:26:25,080
但我已经把最丰厚
这里，屏幕上的信息。

579
00:26:25,080 --> 00:26:29,190
如果你仔细观察，你会看到
至少有几个熟悉的关键字。

580
00:26:29,190 --> 00:26:31,330
我们主要在顶部。

581
00:26:31,330 --> 00:26:35,140
我们在中间的printf下来。

582
00:26:35,140 --> 00:26:38,670
而且我们也有世界你好
反斜杠N的报价楼下。

583
00:26:38,670 --> 00:26:42,450
>> 和其他一切在这里
是非常低的水平指示

584
00:26:42,450 --> 00:26:45,500
计算机的CPU可以理解的。

585
00:26:45,500 --> 00:26:50,090
该移动存储CPU指令
各地，从内存中加载的字符串，

586
00:26:50,090 --> 00:26:52,750
最终，打印
事情在屏幕上。

587
00:26:52,750 --> 00:26:56,780
现在发生什么事虽历经
此汇编代码生成的？

588
00:26:56,780 --> 00:26:59,964
最终，你这样做，事实上，
还是生成目标代码。

589
00:26:59,964 --> 00:27:02,630
但步骤都是真正
已经持续引擎盖下

590
00:27:02,630 --> 00:27:04,180
看起来有点像这样。

591
00:27:04,180 --> 00:27:08,390
源代码变得汇编代码，
然后变成目标代码，

592
00:27:08,390 --> 00:27:11,930
这里的工作的话是，
当您编译源代码，

593
00:27:11,930 --> 00:27:16,300
走出来的汇编代码，然后
当你组装你的汇编代码，

594
00:27:16,300 --> 00:27:17,800
出来自目标代码。

595
00:27:17,800 --> 00:27:20,360
>> 现在锵是超级复杂，
像很多的编译器，

596
00:27:20,360 --> 00:27:23,151
而且它所有这些步骤
在一起，它不一定

597
00:27:23,151 --> 00:27:25,360
输出任何中间
文件，您甚至可以看到。

598
00:27:25,360 --> 00:27:28,400
它只是编译的东西，
这是一般术语，其

599
00:27:28,400 --> 00:27:30,000
描述了整个过程。

600
00:27:30,000 --> 00:27:32,000
但是，如果你真的想
要特别地，有

601
00:27:32,000 --> 00:27:34,330
多了很多事也有。

602
00:27:34,330 --> 00:27:38,860
>> 但是，让我们现在也考虑，即使
该超级简单的程序，hello.c中，

603
00:27:38,860 --> 00:27:40,540
叫的功能。

604
00:27:40,540 --> 00:27:41,870
它呼吁printf的。

605
00:27:41,870 --> 00:27:46,900
但我没写printf的，事实上，
随C，可以这么说。

606
00:27:46,900 --> 00:27:51,139
这是一个函数调用这
在标准io.h，宣称这

607
00:27:51,139 --> 00:27:53,180
是一个头文件，它
是一个主题，我们将实际

608
00:27:53,180 --> 00:27:55,780
深入到更深入没多久。

609
00:27:55,780 --> 00:27:58,000
但是，一个头文件
通常伴随着

610
00:27:58,000 --> 00:28:02,920
由一个代码文件，源代码文件，所以
就像存在标准io.h.

611
00:28:02,920 --> 00:28:05,930
>> 不久以前，一个人，
或某人，也写

612
00:28:05,930 --> 00:28:11,040
一个称为标准io.c中，在文件
它的实际定义，

613
00:28:11,040 --> 00:28:15,220
或printf的实现，
和其他功能束，

614
00:28:15,220 --> 00:28:16,870
实际上写的。

615
00:28:16,870 --> 00:28:22,140
因此考虑到，如果我们考虑有
这里在左边，hello.c中，当

616
00:28:22,140 --> 00:28:26,250
编译后，给了我们hello.s，即使
锵不打扰保存在一个地方

617
00:28:26,250 --> 00:28:31,360
我们可以看到它，并汇编代码
被组装成hello.o，这

618
00:28:31,360 --> 00:28:34,630
确实是，默认名称
每当你编译源代码给

619
00:28:34,630 --> 00:28:39,350
编码成目标代码，但不
完全准备好执行它，

620
00:28:39,350 --> 00:28:41,460
因为又迈进了一步
必须发生，并且具有

621
00:28:41,460 --> 00:28:44,440
已经发生的事情在过去几年
周，也许不知情的你。

622
00:28:44,440 --> 00:28:47,290
>> 特别的地方
在CS50 IDE，而这一点，

623
00:28:47,290 --> 00:28:49,870
也将是一个比特的
过于简单化了一会儿，

624
00:28:49,870 --> 00:28:54,670
有，或者是很久以前，
一个称为标准io.c中的文件，

625
00:28:54,670 --> 00:28:58,440
有人编译成
标准io.s或相当于

626
00:28:58,440 --> 00:29:02,010
有人再组装
成标准io.o，

627
00:29:02,010 --> 00:29:04,600
还是原来成
稍有不同的文件

628
00:29:04,600 --> 00:29:07,220
可以有一个不同的格式
共文件扩展名，

629
00:29:07,220 --> 00:29:11,720
但在理论和概念上，正好
这些步骤必须发生某种形式。

630
00:29:11,720 --> 00:29:14,060
这就是说，现在
当我写一个程序，

631
00:29:14,060 --> 00:29:17,870
hello.c中，这只是说，你好世界，
而我使用别人的代码

632
00:29:17,870 --> 00:29:22,480
如printf，这是仙界
时间，在一个名为标准io.c中的文件，

633
00:29:22,480 --> 00:29:26,390
后来不知怎的我得把我的
目标代码，我的0和1

634
00:29:26,390 --> 00:29:29,260
而那个人的对象
代码，或0和1

635
00:29:29,260 --> 00:29:34,970
并以某种方式连接成
最后一个文件，名为hello，即

636
00:29:34,970 --> 00:29:38,070
拥有所有的零和
从我的主要功能的，

637
00:29:38,070 --> 00:29:40,830
和所有的零
和那些像printf。

638
00:29:40,830 --> 00:29:44,900
>> 事实上，这最后一道工序是
所谓，链接您的目标代码。

639
00:29:44,900 --> 00:29:47,490
它的输出
是一个可执行文件。

640
00:29:47,490 --> 00:29:49,780
因此，在公平，在
的天，没有结束

641
00:29:49,780 --> 00:29:52,660
由于一个周也改变了，当我们
刚开始编译程序。

642
00:29:52,660 --> 00:29:55,200
事实上，所有的这一直
发生在引擎盖下，

643
00:29:55,200 --> 00:29:57,241
但现在，我们正处在一个位置
在这里，我们实际上可以

644
00:29:57,241 --> 00:29:58,794
梳理出这些不同的步骤。

645
00:29:58,794 --> 00:30:00,710
事实上，在结束
这一天，我们仍然

646
00:30:00,710 --> 00:30:04,480
留下零和一，这
实际上是一个很大的SEGUE现在

647
00:30:04,480 --> 00:30:08,620
到C的另一能力，即
我们已经没有利用最有可能

648
00:30:08,620 --> 00:30:11,250
迄今为止，被称为位运算符。

649
00:30:11,250 --> 00:30:15,220
换句话说，迄今为止，任何时候我们已经
处理C或变量数据，C，

650
00:30:15,220 --> 00:30:17,660
我们已经有像
字符，可漂浮，插件

651
00:30:17,660 --> 00:30:21,990
和长和双打之类的，但
所有这些都是至少八位。

652
00:30:21,990 --> 00:30:25,550
我们从来没有能够
操纵单个位，

653
00:30:25,550 --> 00:30:28,970
即使一个人位，我们
知道，可以代表一个0和1。

654
00:30:28,970 --> 00:30:32,640
现在事实证明，在C，你
可以访问各个位，

655
00:30:32,640 --> 00:30:35,530
如果你知道的语法，
与得到他们。

656
00:30:35,530 --> 00:30:38,010
>> 因此，让我们一起来看看
在位运算符。

657
00:30:38,010 --> 00:30:41,700
所以图为几个符号
我们，那种类型的，以前见过。

658
00:30:41,700 --> 00:30:45,580
我看到一个符号，一个垂直
酒吧和其他一些为好，

659
00:30:45,580 --> 00:30:49,430
并且记得，符号与符号
是我们所见过的。

660
00:30:49,430 --> 00:30:54,060
逻辑运算符，那就是你有
他们两个人在一起，或者逻辑或

661
00:30:54,060 --> 00:30:56,300
运营商，在那里你
有两个竖条。

662
00:30:56,300 --> 00:31:00,550
位运算符，我们将
见位独立运行，

663
00:31:00,550 --> 00:31:03,810
只需使用一个符号，一个
单竖条，插入符号符号

664
00:31:03,810 --> 00:31:06,620
随之而来的，小
波浪线，然后离开

665
00:31:06,620 --> 00:31:08,990
支架左支架，或
右括号右括号。

666
00:31:08,990 --> 00:31:10,770
每个这些具有不同的含义。

667
00:31:10,770 --> 00:31:11,950
>> 事实上，让我们一起来看看。

668
00:31:11,950 --> 00:31:16,560
让我们去老同学今天和使用
从昔日的触摸屏，

669
00:31:16,560 --> 00:31:18,002
已知，为白色板。

670
00:31:18,002 --> 00:31:19,710
而这个白板
将会让我们

671
00:31:19,710 --> 00:31:27,360
发表一些相当简单的符号，
或者更确切地说，一些相当简单的公式，

672
00:31:27,360 --> 00:31:29,560
我们可以再最终
杠杆率，为了

673
00:31:29,560 --> 00:31:33,230
访问个人
在C程序位。

674
00:31:33,230 --> 00:31:34,480
换句话说，让我们做到这一点。

675
00:31:34,480 --> 00:31:37,080
让我们先谈了
矩符号，

676
00:31:37,080 --> 00:31:39,560
这是按位与运算。

677
00:31:39,560 --> 00:31:42,130
换言之，这是
运营商允许

678
00:31:42,130 --> 00:31:45,930
我有一个左手变
典型地，和一个右侧变量，

679
00:31:45,930 --> 00:31:50,640
或者一个人的价值，如果我们和
他们在一起，给了我一个最终的结果。

680
00:31:50,640 --> 00:31:51,560
所以，这是什么意思？

681
00:31:51,560 --> 00:31:54,840
如果在一个程序中，你有一个变量
这些值的商店之一，

682
00:31:54,840 --> 00:31:58,000
还是让我们保持简单，只
写出零和一独立，

683
00:31:58,000 --> 00:32:00,940
这里是如何的符号操作符。

684
00:32:00,940 --> 00:32:06,400
0符号0将等于0。

685
00:32:06,400 --> 00:32:07,210
现在，这是为什么？

686
00:32:07,210 --> 00:32:09,291
>> 这是非常相似
布尔表达式，

687
00:32:09,291 --> 00:32:10,540
我们已经迄今为止的讨论。

688
00:32:10,540 --> 00:32:15,800
如果你以后都认为，在0
假的，0是假的，假的，假的

689
00:32:15,800 --> 00:32:18,720
是，正如我们已经讨论
从逻辑上讲，也是假的。

690
00:32:18,720 --> 00:32:20,270
所以，我们得到0在这里。

691
00:32:20,270 --> 00:32:24,390
如果拿0符号
1，清楚，也一样，

692
00:32:24,390 --> 00:32:29,890
将是0，因为对于这
左手边表达式为true或1，

693
00:32:29,890 --> 00:32:32,360
这将需要真正的和真实的。

694
00:32:32,360 --> 00:32:36,320
但在这里，我们有假
而真实，或0和1。

695
00:32:36,320 --> 00:32:42,000
现在再次，如果我们有1符号
0，即，也将是0，

696
00:32:42,000 --> 00:32:47,240
如果我们有1符号1，
最后我们有一个1位。

697
00:32:47,240 --> 00:32:50,340
因此，换句话说，我们没有做
什么有趣的与该运营商

698
00:32:50,340 --> 00:32:51,850
只是还没有，这个符号运算符。

699
00:32:51,850 --> 00:32:53,780
这是按位与运算。

700
00:32:53,780 --> 00:32:57,290
但这些成分
通过它，我们可以做的

701
00:32:57,290 --> 00:32:59,240
有趣的事情，因为我们很快就会看到。

702
00:32:59,240 --> 00:33:02,790
>> 现在，让我们来看看刚才单
竖条在这里就对了。

703
00:33:02,790 --> 00:33:06,710
如果我有一个0位和我
或用，按位

704
00:33:06,710 --> 00:33:11,030
OR运算符，另一0位，
这是怎么回事，给我0。

705
00:33:11,030 --> 00:33:17,540
如果我把一个0位和或用
1位，那么我会得到1。

706
00:33:17,540 --> 00:33:19,830
而事实上，只是
清晰，让我回去，

707
00:33:19,830 --> 00:33:23,380
所以，我的竖线
不能误认为是1的。

708
00:33:23,380 --> 00:33:26,560
让我重写所有的
我1是多一点

709
00:33:26,560 --> 00:33:32,700
显然，让我们接下来看，如果我
有个1或0，这将是一个1，

710
00:33:32,700 --> 00:33:39,060
如果我有1或1中，
也将是一个1。

711
00:33:39,060 --> 00:33:42,900
所以，你可以在逻辑上看到或
经营者的行为非常不同。

712
00:33:42,900 --> 00:33:48,070
这给了我0或0给了我0，但是
所有其他的组合给了我1。

713
00:33:48,070 --> 00:33:52,480
只要我有一个1的
式，其结果将是1。

714
00:33:52,480 --> 00:33:55,580
>> 通过与和对比度
运营商的符号，

715
00:33:55,580 --> 00:34:00,940
只有当我有两个1的中
方程，我居然得到1了。

716
00:34:00,940 --> 00:34:02,850
现在有一些其他的
运营商也是如此。

717
00:34:02,850 --> 00:34:04,810
其中之一是一个涉及多一点。

718
00:34:04,810 --> 00:34:07,980
因此，让我继续前进，抹去
此释放一些空间。

719
00:34:07,980 --> 00:34:13,020

720
00:34:13,020 --> 00:34:16,460
而让我们一起来看看
插入符号符号，只是一瞬间。

721
00:34:16,460 --> 00:34:18,210
这通常是一个
字符，你可以键入

722
00:34:18,210 --> 00:34:21,420
在键盘按住Shift
再一个你顶上美国的数字

723
00:34:21,420 --> 00:34:22,250
键盘。

724
00:34:22,250 --> 00:34:26,190
>> 因此，这是独家
OR运算，异或。

725
00:34:26,190 --> 00:34:27,790
所以，我们刚才看到的或经营人。

726
00:34:27,790 --> 00:34:29,348
这是异或运算符。

727
00:34:29,348 --> 00:34:30,639
什么是真正的区别是什么？

728
00:34:30,639 --> 00:34:34,570
那么就让我们来看看公式，
并以此作为最终的成分。

729
00:34:34,570 --> 00:34:37,690
0 XOR 0。

730
00:34:37,690 --> 00:34:39,650
我要说的是始终为0。

731
00:34:39,650 --> 00:34:41,400
这是异或的定义。

732
00:34:41,400 --> 00:34:47,104
0 XOR 1将是1。

733
00:34:47,104 --> 00:34:58,810
1异或0将是1，
1 XOR 1将是？

734
00:34:58,810 --> 00:34:59,890
错了吗？

735
00:34:59,890 --> 00:35:00,520
还是向右？

736
00:35:00,520 --> 00:35:01,860
我不知道。

737
00:35:01,860 --> 00:35:02,810
0。

738
00:35:02,810 --> 00:35:04,700
现在到底是怎么回事吗？

739
00:35:04,700 --> 00:35:06,630
那么想想
该运营商的名称。

740
00:35:06,630 --> 00:35:09,980
异或，以便在
名种，顾名思义，

741
00:35:09,980 --> 00:35:13,940
的回答为仅将是
1，如果输入是排他性的，

742
00:35:13,940 --> 00:35:15,560
完全不同。

743
00:35:15,560 --> 00:35:18,170
因此，这里的输入是
相同的，所以输出为0。

744
00:35:18,170 --> 00:35:20,700
这里的输入是
相同的，所以输出为0。

745
00:35:20,700 --> 00:35:25,640
下面是输出不同，它们
是互斥的，所以输出1。

746
00:35:25,640 --> 00:35:28,190
所以这是非常相似的
而且，它是非常相似的，

747
00:35:28,190 --> 00:35:32,760
或者更确切地说，它是非常相似
或者，但只在专用方式。

748
00:35:32,760 --> 00:35:36,210
这一个不再是1，
因为我们有两个1的，

749
00:35:36,210 --> 00:35:38,621
而不是排他地，它们中的一个。

750
00:35:38,621 --> 00:35:39,120
好吧。

751
00:35:39,120 --> 00:35:40,080
怎么样的人？

752
00:35:40,080 --> 00:35:44,220
好了波浪线，同时，
其实不错，简单，谢天谢地。

753
00:35:44,220 --> 00:35:46,410
这是一个一元
操作者，这意味着

754
00:35:46,410 --> 00:35:50,400
它仅施加到一个输入端，
一个操作数，可以这么说。

755
00:35:50,400 --> 00:35:51,800
不为左和右。

756
00:35:51,800 --> 00:35:56,050
换句话说，如果你采取的波浪线
0，答案会是相反的。

757
00:35:56,050 --> 00:35:59,710
如果你把波浪的1，
答案会有相反。

758
00:35:59,710 --> 00:36:02,570
所以波浪线操作员
某种程度上否定了一下，

759
00:36:02,570 --> 00:36:06,000
或者翻转位来自
0至1或1至0。

760
00:36:06,000 --> 00:36:09,820
>> 这使我们最终
只有最后两运营商，

761
00:36:09,820 --> 00:36:13,840
所谓左移位，而
所谓向右移位运算符。

762
00:36:13,840 --> 00:36:16,620
让我们来看看如何将这些工作。

763
00:36:16,620 --> 00:36:20,780
左移位运算符，写
有两个尖括号这样，

764
00:36:20,780 --> 00:36:22,110
操作如下。

765
00:36:22,110 --> 00:36:27,390
如果我的输入，还是我操作，向左
移位运算符是很简单1。

766
00:36:27,390 --> 00:36:33,750
我再告诉电脑
左移说明1，说七宿，

767
00:36:33,750 --> 00:36:37,150
其结果是，好像我
采取1，并移动

768
00:36:37,150 --> 00:36:40,160
七宿转移到
左，默认情况下，

769
00:36:40,160 --> 00:36:42,270
我们将假设
的空间权

770
00:36:42,270 --> 00:36:44,080
打算用零填充。

771
00:36:44,080 --> 00:36:50,316
换句话说，1左移7是要
给我一个1，其次是1，2，3，

772
00:36:50,316 --> 00:36:54,060
4，5，6，7个零。

773
00:36:54,060 --> 00:36:57,380
因此，在某种程度上，它可以让你
取少量像1，

774
00:36:57,380 --> 00:37:00,740
并明确使它更
多，在这种方式大得多，

775
00:37:00,740 --> 00:37:06,460
但我们真的要见
更聪明的办法吧

776
00:37:06,460 --> 00:37:08,080
相反，还有，

777
00:37:08,080 --> 00:37:08,720
>> 好吧。

778
00:37:08,720 --> 00:37:10,060
这就是它了三个星期

779
00:37:10,060 --> 00:37:11,400
我们会看到你下一次。

780
00:37:11,400 --> 00:37:12,770
这是CS50。

781
00:37:12,770 --> 00:37:17,270

782
00:37:17,270 --> 00:37:22,243
>> [音乐播放]

783
00:37:22,243 --> 00:37:25,766
>> 扬声器1：他是在小吃
酒吧吃热软糖圣代。

784
00:37:25,766 --> 00:37:28,090
他拥有了一切在他的脸上。

785
00:37:28,090 --> 00:37:30,506
他穿着巧克力像胡子

786
00:37:30,506 --> 00:37:31,756
扬声器2：你在做什么？

787
00:37:31,756 --> 00:37:32,422
扬声器3：嗯？

788
00:37:32,422 --> 00:37:33,500
什么？

789
00:37:33,500 --> 00:37:36,800
>> 扬声器2：您刚才二次探底？

790
00:37:36,800 --> 00:37:38,585
你双跌的芯片。

791
00:37:38,585 --> 00:37:39,460
扬声器3：对不起。

792
00:37:39,460 --> 00:37:44,440
扬声器2：你蘸了芯片，
咬了一口，并再次下跌。

793
00:37:44,440 --> 00:37:44,940
扬声器3：

794
00:37:44,940 --> 00:37:48,440
扬声器2：所以，这就像把
你的整个嘴就在畅游。

795
00:37:48,440 --> 00:37:52,400
下一次你把一个芯片，
只是沾了一次，并结束它。

796
00:37:52,400 --> 00:37:53,890
>> 扬声器3：你知道吗，丹？

797
00:37:53,890 --> 00:37:58,006
你沾要沾的方式。

798
00:37:58,006 --> 00:38:01,900
我会沾，我要沾的方式。

799
00:38:01,900 --> 00:38:03,194