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