1
00:00:00,000 --> 00:00:03,332
>> [音樂播放]

2
00:00:03,332 --> 00:00:06,490
>> ANDI鵬：歡迎來到第3個星期

3
00:00:06,490 --> 00:00:09,550
謝謝你們，所有的未來
到今天這個較早的開始時間。

4
00:00:09,550 --> 00:00:11,466
我們已經有了一個很好的，小
今天的親密組。

5
00:00:11,466 --> 00:00:14,570
所以希望我們會得到
說完，或許，早，

6
00:00:14,570 --> 00:00:15,780
一點點今天一早。

7
00:00:15,780 --> 00:00:22,057
那麼快，只是一些
今天議程公告。

8
00:00:22,057 --> 00:00:23,890
在我們開始之前，我們
要只走了過來

9
00:00:23,890 --> 00:00:28,910
一些簡單的後勤問題，PSET
題，匯報，這樣的事情。

10
00:00:28,910 --> 00:00:30,250
然後，我們將深入權利英寸

11
00:00:30,250 --> 00:00:34,710
我們將使用一個名為GDB來調試程序
啟動揭穿我們的代碼，大衛

12
00:00:34,710 --> 00:00:36,550
有一天在課堂解釋。

13
00:00:36,550 --> 00:00:39,420
我們就去了四種類型的排序。

14
00:00:39,420 --> 00:00:42,310
我們會去超過他們很快
因為他們非常密集。

15
00:00:42,310 --> 00:00:45,710
但是要知道，所有的幻燈片和
源代碼是永遠在線。

16
00:00:45,710 --> 00:00:50,810
所以感到自由，在你細讀，以
回去看看那個。

17
00:00:50,810 --> 00:00:53,930
>> 我們將通過
漸近符號，這

18
00:00:53,930 --> 00:00:55,944
僅僅是一個奇特的方式
說“運行時間”

19
00:00:55,944 --> 00:00:58,360
在這裡，我們有大O，從而
大衛在演講解釋。

20
00:00:58,360 --> 00:01:01,550
而且我們也有歐米茄，這
是下界運行時。

21
00:01:01,550 --> 00:01:06,450
我們將討論多一點
深入的關於如何將這些工作。

22
00:01:06,450 --> 00:01:10,160
最後，我們就去了二進制搜索，
因為很多你誰已經

23
00:01:10,160 --> 00:01:15,190
看了一眼你的pset便知
這是一個問題，在你的pset中。

24
00:01:15,190 --> 00:01:17,470
所以，你都會很高興
我們管這個今天。

25
00:01:17,470 --> 00:01:20,610
>> 最後，根據您的
部分反饋意見，其實我

26
00:01:20,610 --> 00:01:23,000
在離開約15分鐘
年底剛剛走了過來

27
00:01:23,000 --> 00:01:27,730
pset3物流，如有問題，
也許有點指導，如果你願意，

28
00:01:27,730 --> 00:01:28,990
我們開始編程了。

29
00:01:28,990 --> 00:01:30,890
因此，讓我們試著打通
該材料很快。

30
00:01:30,890 --> 00:01:33,880
然後我們就可以花一些時間
同時為處理器集更多的問題。

31
00:01:33,880 --> 00:01:35,230
確定。

32
00:01:35,230 --> 00:01:39,570
>> 很快，所以只是少數
我們之前宣布從今天開始。

33
00:01:39,570 --> 00:01:45,410
首先，歡迎來製作
它通過兩個你的pset中。

34
00:01:45,410 --> 00:01:49,432
我看了看your--是啊，讓我們
獲得掌聲的那一個。

35
00:01:49,432 --> 00:01:51,140
其實，我是真的，
真的很感動。

36
00:01:51,140 --> 00:01:55,800
我分級的第一個PSET為你們
上週，你們做了令人難以置信的。

37
00:01:55,800 --> 00:01:58,290
>> 風格是在點
除了一些意見。

38
00:01:58,290 --> 00:02:00,660
請確保你總是
註釋你的代碼。

39
00:02:00,660 --> 00:02:03,040
但是，你的pset中都點上。

40
00:02:03,040 --> 00:02:05,549
並保持了起來。

41
00:02:05,549 --> 00:02:08,090
而且它的良好的平地機到
看到你們是把

42
00:02:08,090 --> 00:02:10,704
在你的風格盡可能多的努力
和你在你的代碼設計

43
00:02:10,704 --> 00:02:12,120
我們想給你看。

44
00:02:12,120 --> 00:02:16,450
所以我路過沿著我的謝意
為助教的其餘部分。

45
00:02:16,450 --> 00:02:19,210
>> 然而，有一個
一些匯報的問題

46
00:02:19,210 --> 00:02:22,010
我只是想說明一下
可使兩個我的生活

47
00:02:22,010 --> 00:02:24,900
和許多其它的
助教的生活更容易一點。

48
00:02:24,900 --> 00:02:28,220
首先，我注意到這個
過去week--你們有多少人

49
00:02:28,220 --> 00:02:32,301
已經運行check50
在你的代碼提交？

50
00:02:32,301 --> 00:02:32,800
確定。

51
00:02:32,800 --> 00:02:36,690
所以每個人都應該做的check50，
因為 - 一個secret--我們實際上

52
00:02:36,690 --> 00:02:41,540
運行check50作為我們的正確性的一部分
腳本測試代碼。

53
00:02:41,540 --> 00:02:45,480
所以，如果你的代碼是失敗的
check50，在所有的可能性，

54
00:02:45,480 --> 00:02:47,570
它可能會
失敗我們檢查為好。

55
00:02:47,570 --> 00:02:49,320
有時候你們
有正確的答案。

56
00:02:49,320 --> 00:02:52,200
像，在貪婪的，一些
你有正確的號碼，

57
00:02:52,200 --> 00:02:53,960
你只需打印出一些額外的東西。

58
00:02:53,960 --> 00:02:55,940
而這額外的東西
實際上未通過檢查，

59
00:02:55,940 --> 00:02:58,440
因為電腦不
真的知道它在尋找。

60
00:02:58,440 --> 00:03:00,981
因此，這將只運行通過，
看到你的輸出不

61
00:03:00,981 --> 00:03:03,810
符合我們所期待的答​​案
要，並註明這是錯誤的。

62
00:03:03,810 --> 00:03:06,560
>> 我知道，發生在
你的一些情況下，這個星期。

63
00:03:06,560 --> 00:03:09,870
所以，我回去和手動
regraded每個人的代碼。

64
00:03:09,870 --> 00:03:12,780
在未來雖然，
請，請確保

65
00:03:12,780 --> 00:03:14,570
你正在運行
在你的代碼檢查50。

66
00:03:14,570 --> 00:03:17,970
因為它是一種為TA疼痛
不得不回去手動再分類

67
00:03:17,970 --> 00:03:21,197
每一個每一個PSET
單，很少錯過實例。

68
00:03:21,197 --> 00:03:22,530
所以，我沒有脫任何積分。

69
00:03:22,530 --> 00:03:25,210
我想，我脫下也許
的一個或兩個用於設計。

70
00:03:25,210 --> 00:03:27,710
在未來雖然，如果
你失敗check50，

71
00:03:27,710 --> 00:03:31,330
點將會採取
關閉正確性。

72
00:03:31,330 --> 00:03:35,020
>> 此外，pset中是
由於週五中午。

73
00:03:35,020 --> 00:03:38,990
我覺得有一個7分鐘
我們給你遲到寬限期。

74
00:03:38,990 --> 00:03:42,434
每哈佛的時候，他們獲准
為7分鐘遲到的一切。

75
00:03:42,434 --> 00:03:44,350
因此，這裡在耶魯，我們將
堅持這一點。

76
00:03:44,350 --> 00:03:47,910
但相當多，在12:07，
如果你的PSET不在，

77
00:03:47,910 --> 00:03:49,720
這將是為後期標記。

78
00:03:49,720 --> 00:03:53,160
因此，雖然它被標記為
為末，TA--我

79
00:03:53,160 --> 00:03:54,870
還是會被分級您的pset。

80
00:03:54,870 --> 00:03:56,760
所以，你仍然會看到一個檔次的出現。

81
00:03:56,760 --> 00:03:58,820
但是，要知道，在
學期結束時，

82
00:03:58,820 --> 00:04:02,270
所有後期的pset將只是
由計算機自動歸零。

83
00:04:02,270 --> 00:04:04,490
>> 我們這樣做有兩個原因。

84
00:04:04,490 --> 00:04:09,220
其中，有時我們得到
原諒，就像院長的藉口，

85
00:04:09,220 --> 00:04:10,762
後來，我不知道呢。

86
00:04:10,762 --> 00:04:13,761
因此，我們希望確保我們分級
一切都為了以防萬一，比如，我

87
00:04:13,761 --> 00:04:15,080
缺少院長的藉口。

88
00:04:15,080 --> 00:04:17,000
其次，要
心中，你仍然可以

89
00:04:17,000 --> 00:04:19,370
摔個PSET的
有完整的範圍點。

90
00:04:19,370 --> 00:04:21,430
因此，我們要分級
所有的pset只是

91
00:04:21,430 --> 00:04:24,730
以確保您的範圍的
那裡，你想他們。

92
00:04:24,730 --> 00:04:29,150
因此，即使是晚了，你還是會
獲得信貸的範圍點，我想。

93
00:04:29,150 --> 00:04:33,730
>> 因此，道德的故事，使
確保你的pset是導通時間。

94
00:04:33,730 --> 00:04:38,350
並且如果它們不是在導通時間，
知道這是不是很大。

95
00:04:38,350 --> 00:04:41,678
是啊，在我繼續前進，沒有任何人有
有關PSET反饋有任何疑問？

96
00:04:41,678 --> 00:04:42,178
是啊。

97
00:04:42,178 --> 00:04:43,630
>> 聽眾：你是說，我們
可以去掉的pset之一？

98
00:04:43,630 --> 00:04:44,296
>> ANDI彭：是的。

99
00:04:44,296 --> 00:04:47,050
因此，有九pset中整體
在這學期的課程。

100
00:04:47,050 --> 00:04:50,610
如果你有範圍
points--因此範圍是正義的，

101
00:04:50,610 --> 00:04:53,567
相當多，你嘗試了
問題是，你投入的時間，

102
00:04:53,567 --> 00:04:56,150
你表明你已經
表明您已經閱讀了規範。

103
00:04:56,150 --> 00:04:57,191
這是相當多的範圍。

104
00:04:57,191 --> 00:04:59,370
如果你正在履行
範圍點，我們

105
00:04:59,370 --> 00:05:03,360
可以降最低
一出的全部範圍。

106
00:05:03,360 --> 00:05:06,790
所以這是你的優勢，
完成並想盡一切PSET。

107
00:05:06,790 --> 00:05:10,320
>> 即使upload--如果沒有
他們的工作，快點上傳所有。

108
00:05:10,320 --> 00:05:13,711
然後我們就希望能夠
給你一些這些點回來。

109
00:05:13,711 --> 00:05:14,210
酷。

110
00:05:14,210 --> 00:05:16,780
其他問題嗎？

111
00:05:16,780 --> 00:05:17,840
太好了。

112
00:05:17,840 --> 00:05:21,960
>> 其次，辦公hours--數
有關辦公時間快速筆記。

113
00:05:21,960 --> 00:05:24,300
因此，首先，走在了本週初。

114
00:05:24,300 --> 00:05:26,909
沒有人是曾經在
辦公時間週一休息。

115
00:05:26,909 --> 00:05:28,700
Christabel來到
昨晚辦公時間。

116
00:05:28,700 --> 00:05:29,691
是啊，Christabel。

117
00:05:29,691 --> 00:05:32,190
和我們有在辦公室什麼
小時昨晚，Christabel？

118
00:05:32,190 --> 00:05:33,020
>> 聽眾：我們有冰淇淋。

119
00:05:33,020 --> 00:05:36,160
>> ANDI彭：所以這是正確的，我們有
冰淇淋辦公時間昨晚。

120
00:05:36,160 --> 00:05:39,390
雖然我不能答應你，
我們將有冰淇淋辦公時間

121
00:05:39,390 --> 00:05:43,230
每個星期，我可以向你保證
的是，將有顯著

122
00:05:43,230 --> 00:05:45,380
更好的學生到TA的比例。

123
00:05:45,380 --> 00:05:47,650
像合法的，就好像是三比一。

124
00:05:47,650 --> 00:05:50,350
然而，對比，與
週四你有大約150

125
00:05:50,350 --> 00:05:52,830
真正強調的孩子和沒有冰淇淋。

126
00:05:52,830 --> 00:05:55,360
而且它只是沒有生產任何人。

127
00:05:55,360 --> 00:05:58,730
所以這個故事的寓意是，來得早
在辦公時間，辦好事

128
00:05:58,730 --> 00:06:00,310
會發生。

129
00:06:00,310 --> 00:06:02,110
>> 此外，有備而來提問。

130
00:06:02,110 --> 00:06:03,200
你知道嗎？

131
00:06:03,200 --> 00:06:05,420
不管什麼助教，我
想，一直在說，

132
00:06:05,420 --> 00:06:10,710
我們已經獲得一對學生情侶
誰在週四進來的一樣，10:50

133
00:06:10,710 --> 00:06:15,100
不看了規範
是一樣幫助我，幫助我。

134
00:06:15,100 --> 00:06:18,200
不幸的是，在這一點上，還有
沒有多少，我們可以做些什麼來幫助你。

135
00:06:18,200 --> 00:06:19,590
所以，請進來本週初。

136
00:06:19,590 --> 00:06:22,040
來得早在辦公時間。

137
00:06:22,040 --> 00:06:23,350
有備而來的提問。

138
00:06:23,350 --> 00:06:25,310
請確保您作為
一個學生，都在那裡

139
00:06:25,310 --> 00:06:27,620
你必須使得
助教可以引導你前進，

140
00:06:27,620 --> 00:06:32,850
這正是辦公時間
應分配的。

141
00:06:32,850 --> 00:06:37,380
>> 其次，所以我知道教授
喜歡我們測試的驚喜。

142
00:06:37,380 --> 00:06:39,439
我有一個教授的
像喲，順便說一下，

143
00:06:39,439 --> 00:06:41,230
請記住，中期
你下週一。

144
00:06:41,230 --> 00:06:42,855
是啊，我不知道是中期。

145
00:06:42,855 --> 00:06:45,630
所以我將是那個TA
提醒大家，測驗

146
00:06:45,630 --> 00:06:47,270
0--因為，你知道，我們是CS。

147
00:06:47,270 --> 00:06:50,730
現在，我們已經做了數組，你會得到
為什麼它的測驗0，沒有測驗1，是嗎？

148
00:06:50,730 --> 00:06:51,320
確定。

149
00:06:51,320 --> 00:06:52,490
呵呵，我得到了一個有些笑。

150
00:06:52,490 --> 00:06:53,120
確定。

151
00:06:53,120 --> 00:06:59,710
>> 因此，測驗0將是10月14日，如果
你在週一至週三節

152
00:06:59,710 --> 00:07:02,920
而10月15日，如果你在
週二至週四部分。

153
00:07:02,920 --> 00:07:05,630
這不適用於
那些你在哈佛

154
00:07:05,630 --> 00:07:10,350
who--我想你會都是
以14號的測驗。

155
00:07:10,350 --> 00:07:13,560
>> 所以呀，在下週，如果
大衛在演講中，雲，

156
00:07:13,560 --> 00:07:15,747
是啊，所以有關
競猜下週，大家

157
00:07:15,747 --> 00:07:17,580
將不會因為震驚
您來第

158
00:07:17,580 --> 00:07:19,664
你知道你的
測驗0是在兩個星期。

159
00:07:19,664 --> 00:07:21,580
而且我們必須檢討
會議和一切。

160
00:07:21,580 --> 00:07:26,360
所以不愁
被嚇到了點。

161
00:07:26,360 --> 00:07:29,890
如有任何疑問before--任何疑問
在所有有關的後勤問題，

162
00:07:29,890 --> 00:07:32,591
分級，辦公時間，部分？

163
00:07:32,591 --> 00:07:33,090
是啊。

164
00:07:33,090 --> 00:07:35,100
>> 聽眾：所以小測驗
將要演講期間？

165
00:07:35,100 --> 00:07:35,766
>> ANDI彭：是的。

166
00:07:35,766 --> 00:07:39,460
所以測驗，我想，是60
分配在時隙分鐘

167
00:07:39,460 --> 00:07:42,240
你會只拿
在報告廳。

168
00:07:42,240 --> 00:07:44,810
所以，你不必進來
上一樣，隨機下午7:00。

169
00:07:44,810 --> 00:07:46,140
這一切都很好。

170
00:07:46,140 --> 00:07:47,100
是啊。

171
00:07:47,100 --> 00:07:50,060
酷。

172
00:07:50,060 --> 00:07:50,840
>> 好的。

173
00:07:50,840 --> 00:07:54,330
所以，我們要
介紹一個概念，你

174
00:07:54,330 --> 00:08:00,760
本週大衛早已種
這個過去一周觸及的講座。

175
00:08:00,760 --> 00:08:02,010
這就是所謂的GDB。

176
00:08:02,010 --> 00:08:05,570
你們有多少人而且，當
寫你的pset的過程中，

177
00:08:05,570 --> 00:08:09,981
已經注意到一個很大的按鈕，上面寫著
在您的IDE頂部的“調試”？

178
00:08:09,981 --> 00:08:10,480
確定。

179
00:08:10,480 --> 00:08:13,770
所以，現在，我們將真正得到挖掘
其實什麼按鈕的奧秘

180
00:08:13,770 --> 00:08:14,270
確實。

181
00:08:14,270 --> 00:08:16,790
我向你保證，這是一個
美麗的，美麗的東西。

182
00:08:16,790 --> 00:08:20,740
>> 所以到現在為止，我覺得
還有的是兩件事情

183
00:08:20,740 --> 00:08:23,320
學生已通常
調試的pset在做。

184
00:08:23,320 --> 00:08:27,635
一，他們要么加入
printf（）的 - 所以每幾行字，

185
00:08:27,635 --> 00:08:29,760
他們加入一個printf（） - 
哦，這是什麼變量？

186
00:08:29,760 --> 00:08:32,551
哦，這是什麼變量now--
樣的，你會看到進展

187
00:08:32,551 --> 00:08:33,940
你的代碼，因為它運行。

188
00:08:33,940 --> 00:08:37,030
或者第二種方法孩子們做的是
他們只寫了整個事情

189
00:08:37,030 --> 00:08:38,610
然後轉到這樣在末端。

190
00:08:38,610 --> 00:08:39,970
希望它的工作原理。

191
00:08:39,970 --> 00:08:44,851
我向你保證，GDB更好
比兩者的那些方法。

192
00:08:44,851 --> 00:08:45,350
是啊。

193
00:08:45,350 --> 00:08:46,980
因此，這將是你最好的朋友。

194
00:08:46,980 --> 00:08:51,780
因為它是一個美麗的東西
在視覺上同時顯示

195
00:08:51,780 --> 00:08:54,850
你的代碼做
在特定點

196
00:08:54,850 --> 00:08:57,486
以及所有的你的
變量都在進行，

197
00:08:57,486 --> 00:08:59,610
喜歡什麼他們的價值觀，
在該特定的點。

198
00:08:59,610 --> 00:09:02,670
而這樣一來，你才能真正
設置在代碼中的斷點。

199
00:09:02,670 --> 00:09:04,350
您可以通過一行一行地運行。

200
00:09:04,350 --> 00:09:07,324
和GDB只會有
您，向您顯示，

201
00:09:07,324 --> 00:09:09,490
什麼你所有的變量
是，他們在做什麼，

202
00:09:09,490 --> 00:09:10,656
這是怎麼回事代碼。

203
00:09:10,656 --> 00:09:13,240
並且在這樣的方式，它的
所以更容易看到

204
00:09:13,240 --> 00:09:17,120
發生了什麼的printf的-ING代替
或寫下你的陳述。

205
00:09:17,120 --> 00:09:19,160
>> 所以我們會做後面的一個例子。

206
00:09:19,160 --> 00:09:20,660
因此，這似乎有點抽象。

207
00:09:20,660 --> 00:09:23,490
不用擔心，我們會做的例子。

208
00:09:23,490 --> 00:09:29,170
所以本質上，三個最大的，
最常用的功能，你需要在GDB

209
00:09:29,170 --> 00:09:32,500
是接下來，步過，
而步入按鈕。

210
00:09:32,500 --> 00:09:34,860
我將頭以上
在那裡，其實，就是現在。

211
00:09:34,860 --> 00:09:40,930
>> 所以你們可以都看到，
或者我應該放大一點？

212
00:09:40,930 --> 00:09:43,220

213
00:09:43,220 --> 00:09:44,470
在後面，你能看到嗎？

214
00:09:44,470 --> 00:09:45,730
我應該放大？

215
00:09:45,730 --> 00:09:46,480
只是一點點？

216
00:09:46,480 --> 00:09:49,390
OK，涼。

217
00:09:49,390 --> 00:09:50,280
在那裡，我們走了。

218
00:09:50,280 --> 00:09:50,960
確定。

219
00:09:50,960 --> 00:09:57,000
>> 所以我在這裡，我
實現貪婪。

220
00:09:57,000 --> 00:10:01,430
雖然很多你們的寫
貪婪form--，雖然環

221
00:10:01,430 --> 00:10:04,890
是一種完全可以接受的方式做
它 - 另一種方式來做到這一點是根本

222
00:10:04,890 --> 00:10:06,280
在分模。

223
00:10:06,280 --> 00:10:09,290
因為那樣的話，你可以有你
值，然後讓你的其餘部分。

224
00:10:09,290 --> 00:10:11,150
然後你可以只
加上它一起。

225
00:10:11,150 --> 00:10:13,390
請問對我在做什麼邏輯
這裡是有意義的每一個人，

226
00:10:13,390 --> 00:10:14,117
之前我們開始？

227
00:10:14,117 --> 00:10:16,760

228
00:10:16,760 --> 00:10:17,980
樣的？

229
00:10:17,980 --> 00:10:18,710
酷。

230
00:10:18,710 --> 00:10:19,210
太好了。

231
00:10:19,210 --> 00:10:21,290
這是一個非常性感的一塊
的代碼，我會說。

232
00:10:21,290 --> 00:10:23,502
就像我說的，大衛，在
講課，過了一段時間，

233
00:10:23,502 --> 00:10:25,960
你們都開始看到的代碼
作為東西是美麗的。

234
00:10:25,960 --> 00:10:29,950
有時，當你看到漂亮
代碼，它是這樣一個美妙的感覺。

235
00:10:29,950 --> 00:10:35,410
>> 因此然而，儘管這個代碼是非常
美麗的，它不能正常工作。

236
00:10:35,410 --> 00:10:37,750
因此，讓我們在這個運行check50。

237
00:10:37,750 --> 00:10:39,440
檢查50 20--空中接力。

238
00:10:39,440 --> 00:10:43,221

239
00:10:43,221 --> 00:10:43,720
2？

240
00:10:43,720 --> 00:10:44,990
那是pset2？

241
00:10:44,990 --> 00:10:46,870
是啊。

242
00:10:46,870 --> 00:10:47,520
哦，PSET1。

243
00:10:47,520 --> 00:10:50,970

244
00:10:50,970 --> 00:10:52,890
確定。

245
00:10:52,890 --> 00:10:53,900
所以我們運行check50。

246
00:10:53,900 --> 00:11:01,550

247
00:11:01,550 --> 00:11:07,170
>> 正如你們所看到的，
它的失敗一對夫婦的案件。

248
00:11:07,170 --> 00:11:10,165
而對於一些你，在
做你的問題集的過程中，

249
00:11:10,165 --> 00:11:11,110
你喜歡啊，為什麼不工作。

250
00:11:11,110 --> 00:11:13,318
為什麼工作一段
值，而不是為別人？

251
00:11:13,318 --> 00:11:17,760
那麼，GDB是要幫助你的身影
為什麼這些投入並沒有工作。

252
00:11:17,760 --> 00:11:18,320
>> 確定。

253
00:11:18,320 --> 00:11:21,640
所以，讓我們來看看，之一
檢查我是失敗的check50

254
00:11:21,640 --> 00:11:24,920
為0.41的輸入值。

255
00:11:24,920 --> 00:11:27,830
所以正確答案
你應該得到一個4。

256
00:11:27,830 --> 00:11:33,090
而是我所打印出
是3-n中，這是不正確。

257
00:11:33,090 --> 00:11:36,190
因此，讓我們只是手動運行它，只是
確保check50正常工作。

258
00:11:36,190 --> 00:11:36,940
讓我們做./greedy。

259
00:11:36,940 --> 00:11:40,130

260
00:11:40,130 --> 00:11:43,340
哎呀，我一定要貪婪。

261
00:11:43,340 --> 00:11:43,840
在那裡，我們走了。

262
00:11:43,840 --> 00:11:44,381
現在./greedy。

263
00:11:44,381 --> 00:11:46,950

264
00:11:46,950 --> 00:11:47,670
>> 多少錢是欠？

265
00:11:47,670 --> 00:11:49,550
讓我們做0.41。

266
00:11:49,550 --> 00:11:52,590
而且是的，我們在這裡看到
，它的輸出3

267
00:11:52,590 --> 00:11:55,160
當正確的答案，
事實上，應為4。

268
00:11:55,160 --> 00:12:01,460
因此，讓我們進入GDB，看看我們如何
可以去解決這個問題。

269
00:12:01,460 --> 00:12:03,992
>> 因此在第一步驟中
一直調試代碼

270
00:12:03,992 --> 00:12:05,950
是設置一個斷點，
或在這一點，你

271
00:12:05,950 --> 00:12:09,079
希望計算機或
調試器開始尋找。

272
00:12:09,079 --> 00:12:11,120
所以，如果你真的不
知道你的問題是什麼，

273
00:12:11,120 --> 00:12:14,670
通常情況下，一般的事情，我們要
做的是設置了斷點為主。

274
00:12:14,670 --> 00:12:18,520
所以，如果你們可以看到這
紅色按鈕就在那裡，

275
00:12:18,520 --> 00:12:22,860
是的，這是我的設置
斷點的主要功能。

276
00:12:22,860 --> 00:12:24,130
我點擊了。

277
00:12:24,130 --> 00:12:26,130
>> 然後我就可以去了我的Debug按鈕。

278
00:12:26,130 --> 00:12:27,036
我打那個按鈕。

279
00:12:27,036 --> 00:12:31,710

280
00:12:31,710 --> 00:12:36,555
讓我放大了，如果我能。

281
00:12:36,555 --> 00:12:38,020
在那裡，我們走了。

282
00:12:38,020 --> 00:12:40,730
因此，我們有，在這裡，在面板上的權利。

283
00:12:40,730 --> 00:12:43,680
我很抱歉，伙計們在後面，你
實在看不出真的很好。

284
00:12:43,680 --> 00:12:49,090
但本質上，所有的
該右側面板做

285
00:12:49,090 --> 00:12:53,130
被跟踪的兩個突出
線，這是代碼行

286
00:12:53,130 --> 00:12:56,640
計算機正在運行，
以及所有的變量

287
00:12:56,640 --> 00:12:57,600
到這裡。

288
00:12:57,600 --> 00:13:00,487
>> 所以，你有美分，硬幣，N，
所有申報不同的東西

289
00:13:00,487 --> 00:13:01,070
在這一點上。

290
00:13:01,070 --> 00:13:04,850
不用擔心，因為我們沒有真正
它們初始化的變量呢。

291
00:13:04,850 --> 00:13:07,200
因此，在你的電腦，你
電腦只是看到，

292
00:13:07,200 --> 00:13:14,376
哦，32767是最後使用的功能
在我的電腦的內存空間。

293
00:13:14,376 --> 00:13:16,000
所以這就是美分是目前。

294
00:13:16,000 --> 00:13:19,360
但是，沒有，一旦運行該代碼，
它應該成為初始化。

295
00:13:19,360 --> 00:13:24,110
>> 因此，讓我們通過，一行
行，這是怎麼回事的。

296
00:13:24,110 --> 00:13:25,350
確定。

297
00:13:25,350 --> 00:13:29,400
所以，在這裡是三個
按鈕，我剛才解釋。

298
00:13:29,400 --> 00:13:34,090
你有玩，或者運行功能，
按鈕，你有步驟結束按鈕，

299
00:13:34,090 --> 00:13:36,600
你也有步驟為按鈕。

300
00:13:36,600 --> 00:13:41,260
並且基本上，所有三個
他們只是通過你的代碼

301
00:13:41,260 --> 00:13:42,690
而做不同的事情。

302
00:13:42,690 --> 00:13:45,680
>> 所以通常情況下，當你正在調試，
我們不希望只是打遊戲，

303
00:13:45,680 --> 00:13:47,930
因為比賽將只運行
你的代碼，它的結束。

304
00:13:47,930 --> 00:13:49,070
然後，你不會真的
知道你的問題

305
00:13:49,070 --> 00:13:51,432
除非你設置多個斷點。

306
00:13:51,432 --> 00:13:53,890
如果設置了多個斷點，
它只是自動

307
00:13:53,890 --> 00:13:56,030
從一個斷點運行，
到下一個，到下一個。

308
00:13:56,030 --> 00:13:58,030
但是，在這種情況下，我們已經
只是那一個，因為我們

309
00:13:58,030 --> 00:13:59,970
希望我們的工作方式
從頂部向下至底部。

310
00:13:59,970 --> 00:14:04,830
所以，我們要忽略按鈕
現在為了這個計劃。

311
00:14:04,830 --> 00:14:08,230
>> 因此，在步函數只是
在每一行的步驟

312
00:14:08,230 --> 00:14:11,510
並告訴您
計算機在做什麼。

313
00:14:11,510 --> 00:14:14,630
該步驟為函數去
到實際的功能

314
00:14:14,630 --> 00:14:16,000
這是對你的代碼行。

315
00:14:16,000 --> 00:14:19,070
因此，例如，如printf（），
這是一個函數，對不對？

316
00:14:19,070 --> 00:14:21,980
如果我想在物理上一步
到printf（）函數，

317
00:14:21,980 --> 00:14:25,610
我真的進入片
其中，printf（）的寫，看看代碼

318
00:14:25,610 --> 00:14:26,730
這是怎麼回事那裡。

319
00:14:26,730 --> 00:14:29,924
>> 但通常，我們假設
我們為您提供的代碼工作。

320
00:14:29,924 --> 00:14:31,340
我們假設printf（）的正常工作。

321
00:14:31,340 --> 00:14:33,170
我們假設調用getInt（）的工作。

322
00:14:33,170 --> 00:14:35,170
因此，有沒有必要
走進這些功能。

323
00:14:35,170 --> 00:14:37,170
但是，如果有功能
你寫你自己

324
00:14:37,170 --> 00:14:39,060
要檢查
發生了什麼事情，

325
00:14:39,060 --> 00:14:41,200
你會想一步
入該功能。

326
00:14:41,200 --> 00:14:43,940
>> 所以現在我們只是
跨過這段代碼。

327
00:14:43,940 --> 00:14:44,485
所以，讓我們來看看。

328
00:14:44,485 --> 00:14:46,547
哦，打印，“哦，海，怎麼樣
多大的改變是欠？“

329
00:14:46,547 --> 00:14:47,130
我們不關心。

330
00:14:47,130 --> 00:14:49,830
我們知道的工作，
所以我們跳過它。

331
00:14:49,830 --> 00:14:53,290
>> 因此n，這是我們的浮動是
我們已經initialized--或declared--

332
00:14:53,290 --> 00:14:56,810
在頂部，我們現在是
等於說，以GetFloat（）。

333
00:14:56,810 --> 00:14:57,810
因此，讓我們跨過這道。

334
00:14:57,810 --> 00:14:59,580
而我們在看
底部這裡，程序

335
00:14:59,580 --> 00:15:03,360
這促使我輸入一個值。

336
00:15:03,360 --> 00:15:08,580
因此，讓我們輸入我們想要的值
在這裡測試，這是0.41。

337
00:15:08,580 --> 00:15:09,160
太好了。

338
00:15:09,160 --> 00:15:12,780
>> 所以，現在N--做你們看
這裡，在bottom--它的

339
00:15:12,780 --> 00:15:15,140
stored--因為我們
還沒有四捨五入的是，它

340
00:15:15,140 --> 00:15:19,540
存儲在這個像巨大
浮動是0.4099999996，

341
00:15:19,540 --> 00:15:22,550
這是足夠接近我們的
目的，現在，到0.41。

342
00:15:22,550 --> 00:15:26,090
然後，我們將在後​​面看到，因為我們
繼續加強在該程序，

343
00:15:26,090 --> 00:15:29,850
後這裡，正變得
圓潤和分成為41。

344
00:15:29,850 --> 00:15:30,350
太好了。

345
00:15:30,350 --> 00:15:32,230
因此，我們知道，我們的舍入的工作。

346
00:15:32,230 --> 00:15:34,700
我們知道，我們有
正確的數量美分，

347
00:15:34,700 --> 00:15:36,990
所以我們知道，這是
沒有真正的問題。

348
00:15:36,990 --> 00:15:40,050
>> 因此，我們將繼續加強
在此計劃。

349
00:15:40,050 --> 00:15:40,900
我們去這裡。

350
00:15:40,900 --> 00:15:46,139
而這行代碼之後的話，我們
要知道我們有多少個季度有。

351
00:15:46,139 --> 00:15:46,680
我們跳過。

352
00:15:46,680 --> 00:15:52,040
而且你看我們做什麼，其實，有一個
季度，因為我們已經減去25

353
00:15:52,040 --> 00:15:53,790
從41我們的初始值。

354
00:15:53,790 --> 00:15:55,890
我們有16個左右為我們美分。

355
00:15:55,890 --> 00:15:58,830
>> 大家是否明白如何
該程序是通過步進

356
00:15:58,830 --> 00:16:02,980
為什麼美分現已成為16
為什麼，現在，硬幣已經成為1？

357
00:16:02,980 --> 00:16:04,610
是每個人以下的邏輯是什麼？

358
00:16:04,610 --> 00:16:05,110
酷。

359
00:16:05,110 --> 00:16:07,860
因此，作為這一點的，在
計劃的工作，對不對？

360
00:16:07,860 --> 00:16:09,797
我們知道這是做完全
我們希望它。

361
00:16:09,797 --> 00:16:11,880
而我們實際上並沒有
要打印出來，哦，

362
00:16:11,880 --> 00:16:14,430
是仙在這一點上，
什麼是硬幣在此點。

363
00:16:14,430 --> 00:16:17,170
>> 我們將繼續經歷的程序。

364
00:16:17,170 --> 00:16:18,100
步過。

365
00:16:18,100 --> 00:16:18,620
酷。

366
00:16:18,620 --> 00:16:19,700
我們去了助攻。

367
00:16:19,700 --> 00:16:20,200
太好了。

368
00:16:20,200 --> 00:16:22,367
我們看到，它採取
關閉$ 0.10一角錢。

369
00:16:22,367 --> 00:16:23,450
而現在我們有兩個硬幣。

370
00:16:23,450 --> 00:16:25,260
這是正確的。

371
00:16:25,260 --> 00:16:31,555
>> 我們去了幾個便士而我們看到的
我們已經得到了遺留美分。

372
00:16:31,555 --> 00:16:32,680
嗯，這很奇怪。

373
00:16:32,680 --> 00:16:37,540
在這裡，在該程序中，我應該
已減去我便士。

374
00:16:37,540 --> 00:16:39,400
也許我只是沒有
這樣做行權。

375
00:16:39,400 --> 00:16:42,190
唉，你可以看到
在這裡，因為我們知道

376
00:16:42,190 --> 00:16:44,360
我們正在加緊
通過線32和33，

377
00:16:44,360 --> 00:16:50,560
這就是我們的計劃
不當有變量運行。

378
00:16:50,560 --> 00:16:55,136
因此，我們可以看看，看看，哦，
我在這裡減去美分，

379
00:16:55,136 --> 00:16:57,010
但我沒有實際
添加到我的幣值。

380
00:16:57,010 --> 00:16:57,860
我加入到美分。

381
00:16:57,860 --> 00:17:00,234
我不希望添加到
分錢，我要添加到硬幣。

382
00:17:00,234 --> 00:17:05,420
因此，如果我們改變，要硬幣，
我們已經有了一個工作程序。

383
00:17:05,420 --> 00:17:06,730
我可以運行check50。

384
00:17:06,730 --> 00:17:11,063
你可以只退出的GDB右出
這裡，然後再次運行check50。

385
00:17:11,063 --> 00:17:11,938
我可以做到這一點。

386
00:17:11,938 --> 00:17:14,822

387
00:17:14,822 --> 00:17:18,480
我一定要貪婪。

388
00:17:18,480 --> 00:17:19,940
0.41。

389
00:17:19,940 --> 00:17:22,819
而在這裡，它的印刷
出正確的答案。

390
00:17:22,819 --> 00:17:26,569
>> 所以當你們可以看到，GDB
是一個非常強大的工具

391
00:17:26,569 --> 00:17:29,940
當我們有這麼多的代碼
怎麼回事，這麼多的變數

392
00:17:29,940 --> 00:17:32,510
它很難對我們來說，作為
一個人，來跟踪。

393
00:17:32,510 --> 00:17:35,360
計算機，在GDB
調試器，有能力

394
00:17:35,360 --> 00:17:37,020
多事的。

395
00:17:37,020 --> 00:17:40,480
我知道，在VISIONAIRE，你們可能
可能擊中了一些段故障

396
00:17:40,480 --> 00:17:43,150
因為你正在運行
從你的陣列的界限。

397
00:17:43,150 --> 00:17:46,510
在凱撒的例子，這是
正是我在這裡實現。

398
00:17:46,510 --> 00:17:50,060
>> 所以，我忘了檢查
如果會發生什麼，我

399
00:17:50,060 --> 00:17:52,510
沒有兩個命令行參數。

400
00:17:52,510 --> 00:17:53,880
我只是沒有擺在那檢查。

401
00:17:53,880 --> 00:17:57,380
所以，如果我跑Debug--我設置
我的斷點就在這裡。

402
00:17:57,380 --> 00:17:58,055
我運行調試。

403
00:17:58,055 --> 00:18:15,880

404
00:18:15,880 --> 00:18:16,550
>> 確定。

405
00:18:16,550 --> 00:18:17,050
是啊。

406
00:18:17,050 --> 00:18:20,350
所以實際上，GDB應該
已經告訴我，

407
00:18:20,350 --> 00:18:22,300
是分割故障出現。

408
00:18:22,300 --> 00:18:24,883
我不知道發生了什麼事情
在那裡，但是當我運行它，

409
00:18:24,883 --> 00:18:25,590
這是工作。

410
00:18:25,590 --> 00:18:29,410
當您運行通過行代碼
GDB可能只是突然退出你，

411
00:18:29,410 --> 00:18:31,540
上去看看紅色的錯誤是什麼。

412
00:18:31,540 --> 00:18:33,930
它會告訴你的，嘿嘿，你
有段錯誤，

413
00:18:33,930 --> 00:18:38,550
這意味著您嘗試訪問
以陣列的空間不存在的。

414
00:18:38,550 --> 00:18:39,050
是啊。

415
00:18:39,050 --> 00:18:43,280
>> 因此，在接下來的問題
本週集，你們

416
00:18:43,280 --> 00:18:45,600
可能有很多
變量左右浮動。

417
00:18:45,600 --> 00:18:48,560
你不會是知道
它們都是指在某一點。

418
00:18:48,560 --> 00:18:53,560
因此，廣發行將真正幫助你在盤算
它們是什麼都等於

419
00:18:53,560 --> 00:18:55,940
並能夠看到直觀。

420
00:18:55,940 --> 00:19:01,995
有沒有人困惑於如何
任何被工作？

421
00:19:01,995 --> 00:19:02,495
酷。

422
00:19:02,495 --> 00:19:10,121

423
00:19:10,121 --> 00:19:10,620
好的。

424
00:19:10,620 --> 00:19:14,260
所以在這之後，我們
去潛水權

425
00:19:14,260 --> 00:19:17,562
成四種不同的
排序類型本週。

426
00:19:17,562 --> 00:19:19,520
你們有多少人，第一次
所有的人，在我們開始之前，

427
00:19:19,520 --> 00:19:23,020
讀完整個規範的pset3？

428
00:19:23,020 --> 00:19:23,824
確定。

429
00:19:23,824 --> 00:19:24,740
我是你們的驕傲。

430
00:19:24,740 --> 00:19:29,110
這就像半個班，這
是顯著超過上一次。

431
00:19:29,110 --> 00:19:33,950
>> 所以，這是偉大的，因為當
我們談論的內容

432
00:19:33,950 --> 00:19:36,170
在lecture--還是遺憾，
在section--我喜歡

433
00:19:36,170 --> 00:19:38,210
以涉及了很多的
回PSET是什麼

434
00:19:38,210 --> 00:19:40,210
你想如何
實現在你的pset中。

435
00:19:40,210 --> 00:19:42,400
所以，如果你來有
讀取規格，它會

436
00:19:42,400 --> 00:19:45,510
是一個更容易讓你明白
我說的是，當我說，

437
00:19:45,510 --> 00:19:48,720
嘿，這可能是一個真正的
實現這種好地方。

438
00:19:48,720 --> 00:19:52,870
所以，你們誰讀了
SPEC知道，作為你的PSET的一部分，

439
00:19:52,870 --> 00:19:54,900
你將不得不
寫一個排序的類型。

440
00:19:54,900 --> 00:19:58,670
所以，這可能是非常有幫助
今天很多你。

441
00:19:58,670 --> 00:20:01,760
>> 因此，我們將剛開始時，
本質上，最簡單類型

442
00:20:01,760 --> 00:20:04,580
排序，選擇排序。

443
00:20:04,580 --> 00:20:06,800
典型的算法
我們怎麼會去這

444
00:20:06,800 --> 00:20:10,460
is--大衛通過這些全都走了進去
講座，所以我會很快待著

445
00:20:10,460 --> 00:20:13,900
這裡 - 本質上，你
有值的數組。

446
00:20:13,900 --> 00:20:17,170
然後你找到
最小的未分類的價值

447
00:20:17,170 --> 00:20:20,200
和你交換與價值
第一個未排序的值。

448
00:20:20,200 --> 00:20:22,700
然後你只是不斷重複
以列表的其餘部分。

449
00:20:22,700 --> 00:20:25,740
>> 而且這裡有一個直觀的解釋
如何將工作。

450
00:20:25,740 --> 00:20:30,460
因此，例如，如果我們開始
與五個元件的陣列，索引

451
00:20:30,460 --> 00:20:35,910
0至4，用3,5，2,6，和4個值
所以，現在擺在array--，

452
00:20:35,910 --> 00:20:38,530
我們只是假設
他們都是未分類

453
00:20:38,530 --> 00:20:41,130
因為我們還沒有測試過，否則。

454
00:20:41,130 --> 00:20:44,130
>> 因此，如何選擇排序會
工作是，那就先

455
00:20:44,130 --> 00:20:46,800
通過整體運行
未排序的數組。

456
00:20:46,800 --> 00:20:49,120
這將挑選出的最小值。

457
00:20:49,120 --> 00:20:51,750
在這種情況下，如圖3所示，右
現在，是最小的。

458
00:20:51,750 --> 00:20:52,680
它得到5。

459
00:20:52,680 --> 00:20:55,620
不，5不大於than--
或不好意思，不低於than-- 3。

460
00:20:55,620 --> 00:20:57,779
所以最小值仍然3。

461
00:20:57,779 --> 00:20:58,695
然後你到2。

462
00:20:58,695 --> 00:21:00,990
電腦看，哦，2小於3。

463
00:21:00,990 --> 00:21:02,750
2現在必須的最小值。

464
00:21:02,750 --> 00:21:06,630
所以2掉期與第一個值。

465
00:21:06,630 --> 00:21:10,702
>> 因此，人們通過後，我們確實看到
該2和3被交換。

466
00:21:10,702 --> 00:21:13,910
而我們只是要繼續做
這再次與陣列的其餘部分。

467
00:21:13,910 --> 00:21:17,660
因此，我們將只運行通過
最後四個指標的數組。

468
00:21:17,660 --> 00:21:20,670
我們會看到，3
下一最小值。

469
00:21:20,670 --> 00:21:23,240
所以，我們要交換與4。

470
00:21:23,240 --> 00:21:26,900
然後，我們只是要繼續
貫​​穿直到最後，你

471
00:21:26,900 --> 00:21:33,730
得到一個排序的數組中
2，3，4，5，和6被所有排序。

472
00:21:33,730 --> 00:21:37,530
大家是否明白邏輯
如何選擇排序工作？

473
00:21:37,530 --> 00:21:39,669
>> 你只要有某種
的最小值。

474
00:21:39,669 --> 00:21:41,210
你跟踪的那是什麼。

475
00:21:41,210 --> 00:21:45,170
每當你找到它，你將其交換
與在array--第一值

476
00:21:45,170 --> 00:21:48,740
或者，不是第一value--
陣列中的下一個值。

477
00:21:48,740 --> 00:21:50,150
酷。

478
00:21:50,150 --> 00:21:55,460
>> 所以當你們那種
從短暫的一瞥看到，

479
00:21:55,460 --> 00:21:58,450
我們要偽代碼這一點。

480
00:21:58,450 --> 00:22:02,510
所以，如果你們在後面要
組成一個小組，每個人都在一張桌子

481
00:22:02,510 --> 00:22:06,170
可以形成一個小夥伴，我要去
給你們喜歡3分鐘

482
00:22:06,170 --> 00:22:08,190
剛才講通過
邏輯，英語，

483
00:22:08,190 --> 00:22:14,161
對我們如何能夠實現
偽代碼寫一個選擇排序。

484
00:22:14,161 --> 00:22:14,910
還有的糖果。

485
00:22:14,910 --> 00:22:16,118
請上來，並得到糖果。

486
00:22:16,118 --> 00:22:19,520
如果你在後面，你想
糖果，我會向你扔糖果。

487
00:22:19,520 --> 00:22:22,850
其實，做你 - 爽。

488
00:22:22,850 --> 00:22:23,552
哦，對不起。

489
00:22:23,552 --> 00:22:26,751

490
00:22:26,751 --> 00:22:27,250
確定。

491
00:22:27,250 --> 00:25:23,880

492
00:25:23,880 --> 00:25:27,140
>> 所以，如果我們想，作為
一類，寫偽代碼

493
00:25:27,140 --> 00:25:30,466
如何人們可能接近
這個問題，只是覺得自由。

494
00:25:30,466 --> 00:25:32,340
我就到處去和，
為了，問群體

495
00:25:32,340 --> 00:25:35,065
對於下一行
我們應該做的。

496
00:25:35,065 --> 00:25:37,840
所以，如果你們想開始
關，什麼是第一件事情

497
00:25:37,840 --> 00:25:40,600
當你試圖做
實現的方式來解決這個方案

498
00:25:40,600 --> 00:25:43,480
有選擇地排序列表？

499
00:25:43,480 --> 00:25:46,349
讓我們只是假設我們
有一個數組，沒事吧？

500
00:25:46,349 --> 00:25:49,088
>> 聽眾：你想創造一些
排序[聽不清]你是

501
00:25:49,088 --> 00:25:50,420
通過你的整個陣列的運行。

502
00:25:50,420 --> 00:25:51,128
>> ANDI彭：對。

503
00:25:51,128 --> 00:25:54,100
所以，你會想迭代
通過每一個空間，對不對？

504
00:25:54,100 --> 00:26:05,490
所以，偉大的。

505
00:26:05,490 --> 00:26:08,600
如果你們想給我
接下來line--是啊，在後面。

506
00:26:08,600 --> 00:26:11,414

507
00:26:11,414 --> 00:26:13,290
>> 聽眾：檢查他們
全部為最小。

508
00:26:13,290 --> 00:26:14,248
>> ANDI彭：我們去那裡。

509
00:26:14,248 --> 00:26:17,438
因此，我們希望通過和檢查
看到最小值是什麼，對不對？

510
00:26:17,438 --> 00:26:22,110

511
00:26:22,110 --> 00:26:24,840
我要縮寫，為“最小”。

512
00:26:24,840 --> 00:26:27,658
你們有什麼想後做
你已經找到了最小值？

513
00:26:27,658 --> 00:26:28,533
>> 聽眾：[聽不清]

514
00:26:28,533 --> 00:26:29,942

515
00:26:29,942 --> 00:26:33,150
ANDI彭：所以你會想
與第一個數組中打開它，

516
00:26:33,150 --> 00:26:33,650
對不對？

517
00:26:33,650 --> 00:26:45,120

518
00:26:45,120 --> 00:26:46,850
這是開始的時候，我會說。

519
00:26:46,850 --> 00:26:47,220
好的。

520
00:26:47,220 --> 00:26:50,386
所以，現在你已經換第一
一，什麼你想以後做什麼？

521
00:26:50,386 --> 00:26:54,840
所以，現在我們知道，這一個在這裡
必須是最小的值，對不對？

522
00:26:54,840 --> 00:26:58,310
然後，你有一個額外的休息
該陣列是無序的。

523
00:26:58,310 --> 00:27:01,569
所以，你想在這裡做的，如果你有什麼
人想給我的下一行？

524
00:27:01,569 --> 00:27:04,610
聽眾：那麼接下來你要遍歷
通過該陣列的剩餘部分。

525
00:27:04,610 --> 00:27:05,276
ANDI彭：是的。

526
00:27:05,276 --> 00:27:09,857
還等什麼，通過它遍歷
那種暗示我們可能會需要什麼？

527
00:27:09,857 --> 00:27:10,440
什麼類型的of--

528
00:27:10,440 --> 00:27:12,057
>> 聽眾：哦，一個額外的變量？

529
00:27:12,057 --> 00:27:13,890
ANDI彭：可能
另一個循環，對不對？

530
00:27:13,890 --> 00:27:28,914
因此，我們可能會想
迭代through--很大。

531
00:27:28,914 --> 00:27:31,830
然後，你要回去
可能再次檢查最低，

532
00:27:31,830 --> 00:27:32,100
對不對？

533
00:27:32,100 --> 00:27:34,975
而你要不斷重複
這一點，因為環正要

534
00:27:34,975 --> 00:27:36,010
繼續運行，對吧？

535
00:27:36,010 --> 00:27:39,190
>> 所以當你們可以看到，我們
只是有一個大致的偽代碼

536
00:27:39,190 --> 00:27:41,480
我們如何希望這個節目的樣子。

537
00:27:41,480 --> 00:27:46,646
這裡這個迭代，我們怎麼
通常需要在我們的代碼編寫

538
00:27:46,646 --> 00:27:49,270
如果我們要遍歷一個
陣列，什麼類型的結構？

539
00:27:49,270 --> 00:27:51,030
我想Christabel
之前已經說過這​​一點。

540
00:27:51,030 --> 00:27:51,500
>> 聽眾：for循環。

541
00:27:51,500 --> 00:27:52,160
>> ANDI彭：一種循環？

542
00:27:52,160 --> 00:27:52,770
沒錯。

543
00:27:52,770 --> 00:27:56,060
因此，這可能是
將是一個for循環。

544
00:27:56,060 --> 00:27:59,240
什麼是這裡的檢查會意味著什麼呢？

545
00:27:59,240 --> 00:28:02,536
通常情況下，如果你想查詢
如果有什麼東西else--

546
00:28:02,536 --> 00:28:03,270
>> 聽眾：如果。

547
00:28:03,270 --> 00:28:06,790
>> ANDI彭：如果一個，對不對？

548
00:28:06,790 --> 00:28:10,790
然後在這裡交換，我們將
去了以後，因為大衛·

549
00:28:10,790 --> 00:28:12,770
通過講座去為好。

550
00:28:12,770 --> 00:28:14,580
然後第二個迭代implies--

551
00:28:14,580 --> 00:28:15,120
>> 聽眾：另一個循環。

552
00:28:15,120 --> 00:28:16,745
>> ANDI彭：--another for循環，沒錯。

553
00:28:16,745 --> 00:28:19,870

554
00:28:19,870 --> 00:28:22,000
因此，如果我們正在尋找
在這個正確的，我們

555
00:28:22,000 --> 00:28:24,680
可以看到，我們可能
將需要一個嵌套的循環

556
00:28:24,680 --> 00:28:28,330
在有一個條件語句
然後代碼的一個實際的一塊是

557
00:28:28,330 --> 00:28:31,360
要交換值。

558
00:28:31,360 --> 00:28:35,980
所以，我只是一般寫
這裡一個偽代碼。

559
00:28:35,980 --> 00:28:38,910
然後，我們實際上會
到身體上，作為一類，

560
00:28:38,910 --> 00:28:40,700
試試這個今天實現。

561
00:28:40,700 --> 00:28:42,486
讓我們回到這個IDE。

562
00:28:42,486 --> 00:28:49,243

563
00:28:49,243 --> 00:28:50,230
>> 嗯，哦。

564
00:28:50,230 --> 00:28:51,754
這是為什麼不是 - 它就在那裡。

565
00:28:51,754 --> 00:28:52,253
確定。

566
00:28:52,253 --> 00:28:55,834

567
00:28:55,834 --> 00:28:57,500
對不起，讓我盡量放大一點。

568
00:28:57,500 --> 00:28:59,310
在那裡，我們走了。

569
00:28:59,310 --> 00:29:05,060
我做的是在這裡我創建
一個名為“選擇/ sort.c。”

570
00:29:05,060 --> 00:29:10,860
我創建了九個數組
值，4，8 2，1，6,9，7,5，3。

571
00:29:10,860 --> 00:29:14,370
目前，你可以
看，他們是無序的。

572
00:29:14,370 --> 00:29:17,880
n為將成為數
告訴你值量

573
00:29:17,880 --> 00:29:18,920
你在你的陣列。

574
00:29:18,920 --> 00:29:20,670
在這種情況下，我們有九個值。

575
00:29:20,670 --> 00:29:23,760
我剛剛得到了一個for循環在這裡
打印出的排序的數組。

576
00:29:23,760 --> 00:29:28,370
>> 而在最後，我也得到了一個為
循環，只是打印出來了。

577
00:29:28,370 --> 00:29:32,070
因此從理論上說，如果此程序
工作正常，到了最後，

578
00:29:32,070 --> 00:29:35,670
你應該看到一個打印的循環
其中，1，2，3，4，5，6，7，8，

579
00:29:35,670 --> 00:29:39,310
9都是正確的順序。

580
00:29:39,310 --> 00:29:43,410
>> 所以，我們在這裡得到了我們的偽代碼。

581
00:29:43,410 --> 00:29:46,090
有誰想用於：我只是
要去問volunteers--

582
00:29:46,090 --> 00:29:49,540
確切地告訴我，如果什麼類型
我們希望，第一，只是想迭代

583
00:29:49,540 --> 00:29:52,840
通過這個數組的開始？

584
00:29:52,840 --> 00:29:55,204
什麼是代碼行我
可能要在這裡需要什麼？

585
00:29:55,204 --> 00:29:56,990
>> 聽眾：[聽不清]

586
00:29:56,990 --> 00:29:59,010
>> ANDI彭：是啊，感覺
免費用於：對不起，你

587
00:29:59,010 --> 00:30:02,318
不必忍受up--手感
自由地提高你的聲音有點。

588
00:30:02,318 --> 00:30:08,190
>> 顧客：INT I等於0--

589
00:30:08,190 --> 00:30:10,690
>> ANDI彭：是的，不錯。

590
00:30:10,690 --> 00:30:15,220
>> 觀眾：我是小於數組的長度。

591
00:30:15,220 --> 00:30:19,630
>> ANDI彭：因此，保持在
介意在這裡，因為我們

592
00:30:19,630 --> 00:30:23,060
不具有功能
告訴我們的陣列的長度，

593
00:30:23,060 --> 00:30:25,790
我們已經有一個
值，其存儲。

594
00:30:25,790 --> 00:30:27,920
對嗎？

595
00:30:27,920 --> 00:30:31,010
另一件讓
在mind--以陣列

596
00:30:31,010 --> 00:30:33,940
九價值觀，有什麼指標？

597
00:30:33,940 --> 00:30:38,720
遠的不說這個數組是0至3。

598
00:30:38,720 --> 00:30:41,500
你看，最後
指數實際上是3。

599
00:30:41,500 --> 00:30:45,530
這不是4，即使有
陣列中的四個值。

600
00:30:45,530 --> 00:30:49,866
>> 所以在這裡，我們必須非常小心，
什麼我們條件的長度

601
00:30:49,866 --> 00:30:50,490
將是。

602
00:30:50,490 --> 00:30:51,948
>> 聽眾：那豈不是為n減去1？

603
00:30:51,948 --> 00:30:54,440
ANDI彭：這是怎麼回事
Ñ​​減去1，正好。

604
00:30:54,440 --> 00:30:57,379
這是否有意義，為什麼
它n值減1，每個人？

605
00:30:57,379 --> 00:30:58,920
這是因為數組是零索引。

606
00:30:58,920 --> 00:31:02,010
他們從0開始並運行最多n個減1。

607
00:31:02,010 --> 00:31:03,210
是的，這是一個有點棘手。

608
00:31:03,210 --> 00:31:03,730
確定。

609
00:31:03,730 --> 00:31:05,929
而then--

610
00:31:05,929 --> 00:31:08,054
聽眾：Isnt'1那
已經採取的雖然照顧，

611
00:31:08,054 --> 00:31:11,400
通過剛才不是說“小於或
等於“，只是說：”不到？“

612
00:31:11,400 --> 00:31:13,108
>> ANDI彭：這是一個
非常好的問題。

613
00:31:13,108 --> 00:31:13,630
所以，是的。

614
00:31:13,630 --> 00:31:17,410
而且，我們的方式是說
實施檢查權，

615
00:31:17,410 --> 00:31:19,120
你需要比較兩個值。

616
00:31:19,120 --> 00:31:21,009
所以，你真的想
離開“到”空。

617
00:31:21,009 --> 00:31:23,050
因為如果你比較
這一次，你不會

618
00:31:23,050 --> 00:31:25,530
有後什麼
要比較的，對不對？

619
00:31:25,530 --> 00:31:27,460
是啊。

620
00:31:27,460 --> 00:31:29,297
所以我++。

621
00:31:29,297 --> 00:31:30,380
讓我們添加括號研究。

622
00:31:30,380 --> 00:31:30,880
哎呦。

623
00:31:30,880 --> 00:31:33,950

624
00:31:33,950 --> 00:31:34,710
太好了。

625
00:31:34,710 --> 00:31:39,117
因此，我們有初
我們的外環。

626
00:31:39,117 --> 00:31:41,450
所以，現在我們可能要
建立保持一個變量

627
00:31:41,450 --> 00:31:43,085
軌道的最小值，對不對？

628
00:31:43,085 --> 00:31:45,751
沒有人想給我
行代碼，將做到這一點？

629
00:31:45,751 --> 00:31:48,700

630
00:31:48,700 --> 00:31:53,570
我們需要什麼，如果我們打算
想儲存什麼？

631
00:31:53,570 --> 00:31:55,047
>> 右。

632
00:31:55,047 --> 00:31:57,630
對於也許一個更好的名字
將be--“臨時”完全works--

633
00:31:57,630 --> 00:32:00,655
也許更恰當地命名會是這樣，
如果我們希望最小value--

634
00:32:00,655 --> 00:32:01,624
>> 聽眾：最小。

635
00:32:01,624 --> 00:32:02,790
ANDI彭：分鐘，我們走吧。

636
00:32:02,790 --> 00:32:05,230
分將是一件好事。

637
00:32:05,230 --> 00:32:08,340
所以在這裡，我們怎麼
要初始化為？

638
00:32:08,340 --> 00:32:09,620
這是一個有點棘手。

639
00:32:09,620 --> 00:32:13,580
因為現在在
開始本陣，

640
00:32:13,580 --> 00:32:15,730
你有沒有看什麼，對不對？

641
00:32:15,730 --> 00:32:19,200
還等什麼，自動，如果
我們只是i等於0，

642
00:32:19,200 --> 00:32:22,302
我們怎麼想初始化
我們的第一個最小值？

643
00:32:22,302 --> 00:32:22,802
觀眾：我。

644
00:32:22,802 --> 00:32:24,790
ANDI彭：我，沒錯。

645
00:32:24,790 --> 00:32:27,040
Christabel，那我們為什麼還要
它初始化到我？

646
00:32:27,040 --> 00:32:28,510
>> 聽眾：因為，
我們從0開始。

647
00:32:28,510 --> 00:32:31,660
所以，因為我們沒有什麼可比較
它，最小最終會被0。

648
00:32:31,660 --> 00:32:32,451
>> ANDI鵬：沒錯。

649
00:32:32,451 --> 00:32:34,400
所以她完全正確。

650
00:32:34,400 --> 00:32:36,780
因為我們還沒有真正
看著任何東西，

651
00:32:36,780 --> 00:32:38,680
我們不知道我們的最低值。

652
00:32:38,680 --> 00:32:41,960
我們希望只是將其初始化為
我，這，目前，就在這裡。

653
00:32:41,960 --> 00:32:44,750
而且，我們將繼續
向下移動，這陣，

654
00:32:44,750 --> 00:32:48,122
我們將看到，每個
額外的傳球，我遞增。

655
00:32:48,122 --> 00:32:49,830
因此，在這一點上，
我很可能會

656
00:32:49,830 --> 00:32:52,329
想為最小，
因為這將是什麼

657
00:32:52,329 --> 00:32:54,520
是未排序數組的開始。

658
00:32:54,520 --> 00:32:55,270
酷。

659
00:32:55,270 --> 00:32:58,720
>> 所以，現在我們要添加
一個for循環，這裡的

660
00:32:58,720 --> 00:33:03,225
要遍歷
未分類，或該陣列的其餘部分。

661
00:33:03,225 --> 00:33:05,808
沒有人想給我一個
行代碼，將做到這一點？

662
00:33:05,808 --> 00:33:08,870

663
00:33:08,870 --> 00:33:11,330
Hint--我們需要什麼到這裡？

664
00:33:11,330 --> 00:33:17,320

665
00:33:17,320 --> 00:33:18,820
這是怎麼回事往這個循環？

666
00:33:18,820 --> 00:33:19,465
是啊。

667
00:33:19,465 --> 00:33:21,590
聽眾：所以我們會想
有一個不同的整數，

668
00:33:21,590 --> 00:33:25,080
因為我們通過休息運行
數組，而不是我，所以也許對

669
00:33:25,080 --> 00:33:25,760
學家

670
00:33:25,760 --> 00:33:27,301
>> ANDI彭：是啊，J聽起來不錯。

671
00:33:27,301 --> 00:33:27,850
等於？

672
00:33:27,850 --> 00:33:33,930
>> 聽眾：那將是我加1，因為
你開始的下一個值。

673
00:33:33,930 --> 00:33:40,395
然後到end--如此反复，j為
小於n減去1，然後J ++以下。

674
00:33:40,395 --> 00:33:41,103
ANDI彭：太好了。

675
00:33:41,103 --> 00:33:48,510

676
00:33:48,510 --> 00:33:52,750
>> 然後在這裡，我們將要
檢查，看看是否符合我們的條件，

677
00:33:52,750 --> 00:33:53,250
對不對？

678
00:33:53,250 --> 00:33:55,740
因為你想
改變的最小值

679
00:33:55,740 --> 00:33:58,700
如果它實際上是小於什麼
你對比的話，對不對？

680
00:33:58,700 --> 00:34:01,146
那麼，我們將要在這裡？

681
00:34:01,146 --> 00:34:04,160

682
00:34:04,160 --> 00:34:04,897
請檢查。

683
00:34:04,897 --> 00:34:06,730
聲明什麼類型
我們有可能將

684
00:34:06,730 --> 00:34:08,389
TI想，如果用我們
要檢查些什麼呢？

685
00:34:08,389 --> 00:34:09,360
>> 聽眾：if語句。

686
00:34:09,360 --> 00:34:10,485
>> ANDI彭：if語句。

687
00:34:10,485 --> 00:34:13,155
所以if--，什麼將是
我們希望裡面的狀況

688
00:34:13,155 --> 00:34:13,988
我們的if語句？

689
00:34:13,988 --> 00:34:18,255

690
00:34:18,255 --> 00:34:22,960
>> 聽眾：如果j值
小於I--值

691
00:34:22,960 --> 00:34:24,600
>> ANDI鵬：沒錯。

692
00:34:24,600 --> 00:34:27,480
所以if--所以這個數組被稱為“數組”。

693
00:34:27,480 --> 00:34:27,980
太好了。

694
00:34:27,980 --> 00:34:30,465
因此，如果array--那是什麼？

695
00:34:30,465 --> 00:34:31,090
再說了。

696
00:34:31,090 --> 00:34:39,590
>> 聽眾：如果array-j是小於
數組我的話，就要改變最小。

697
00:34:39,590 --> 00:34:41,590
所以分鐘就學家

698
00:34:41,590 --> 00:34:44,590

699
00:34:44,590 --> 00:34:47,249
>> ANDI彭：這是否有意義嗎？

700
00:34:47,249 --> 00:34:48,670
確定。

701
00:34:48,670 --> 00:34:52,929
而現在到這裡，我們其實
要實現交換，對不對？

702
00:34:52,929 --> 00:34:58,285
所以記得，在演講中，大衛，當
他是想換the--是什麼

703
00:34:58,285 --> 00:34:59,996
它 - 橙汁和milk--

704
00:34:59,996 --> 00:35:01,150
>> 聽眾：這是毛。

705
00:35:01,150 --> 00:35:02,816
>> ANDI彭：是啊，這是種毛。

706
00:35:02,816 --> 00:35:05,310
但它是一個相當不錯的
概念展示時間。

707
00:35:05,310 --> 00:35:08,430
因此，認為你的價值在這裡。

708
00:35:08,430 --> 00:35:10,794
你有一個數組
的分，i的陣列，

709
00:35:10,794 --> 00:35:12,460
或不管我們想在這裡交換。

710
00:35:12,460 --> 00:35:15,310
而且你可能無法將其倒入
對方在同一時間，對吧？

711
00:35:15,310 --> 00:35:17,180
那麼究竟是為了什麼
需要創建在這裡

712
00:35:17,180 --> 00:35:19,126
為了正確交換價值？

713
00:35:19,126 --> 00:35:19,820
>> 聽眾：一個臨時變量。

714
00:35:19,820 --> 00:35:21,370
>> ANDI彭：一個臨時變量。

715
00:35:21,370 --> 00:35:22,570
因此，讓我們做INT溫度。

716
00:35:22,570 --> 00:35:25,681
你看，這將是一個更好的
時間用於：哇，那是什麼？

717
00:35:25,681 --> 00:35:26,180
確定。

718
00:35:26,180 --> 00:35:29,800
因此，這將是一個更好的
時間命名變量“溫度”。

719
00:35:29,800 --> 00:35:30,730
因此，讓我們做INT溫度。

720
00:35:30,730 --> 00:35:32,563
什麼是我們要
SET TEMP等於在這裡？

721
00:35:32,563 --> 00:35:34,752

722
00:35:34,752 --> 00:35:35,335
聽眾：最小？

723
00:35:35,335 --> 00:35:38,508

724
00:35:38,508 --> 00:35:39,716
ANDI彭：這是一個有點棘手。

725
00:35:39,716 --> 00:35:43,110

726
00:35:43,110 --> 00:35:44,880
它實際上無所謂到底。

727
00:35:44,880 --> 00:35:47,690
它什麼都無所謂
為了您選擇交換

728
00:35:47,690 --> 00:35:50,862
只要你確保你
跟踪你交換什麼。

729
00:35:50,862 --> 00:35:52,250
>> 聽眾：這可能是數組我。

730
00:35:52,250 --> 00:35:53,666
>> ANDI彭：是的，讓我們做陣列我。

731
00:35:53,666 --> 00:35:55,950

732
00:35:55,950 --> 00:35:59,305
然後什麼是下一行
的代碼，我們要在這裡？

733
00:35:59,305 --> 00:36:00,680
聽眾：陣列-i等於陣列-J。

734
00:36:00,680 --> 00:36:07,154

735
00:36:07,154 --> 00:36:08,070
ANDI彭：最後一點？

736
00:36:08,070 --> 00:36:12,070
聽眾：陣列-J等於陣列我。

737
00:36:12,070 --> 00:36:14,525
聽眾：或數組，j為
陣列temp--或溫度。

738
00:36:14,525 --> 00:36:17,135

739
00:36:17,135 --> 00:36:19,430
>> ANDI彭：OK。

740
00:36:19,430 --> 00:36:21,510
因此，讓我們運行這個，看看
如果它去上班。

741
00:36:21,510 --> 00:36:37,520

742
00:36:37,520 --> 00:36:39,335
哪裡是怎麼回事？

743
00:36:39,335 --> 00:36:40,210
哦，這是一個問題。

744
00:36:40,210 --> 00:36:44,320
見，第40行，我們
嘗試使用數組-J？

745
00:36:44,320 --> 00:36:47,022
但是，在沒有Ĵ只存在嗎？

746
00:36:47,022 --> 00:36:48,402
>> 聽眾：在for循環。

747
00:36:48,402 --> 00:36:49,110
ANDI彭：對。

748
00:36:49,110 --> 00:36:51,730
那麼，我們將需要做什麼？

749
00:36:51,730 --> 00:36:53,170
>> 聽眾：外the--將其定義

750
00:36:53,170 --> 00:36:57,777

751
00:36:57,777 --> 00:37:00,610
聽眾：是的，我想你
if語句，使用權的另一個？

752
00:37:00,610 --> 00:37:05,230
所以像，如果minimum--
好吧，讓我想想。

753
00:37:05,230 --> 00:37:08,170

754
00:37:08,170 --> 00:37:09,990
>> ANDI彭：伙計們，試試
看看咱們的

755
00:37:09,990 --> 00:37:11,270
看看，什麼的東西，我們可以在這裡做什麼？

756
00:37:11,270 --> 00:37:11,811
>> 聽眾：OK。

757
00:37:11,811 --> 00:37:15,900
因此，如果最低不等於
j--所以如果最小仍然I--

758
00:37:15,900 --> 00:37:17,570
那麼我們就不會掉。

759
00:37:17,570 --> 00:37:22,450

760
00:37:22,450 --> 00:37:24,712
>> ANDI彭：這是否等於我？

761
00:37:24,712 --> 00:37:25,920
你怎麼在這裡想說的？

762
00:37:25,920 --> 00:37:30,494
>> 聽眾：或者是啊，如果
最低不等於我，是的。

763
00:37:30,494 --> 00:37:39,627

764
00:37:39,627 --> 00:37:40,210
ANDI彭：OK。

765
00:37:40,210 --> 00:37:42,040
好了，解決了，那種，我們的問題。

766
00:37:42,040 --> 00:37:47,265
但是，這仍然沒有解決
如果j--發生，因為Ĵ哪些問題

767
00:37:47,265 --> 00:37:49,890
外面它不存在，什麼
你，我們想用它做？

768
00:37:49,890 --> 00:37:50,698
外部聲明呢？

769
00:37:50,698 --> 00:37:59,410

770
00:37:59,410 --> 00:38:02,730
讓我們嘗試運行此。

771
00:38:02,730 --> 00:38:04,435
嗯，哦。

772
00:38:04,435 --> 00:38:06,200
我們的排序不工作。

773
00:38:06,200 --> 00:38:10,060
>> 正如你所看到的，我們最初的
數組有這些值。

774
00:38:10,060 --> 00:38:14,800
事後它應該有
一直在1，2，3，4，5，6，7，8，9。

775
00:38:14,800 --> 00:38:15,530
它不工作。

776
00:38:15,530 --> 00:38:16,030
啊。

777
00:38:16,030 --> 00:38:17,184
我們該怎麼辦？

778
00:38:17,184 --> 00:38:17,850
聽眾：調試。

779
00:38:17,850 --> 00:38:21,787

780
00:38:21,787 --> 00:38:23,370
ANDI鵬：好的，我們可以試試。

781
00:38:23,370 --> 00:38:25,030
我們可以調試。

782
00:38:25,030 --> 00:38:26,042
縮小了一點。

783
00:38:26,042 --> 00:38:31,177

784
00:38:31,177 --> 00:38:33,656
讓我們設置的斷點。

785
00:38:33,656 --> 00:38:37,280
讓我們去like--確定。

786
00:38:37,280 --> 00:38:40,444
>> 所以，因為我們已經知道，
這些線路，15至22，

787
00:38:40,444 --> 00:38:43,610
在working--因為我做的是
通過與printing--只是迭代

788
00:38:43,610 --> 00:38:45,406
我可以繼續跳過。

789
00:38:45,406 --> 00:38:47,280
讓我們從第25行。

790
00:38:47,280 --> 00:38:48,712
空中接力，讓我擺脫這一點。

791
00:38:48,712 --> 00:38:51,598

792
00:38:51,598 --> 00:38:54,057
>> 聽眾：所以斷點的
其中，調試開始？

793
00:38:54,057 --> 00:38:54,890
ANDI彭：或停止。

794
00:38:54,890 --> 00:38:55,670
聽眾：或停止。

795
00:38:55,670 --> 00:38:55,930
ANDI彭：是的。

796
00:38:55,930 --> 00:38:58,640
您可以設置多個斷點和
它可以只從一個到另一個跳。

797
00:38:58,640 --> 00:39:01,590
但是，在這種情況下，我們不知道
那裡的錯誤發生。

798
00:39:01,590 --> 00:39:03,780
所以，我們只是想
從上向下展開。

799
00:39:03,780 --> 00:39:05,020
是的。

800
00:39:05,020 --> 00:39:05,550
確定。

801
00:39:05,550 --> 00:39:08,460
>> 因此，這條線在這裡，我們可以介入。

802
00:39:08,460 --> 00:39:11,499
你可以看到這兒，
我們已經有了一個數組。

803
00:39:11,499 --> 00:39:13,290
這些都是價值
是陣列中。

804
00:39:13,290 --> 00:39:16,360
你看到了，怎麼指數為0，
對應於value--哦，

805
00:39:16,360 --> 00:39:17,526
我要去嘗試進行放大。

806
00:39:17,526 --> 00:39:20,650
對不起，這真的很難
以see--數組索引0，

807
00:39:20,650 --> 00:39:24,090
我們有4的值，
然後依此類推等等。

808
00:39:24,090 --> 00:39:25,670
我們有自己的局部變量。

809
00:39:25,670 --> 00:39:28,570
現在我等於
0，這是我們希望它是。

810
00:39:28,570 --> 00:39:31,540

811
00:39:31,540 --> 00:39:33,690
>> 因此，讓我們繼續單步調​​試。

812
00:39:33,690 --> 00:39:36,850
我們的最低等於0，
我們也希望它是。

813
00:39:36,850 --> 00:39:39,470

814
00:39:39,470 --> 00:39:45,560
然後，我們進入我們的第二個用於
環，如果陣列-j是小於陣列-i的，

815
00:39:45,560 --> 00:39:46,380
它不是。

816
00:39:46,380 --> 00:39:48,130
所以，你怎麼看
即跳過了嗎？

817
00:39:48,130 --> 00:39:52,430
>> 聽眾：所以要把如果
最低，所有that--不應該的

818
00:39:52,430 --> 00:39:55,424
在裡面的第一個for循環？

819
00:39:55,424 --> 00:39:57,340
ANDI彭：沒有，因為
你還是想測試。

820
00:39:57,340 --> 00:40:00,329
你想要做一個比較每
時間，即使你通過它運行。

821
00:40:00,329 --> 00:40:02,620
你不只是想這樣做
在第一通過。

822
00:40:02,620 --> 00:40:05,240
你想做到這一點的
再每增加一個通行證。

823
00:40:05,240 --> 00:40:07,198
所以，你要檢查
你的病情裡面。

824
00:40:07,198 --> 00:40:11,610

825
00:40:11,610 --> 00:40:13,746
所以，我們只是要
讓經過這裡運行。

826
00:40:13,746 --> 00:40:17,337

827
00:40:17,337 --> 00:40:18,420
我給你們一個提示。

828
00:40:18,420 --> 00:40:23,910
它必須做的事實是，當
你檢查你的條件，

829
00:40:23,910 --> 00:40:26,600
你不檢查
正確的索引。

830
00:40:26,600 --> 00:40:32,510
所以現在你檢查
殲數組索引小於陣列

831
00:40:32,510 --> 00:40:33,970
我索引。

832
00:40:33,970 --> 00:40:36,580
但是，你在做什麼了，在
for循環的開始？

833
00:40:36,580 --> 00:40:38,260
難道你不設置Ĵ等於我？

834
00:40:38,260 --> 00:40:41,260

835
00:40:41,260 --> 00:40:45,415
>> 是啊，所以我們實際上可以
退出調試器在這裡。

836
00:40:45,415 --> 00:40:47,040
因此，讓我們來看看我們的偽代碼。

837
00:40:47,040 --> 00:40:50,070

838
00:40:50,070 --> 00:40:52,580
For--我們要
開始我等於0。

839
00:40:52,580 --> 00:40:54,760
我們要上浮到n減去1。

840
00:40:54,760 --> 00:40:58,040
讓我們來看看，沒我們有這個權利？

841
00:40:58,040 --> 00:40:59,580
是的，這是正確的。

842
00:40:59,580 --> 00:41:02,080
>> 因此，然後在裡面在這裡，我們
要創建一個最小值

843
00:41:02,080 --> 00:41:03,630
並設置等於i。

844
00:41:03,630 --> 00:41:04,950
難道我們這樣做嗎？

845
00:41:04,950 --> 00:41:06,270
是的，這樣做。

846
00:41:06,270 --> 00:41:10,430
現在，在我們內心的for循環中，我們
要做到j為我到n減去1。

847
00:41:10,430 --> 00:41:11,950
難道我們這樣做嗎？

848
00:41:11,950 --> 00:41:15,540
事實上，我們做到了。

849
00:41:15,540 --> 00:41:19,922
>> 所以，不管，什麼是我們比較嗎？

850
00:41:19,922 --> 00:41:20,925
>> 聽眾：J-加1。

851
00:41:20,925 --> 00:41:21,716
ANDI鵬：沒錯。

852
00:41:21,716 --> 00:41:24,184

853
00:41:24,184 --> 00:41:27,350
然後你會想設置
您的最低等於到j加1為好。

854
00:41:27,350 --> 00:41:31,057

855
00:41:31,057 --> 00:41:32,640
所以，我通過真的很快去了。

856
00:41:32,640 --> 00:41:36,190
難道你們明白
為什麼它的殲加1？

857
00:41:36,190 --> 00:41:36,890
確定。

858
00:41:36,890 --> 00:41:40,700
>> 因此，在你的陣列，在
你的第一個闖關，

859
00:41:40,700 --> 00:41:44,850
你的for循環，對於int
i等於0，我們只

860
00:41:44,850 --> 00:41:46,740
假設這並沒有改變呢。

861
00:41:46,740 --> 00:41:53,180

862
00:41:53,180 --> 00:41:56,760
我們的陣列，完全，
短短四年未排序的元素，對不對？

863
00:41:56,760 --> 00:42:00,760
因此，我們要初始化i等於0。

864
00:42:00,760 --> 00:42:03,650
而我是要只
通過這個循環運行。

865
00:42:03,650 --> 00:42:08,560
因此在第一輪，我們要
初始化一個名為“分”變

866
00:42:08,560 --> 00:42:11,245
這也等於我，因為
我們沒有一個最小值。

867
00:42:11,245 --> 00:42:12,870
所以這是當前等於0為好。

868
00:42:12,870 --> 00:42:16,182

869
00:42:16,182 --> 00:42:17,640
然後，我們將經歷。

870
00:42:17,640 --> 00:42:19,270
我們想再次重複。

871
00:42:19,270 --> 00:42:22,900
現在我們已經找到了我們的最低
是，我們要遍歷

872
00:42:22,900 --> 00:42:25,190
再看看它的比較，對不對？

873
00:42:25,190 --> 00:42:40,440
所以Ĵ，在這裡，是怎麼回事
等於I，這是0。

874
00:42:40,440 --> 00:42:46,320
然後，如果陣列Ĵ再加上我，這
就是一個​​是下完了，一樣都不能少

875
00:42:46,320 --> 00:42:49,270
比你目前的最低
值，要交換。

876
00:42:49,270 --> 00:42:56,850
>> 所以，讓我們只說我們已經
有，像，2，5，1，8。

877
00:42:56,850 --> 00:43:01,610
現在，我等於
0和j是等於0。

878
00:43:01,610 --> 00:43:05,210
這就是我們的最低值。

879
00:43:05,210 --> 00:43:09,950
如果陣列-j的加I--因此如果所述一個
這就是我們正在尋找在一前一後

880
00:43:09,950 --> 00:43:13,450
大於前一，
這將成為最低。

881
00:43:13,450 --> 00:43:18,120
>> 所以在這裡我們可以看到，5
是不遜色。

882
00:43:18,120 --> 00:43:19,730
因此，這將不會是5。

883
00:43:19,730 --> 00:43:23,580
我們看到，1小於2，對不對？

884
00:43:23,580 --> 00:43:32,970
所以，現在我們知道，我們的最低是
將是0，1，2的指數值。

885
00:43:32,970 --> 00:43:34,030
是嗎？

886
00:43:34,030 --> 00:43:39,170
然後當你到這裡，
你可以交換正確的價值觀。

887
00:43:39,170 --> 00:43:42,610
>> 所以，當你們剛剛有第j
之前，你是不是在看一

888
00:43:42,610 --> 00:43:43,260
後。

889
00:43:43,260 --> 00:43:44,520
你在看
相同的值，這

890
00:43:44,520 --> 00:43:46,290
就是為什麼它只是沒有做任何事情。

891
00:43:46,290 --> 00:43:49,721
這是否有意義給大家，
為什麼我們需要一個加1呢？

892
00:43:49,721 --> 00:43:50,220
確定。

893
00:43:50,220 --> 00:43:53,345
現在，讓我們只運行通過它來作
確認代碼的其餘部分是正確的。

894
00:43:53,345 --> 00:44:04,424

895
00:44:04,424 --> 00:44:05,340
這是為什麼發生？

896
00:44:05,340 --> 00:44:14,780

897
00:44:14,780 --> 00:44:16,364
啊，這是分就在這裡。

898
00:44:16,364 --> 00:44:17,780
我們比較了錯誤的值。

899
00:44:17,780 --> 00:44:24,944

900
00:44:24,944 --> 00:44:25,906
哦，不。

901
00:44:25,906 --> 00:44:30,720

902
00:44:30,720 --> 00:44:33,482
>> 哦，是的，在這兒我們
交換了錯誤的值也是如此。

903
00:44:33,482 --> 00:44:34,940
因為我們在看i和j。

904
00:44:34,940 --> 00:44:36,440
這些都是那些我們被檢查。

905
00:44:36,440 --> 00:44:39,160
事實上，我們希望交換的
至少，目前最低，

906
00:44:39,160 --> 00:44:40,550
與任何一個外面。

907
00:44:40,550 --> 00:44:59,510

908
00:44:59,510 --> 00:45:05,402
正如你們所看到下跌
在這裡，我們有一個排序的數組。

909
00:45:05,402 --> 00:45:07,110
這只是不得不做
事實，當

910
00:45:07,110 --> 00:45:09,350
我們被檢查
值的我們相比，

911
00:45:09,350 --> 00:45:11,226
我們不看正確的價值觀。

912
00:45:11,226 --> 00:45:13,850
我們在看的同一個
在這裡，沒有實際交換它。

913
00:45:13,850 --> 00:45:17,135
你要看看一個接一個
它，然後你可以交換。

914
00:45:17,135 --> 00:45:19,260
所以，這是什麼樣的
前纏著我們的代碼。

915
00:45:19,260 --> 00:45:22,460
而我在這裡所做的一切
調試器可以為你做

916
00:45:22,460 --> 00:45:23,810
我只是做了它的
板，因為它更容易

917
00:45:23,810 --> 00:45:26,320
看而不是試圖
可放大的調試器。

918
00:45:26,320 --> 00:45:29,391
這是否有意義給大家？

919
00:45:29,391 --> 00:45:29,890
酷。

920
00:45:29,890 --> 00:45:34,800

921
00:45:34,800 --> 00:45:35,410
>> 好的。

922
00:45:35,410 --> 00:45:41,070
我們可以繼續談
漸近符號，這

923
00:45:41,070 --> 00:45:44,580
是說的只是一種奇特的方式
所有這些各種各樣的運行時間。

924
00:45:44,580 --> 00:45:47,650
所以我知道大衛在演講中，
在運行時感動。

925
00:45:47,650 --> 00:45:52,124
他走遍了整個公式
如何計算的運行時。

926
00:45:52,124 --> 00:45:53,040
關於無後顧之憂。

927
00:45:53,040 --> 00:45:54,660
如果你真的很好奇
其工作原理，

928
00:45:54,660 --> 00:45:55,810
隨時節後跟我說話。

929
00:45:55,810 --> 00:45:57,560
我們可以穿行
公式在一起。

930
00:45:57,560 --> 00:46:00,689
但是，所有你們要真
知道是n的平方超過2

931
00:46:00,689 --> 00:46:01,980
是同樣的事情為N的平方。

932
00:46:01,980 --> 00:46:04,710
因為最大數目，
該指數增長最。

933
00:46:04,710 --> 00:46:06,590
所以我們的目的，
我們關心的

934
00:46:06,590 --> 00:46:09,470
是巨大的數量也在不斷增長。

935
00:46:09,470 --> 00:46:13,340
>> 那麼，什麼是最好的情況下，
選擇排序的運行時間？

936
00:46:13,340 --> 00:46:15,830
如果你想有
遍歷列表

937
00:46:15,830 --> 00:46:18,712
然後遍歷
該列表的其餘部分，

938
00:46:18,712 --> 00:46:20,420
多少次都
你要大概，

939
00:46:20,420 --> 00:46:24,612
在最壞的case--在
最好的情況下，sorry--跑過來嗎？

940
00:46:24,612 --> 00:46:27,070
也許更好的問題是
要問，什麼是最壞的情況下

941
00:46:27,070 --> 00:46:28,153
運行時選擇排序的。

942
00:46:28,153 --> 00:46:29,366
聽眾：N的平方。

943
00:46:29,366 --> 00:46:30,740
ANDI彭：這n值的平方，正確的。

944
00:46:30,740 --> 00:46:36,986
因此，一個簡單的方法來認為這是喜歡，
任何時候你有兩個嵌套的for循環，

945
00:46:36,986 --> 00:46:38,110
它會為n的平方。

946
00:46:38,110 --> 00:46:40,386
因為不僅是你
通過再次運行，

947
00:46:40,386 --> 00:46:42,260
你要回去
周圍，並通過它運行

948
00:46:42,260 --> 00:46:44,980
裡面的每一個值一次。

949
00:46:44,980 --> 00:46:48,640
因此，在這種情況下，你在行駛中N
n次平方，這is--抱歉，

950
00:46:48,640 --> 00:46:50,505
n次N，這等於N的平方。

951
00:46:50,505 --> 00:46:53,230

952
00:46:53,230 --> 00:46:56,360
>> 和排序也有點
在這個意義上獨特

953
00:46:56,360 --> 00:46:59,774
它不如果這些關係
值已經在秩序。

954
00:46:59,774 --> 00:47:01,440
它仍然會通過反正運行。

955
00:47:01,440 --> 00:47:03,872
遠的不說，這是1，2，3，4。

956
00:47:03,872 --> 00:47:07,080
不管它是否是在
命令，它仍然會通過跑

957
00:47:07,080 --> 00:47:08,620
並且仍然檢查的最小值。

958
00:47:08,620 --> 00:47:10,100
它會作出
檢查相同數量的

959
00:47:10,100 --> 00:47:12,780
每一次，即使它
實際上並沒有碰任何東西。

960
00:47:12,780 --> 00:47:16,940
>> 因此，在這樣的情況下，最好和最差
運行時實際上是等價的。

961
00:47:16,940 --> 00:47:19,160
因此，預計運行時間
選擇排序的，

962
00:47:19,160 --> 00:47:23,790
這是我們指定的符號
的θ，θ-，在這種情況下，

963
00:47:23,790 --> 00:47:24,790
還將為n的平方。

964
00:47:24,790 --> 00:47:26,480
所有這三個為N的平方。

965
00:47:26,480 --> 00:47:29,653
是為什麼每個人都清楚
運行時間為n的平方？

966
00:47:29,653 --> 00:47:33,360

967
00:47:33,360 --> 00:47:33,980
>> 好的。

968
00:47:33,980 --> 00:47:39,120
所以我只是要快速運行
通過對各種休息。

969
00:47:39,120 --> 00:47:41,137
該算法
泡泡類別 - 記住，

970
00:47:41,137 --> 00:47:43,220
這是第一個
大衛走過去的講座。

971
00:47:43,220 --> 00:47:46,000
從本質上講，你一步
整個列表

972
00:47:46,000 --> 00:47:48,950
你剛才swap--你
同時比較兩個。

973
00:47:48,950 --> 00:47:51,350
而如果一個人的更大，
比你只是換他們。

974
00:47:51,350 --> 00:47:53,590
因此，如果這些是更大的，你就掉。

975
00:47:53,590 --> 00:47:56,180
我已經得到了官方的就在這裡。

976
00:47:56,180 --> 00:47:59,100
>> 因此，讓我們只說你有8個，6個，4個，2。

977
00:47:59,100 --> 00:48:00,571
你會比較8和6。

978
00:48:00,571 --> 00:48:01,570
你需要交換它們。

979
00:48:01,570 --> 00:48:02,610
您會比較8和4。

980
00:48:02,610 --> 00:48:03,609
你需要交換它們。

981
00:48:03,609 --> 00:48:07,000
如果您有交換8
2，改變他們。

982
00:48:07,000 --> 00:48:10,760
因此，在這樣的意義上，你可以看到，
發揮出了相當長的時間週期，

983
00:48:10,760 --> 00:48:13,730
怎麼樣值泡沫來
兩端，這就是為什麼我們叫它

984
00:48:13,730 --> 00:48:15,320
冒泡排序。

985
00:48:15,320 --> 00:48:19,950
>> 我們只想上運行再次通過
我們的二傳，而我們的第三關，

986
00:48:19,950 --> 00:48:21,150
而我們的第四個階段。

987
00:48:21,150 --> 00:48:25,820
從本質上講，冒泡排序只是運行
直到你不作任何更多的互換。

988
00:48:25,820 --> 00:48:31,109
因此，在這個意義上，這僅僅是
一般偽它。

989
00:48:31,109 --> 00:48:32,650
不用擔心，這些都將在網上。

990
00:48:32,650 --> 00:48:34,990
我們沒有真正去了這一點。

991
00:48:34,990 --> 00:48:38,134
>> 我們只是初始化一個計數器
從0開始的變量。

992
00:48:38,134 --> 00:48:39,800
而我們通過整個數組迭代。

993
00:48:39,800 --> 00:48:43,420
如果一個值is--如果這
值大於該值，

994
00:48:43,420 --> 00:48:44,610
你要交換它們。

995
00:48:44,610 --> 00:48:46,860
然後，你只是
要繼續下去。

996
00:48:46,860 --> 00:48:47,970
而你要算。

997
00:48:47,970 --> 00:48:50,845
而你只是要繼續做
這同時計數器的值大

998
00:48:50,845 --> 00:48:53,345
大於0，這意味著
每次你要交換，

999
00:48:53,345 --> 00:48:55,220
你知道你想要去
回去檢查一次。

1000
00:48:55,220 --> 00:48:59,510
你要繼續檢查，直到你知道
你不必換了。

1001
00:48:59,510 --> 00:49:05,570
>> 那麼，什麼是最好的和最差
情況下的運行時間冒泡排序？

1002
00:49:05,570 --> 00:49:09,300
這hint--實際上是不同的
從某種意義上選擇排序

1003
00:49:09,300 --> 00:49:11,810
這兩個答案是不一樣的。

1004
00:49:11,810 --> 00:49:14,709
想想會發生什麼
的情況下，如果它已經被排序。

1005
00:49:14,709 --> 00:49:16,500
想想什麼
如果它是會發生

1006
00:49:16,500 --> 00:49:18,372
在的情況下在它被排序。

1007
00:49:18,372 --> 00:49:20,580
你可以種運行
通過為什麼會發生的事情。

1008
00:49:20,580 --> 00:49:22,954
我給你們一樣，30
秒，想想。

1009
00:49:22,954 --> 00:49:52,330

1010
00:49:52,330 --> 00:49:53,540
>> 確定。

1011
00:49:53,540 --> 00:49:57,462
是否有人在猜測什麼
冒泡排序的最壞情況下的運行時間是？

1012
00:49:57,462 --> 00:49:57,962
是啊。

1013
00:49:57,962 --> 00:50:07,810
>> 聽眾：會是一樣，n次
ñ減1或類似的東西？

1014
00:50:07,810 --> 00:50:10,650
像，每次運行時，
它只是一樣，一個交換少

1015
00:50:10,650 --> 00:50:10,960
這不管是什麼。

1016
00:50:10,960 --> 00:50:12,668
>> ANDI彭：是啊，所以
你是完全正確的。

1017
00:50:12,668 --> 00:50:15,940
這是在這種情況下你
答案竟是更複雜

1018
00:50:15,940 --> 00:50:17,240
比我們需要給。

1019
00:50:17,240 --> 00:50:19,772
因此，這將run--我
要刪除這一切都在這裡。

1020
00:50:19,772 --> 00:50:20,480
是每個人都好？

1021
00:50:20,480 --> 00:50:21,869
我能抹去嗎？

1022
00:50:21,869 --> 00:50:22,368
確定。

1023
00:50:22,368 --> 00:50:27,904

1024
00:50:27,904 --> 00:50:30,320
你會到n運行
第一次時間，對吧？

1025
00:50:30,320 --> 00:50:33,200
他們正在經歷的運行
Ñ​​減去1秒的時間，對吧？

1026
00:50:33,200 --> 00:50:37,130
然後，你要保持
去，N礦2，等等。

1027
00:50:37,130 --> 00:50:40,210
大衛這樣做的講座，其中，
如果你加起來所有的值，

1028
00:50:40,210 --> 00:50:48,080
你得到的東西，是like-- yeah--
超過2，這本質上只是減少

1029
00:50:48,080 --> 00:50:49,784
下降到n的平方。

1030
00:50:49,784 --> 00:50:51,700
你會得到一個
怪異的部分在裡面。

1031
00:50:51,700 --> 00:50:53,892
所以只要知道
第n總是平方

1032
00:50:53,892 --> 00:50:55,350
優先於分數。

1033
00:50:55,350 --> 00:50:58,450
因此在這種情況下，最壞的
運行時間為N的平方。

1034
00:50:58,450 --> 00:51:00,210
如果它是在降
順序，想想，你

1035
00:51:00,210 --> 00:51:02,530
不得不做出交換每一次。

1036
00:51:02,530 --> 00:51:05,170
>> 什麼是潛在的，
最好的情況下運行？

1037
00:51:05,170 --> 00:51:08,580
這麼說吧，如果列表已經
為了，你會在運行時？

1038
00:51:08,580 --> 00:51:09,565
>> 聽眾：N。

1039
00:51:09,565 --> 00:51:10,690
ANDI彭：這是N，正好。

1040
00:51:10,690 --> 00:51:11,600
為什麼是這N +

1041
00:51:11,600 --> 00:51:13,850
聽眾：因為你剛才
必須檢查每一次。

1042
00:51:13,850 --> 00:51:14,770
ANDI鵬：沒錯。

1043
00:51:14,770 --> 00:51:17,150
因此，在可能的最佳運行時，
如果此列表中已經

1044
00:51:17,150 --> 00:51:20,270
sorted--比方說，1，2，3，4--您
只想去實現它，你會檢查，

1045
00:51:20,270 --> 00:51:21,720
你會看到，哦，他們都做成。

1046
00:51:21,720 --> 00:51:22,636
我沒得換。

1047
00:51:22,636 --> 00:51:23,370
我完成了。

1048
00:51:23,370 --> 00:51:26,500
因此，在這種情況下，它僅僅局限於N
或步數，你只是

1049
00:51:26,500 --> 00:51:29,870
不得不檢查的第一個列表。

1050
00:51:29,870 --> 00:51:33,990
>> 及後，我們現在打
插入排序，其中，

1051
00:51:33,990 --> 00:51:39,260
該算法本質上是鴻溝
它變成一個排序和未排序的部分。

1052
00:51:39,260 --> 00:51:42,810
然後一個接一個，
未排序值

1053
00:51:42,810 --> 00:51:46,880
在其相應插
在列表的開頭位置。

1054
00:51:46,880 --> 00:51:52,120
>> 因此，例如，我們有一個
的3名單，5,2，6,4試。

1055
00:51:52,120 --> 00:51:54,750
我們知道，這是目前
未分類的，因為我們剛剛

1056
00:51:54,750 --> 00:51:57,030
開始尋找它。

1057
00:51:57,030 --> 00:52:00,610
我們來看看，我們知道，
第一個值進行排序，對吧？

1058
00:52:00,610 --> 00:52:04,190
如果你只關注一個數組
尺寸之一，你知道它的排序。

1059
00:52:04,190 --> 00:52:08,230
>> 於是我們知道，
其他四個都是無序。

1060
00:52:08,230 --> 00:52:10,980
我們通過和我們看到的價值。

1061
00:52:10,980 --> 00:52:11,730
讓我們回去。

1062
00:52:11,730 --> 00:52:13,130
見5的價值？

1063
00:52:13,130 --> 00:52:14,110
我們來看看它。

1064
00:52:14,110 --> 00:52:15,204
我們把它比作3。

1065
00:52:15,204 --> 00:52:17,870
我們知道，它是大於
3，讓我們知道，多數民眾贊成排序。

1066
00:52:17,870 --> 00:52:22,940
所以，現在我們知道，前兩個
進行排序和最後三個不是。

1067
00:52:22,940 --> 00:52:24,270
>> 我們來看看2。

1068
00:52:24,270 --> 00:52:25,720
我們首先檢查一下與5。

1069
00:52:25,720 --> 00:52:26,700
是小於5？

1070
00:52:26,700 --> 00:52:27,240
事實並非如此。

1071
00:52:27,240 --> 00:52:29,510
因此，我們必須繼續找下去。

1072
00:52:29,510 --> 00:52:30,940
然後檢查2關閉3。

1073
00:52:30,940 --> 00:52:31,850
是小於？

1074
00:52:31,850 --> 00:52:32,350
第

1075
00:52:32,350 --> 00:52:35,430
所以，你知道2必須插入
入前和3和5

1076
00:52:35,430 --> 00:52:38,200
都必須被推出。

1077
00:52:38,200 --> 00:52:42,190
6和4再次做到這一點。

1078
00:52:42,190 --> 00:52:48,962
我們只是保持檢查從本質上講，
在這裡我們只是檢查，檢查，檢查。

1079
00:52:48,962 --> 00:52:51,170
而直到它在正確的
樣的位置，我們只是

1080
00:52:51,170 --> 00:52:54,890
將其插入合適的位置，
這就是它的名字是從哪裡來的。

1081
00:52:54,890 --> 00:52:59,830
>> 所以，這僅僅是算法，
那種偽代碼本身，

1082
00:52:59,830 --> 00:53:04,990
關於我們如何實現
插入排序。

1083
00:53:04,990 --> 00:53:05,954
偽代碼是在這裡。

1084
00:53:05,954 --> 00:53:06,620
這一切都在網上。

1085
00:53:06,620 --> 00:53:10,720
不，如果你們有隱憂
試圖複製下來。

1086
00:53:10,720 --> 00:53:14,500
所以再次，相同的問題 - 是什麼
將是最好的和最差的運行時間

1087
00:53:14,500 --> 00:53:16,120
插入排序？

1088
00:53:16,120 --> 00:53:17,750
這是非常相似的最後一個問題。

1089
00:53:17,750 --> 00:53:20,479
我給你們一樣，30
秒想想這一點。

1090
00:53:20,479 --> 00:53:47,150

1091
00:53:47,150 --> 00:53:50,071
>> 確定有沒有人要
給我最糟糕的運行？

1092
00:53:50,071 --> 00:53:50,570
是啊。

1093
00:53:50,570 --> 00:53:51,490
>> 聽眾：N的平方。

1094
00:53:51,490 --> 00:53:52,573
>> ANDI彭：這n值的平方。

1095
00:53:52,573 --> 00:53:53,730
為什麼它Ñ平方？

1096
00:53:53,730 --> 00:53:57,562
>> 聽眾：因為在
相反的順序，你有

1097
00:53:57,562 --> 00:54:02,619
要經過n次N，其中is--

1098
00:54:02,619 --> 00:54:03,660
ANDI彭：是的，沒錯。

1099
00:54:03,660 --> 00:54:06,610
所以，同樣的事情在冒泡排序。

1100
00:54:06,610 --> 00:54:08,720
如果此列表中
降序排列，你

1101
00:54:08,720 --> 00:54:11,240
不得不先檢查一次。

1102
00:54:11,240 --> 00:54:13,470
然後每
額外的價值，你

1103
00:54:13,470 --> 00:54:16,390
將不得不對檢查
每一個值，對不對？

1104
00:54:16,390 --> 00:54:20,290
所以乾脆，你會做
正通時代另外N通，這

1105
00:54:20,290 --> 00:54:21,750
為n的平方。

1106
00:54:21,750 --> 00:54:22,860
那麼最好的情況？

1107
00:54:22,860 --> 00:54:24,360
是啊。

1108
00:54:24,360 --> 00:54:28,840
>> 聽眾：N減1，因為
第一個是已經平方。

1109
00:54:28,840 --> 00:54:30,270
>> ANDI彭：那麼，關閉。

1110
00:54:30,270 --> 00:54:31,850
其實答案ñ。

1111
00:54:31,850 --> 00:54:37,189
因為當第一個是
排序，也可以不actually--它

1112
00:54:37,189 --> 00:54:38,980
我們只是走運了，在
即例如，2

1113
00:54:38,980 --> 00:54:40,930
正好是最小的數目。

1114
00:54:40,930 --> 00:54:43,680
但是，這不會總是這種情況。

1115
00:54:43,680 --> 00:54:48,040
如果2已經排序的開始
但是你看，有一個1在這裡，

1116
00:54:48,040 --> 00:54:49,144
1將要碰撞。

1117
00:54:49,144 --> 00:54:51,060
而這將結束
最多被撞毀反正。

1118
00:54:51,060 --> 00:54:56,250
>> 因此，在最好的情況下，
它實際上只是要為n。

1119
00:54:56,250 --> 00:54:59,090
如果有1個，2個，3個，
4，5，6，7，8，你

1120
00:54:59,090 --> 00:55:00,940
經過運行
這整個列表一次

1121
00:55:00,940 --> 00:55:03,430
檢查，如果一切都很好看。

1122
00:55:03,430 --> 00:55:07,390
在其上運行大家清楚
選擇的時候呢？

1123
00:55:07,390 --> 00:55:09,960
我知道我經歷
這些真快。

1124
00:55:09,960 --> 00:55:13,330
但是，僅僅知道，如果你知道
一般概念，您應該不錯。

1125
00:55:13,330 --> 00:55:16,070
確定。

1126
00:55:16,070 --> 00:55:19,790
所以，我只是給你們也許一樣，
一分鐘談談你的鄰居

1127
00:55:19,790 --> 00:55:21,890
什麼都只是一些
的主要區別

1128
00:55:21,890 --> 00:55:23,540
與這些類型的排序。

1129
00:55:23,540 --> 00:56:24,571

1130
00:56:24,571 --> 00:56:25,570
我們一起去了很快。

1131
00:56:25,570 --> 00:56:26,444
聽眾：哦，好。

1132
00:56:26,444 --> 00:56:27,320
ANDI彭：是的。

1133
00:56:27,320 --> 00:56:28,380
確定。

1134
00:56:28,380 --> 00:56:33,420
酷，讓我們重新召集的一類。

1135
00:56:33,420 --> 00:56:34,330
確定。

1136
00:56:34,330 --> 00:56:37,579
所以，這是一種一
在這個意義上開放式的問題

1137
00:56:37,579 --> 00:56:39,120
這有很多他​​們的答案的。

1138
00:56:39,120 --> 00:56:40,746
我們將介紹一些他們的簡要介紹。

1139
00:56:40,746 --> 00:56:43,411
我只想讓你們
思考什麼區別

1140
00:56:43,411 --> 00:56:44,530
這三種類型的排序。

1141
00:56:44,530 --> 00:56:47,440
而且我聽說，也有很大
的問題 - 是什麼歸併排序呢？

1142
00:56:47,440 --> 00:56:50,110
大的問題，因為這是
我們正在覆蓋下一個。

1143
00:56:50,110 --> 00:56:52,850
>> 所以，歸併排序是
一個分類的功能

1144
00:56:52,850 --> 00:56:56,100
非常不同於其他種類。

1145
00:56:56,100 --> 00:56:58,180
正如你們可以see--
David是不是做演示

1146
00:56:58,180 --> 00:57:01,130
在那裡，他把所有的酷
看到如何合併的聲音

1147
00:57:01,130 --> 00:57:04,010
排序跑了一樣，無限
比其他兩種類型的快？

1148
00:57:04,010 --> 00:57:04,510
確定。

1149
00:57:04,510 --> 00:57:07,580
所以，這是因為合併
排序實現了鴻溝

1150
00:57:07,580 --> 00:57:11,020
而治之的概念，我們已經
談到了很多在課堂上。

1151
00:57:11,020 --> 00:57:14,550
在這個意義上，我們喜歡的工作
更聰明，而不是更辛苦，當你把

1152
00:57:14,550 --> 00:57:18,120
而治之的問題，並打破他們
下來，然後把它們放在一起，

1153
00:57:18,120 --> 00:57:19,930
美好的事物總是發生。

1154
00:57:19,930 --> 00:57:21,960
>> 這樣合併的方式
排序基本工作原理

1155
00:57:21,960 --> 00:57:24,660
是，它把一個
無序陣列中的一半。

1156
00:57:24,660 --> 00:57:26,500
然後它有陣列的兩半。

1157
00:57:26,500 --> 00:57:28,220
它只是排序那些兩半。

1158
00:57:28,220 --> 00:57:31,750
它只是保持在半分，在
一半，一半，直到萬事俱備

1159
00:57:31,750 --> 00:57:33,680
然後遞歸
把他們放在一起。

1160
00:57:33,680 --> 00:57:36,550
>> 這就是真正的抽象。

1161
00:57:36,550 --> 00:57:38,750
所以，這只是一個有點偽的。

1162
00:57:38,750 --> 00:57:41,040
這是否有意義的
它的運行方式？

1163
00:57:41,040 --> 00:57:43,870
因此，讓我們只說你有一個
n個元素的數組，對不對？

1164
00:57:43,870 --> 00:57:45,450
如果n小於2，可以退貨。

1165
00:57:45,450 --> 00:57:49,040
因為你知道，如果有
只有一件事，它必須被排序。

1166
00:57:49,040 --> 00:57:52,600
否則，你排序左前衛，
然後排序的右半​​部分，

1167
00:57:52,600 --> 00:57:54,140
然後合併。

1168
00:57:54,140 --> 00:57:56,979
>> 因此，雖然看起來很容易，
在現實中，思考它的

1169
00:57:56,979 --> 00:58:00,270
樣的困難。因為你喜歡，
嗯，這是運行的一種自身。

1170
00:58:00,270 --> 00:58:00,769
對嗎？

1171
00:58:00,769 --> 00:58:02,430
它本身運行。

1172
00:58:02,430 --> 00:58:05,479
因此，在這個意義上，大衛·感動
在遞歸類。

1173
00:58:05,479 --> 00:58:07,270
這是一個概念
我們將談論更多。

1174
00:58:07,270 --> 00:58:11,430
那就是這一點，這兩條線
在這裡，其實只是節目

1175
00:58:11,430 --> 00:58:13,860
告訴它運行本身
與不同的輸入。

1176
00:58:13,860 --> 00:58:17,230
因此，而不是與運行本身
n個元素的全部，

1177
00:58:17,230 --> 00:58:20,530
你可以把它分解成的
左半部和右半

1178
00:58:20,530 --> 00:58:22,680
然後再運行它。

1179
00:58:22,680 --> 00:58:26,050
>> 然後我們來看看它在視覺上，
因為我是一個視覺學習者。

1180
00:58:26,050 --> 00:58:27,270
它為我好。

1181
00:58:27,270 --> 00:58:29,890
所以，我們來看看一個可視化的例子在這裡。

1182
00:58:29,890 --> 00:58:36,237
>> 比方說，我們有一個數組，六
元素，3，5，2,6，4,1，不進行排序。

1183
00:58:36,237 --> 00:58:37,820
好吧，有很多這個頁面上。

1184
00:58:37,820 --> 00:58:43,179
所以，如果你們可以看看
這裡第一步驟中，3，5，2,6，4,1，

1185
00:58:43,179 --> 00:58:44,220
您可以在一半分裂它。

1186
00:58:44,220 --> 00:58:45,976
您有3個，5個，2，6,4，1。

1187
00:58:45,976 --> 00:58:48,850
你知道這些aren't--您
不知道他們正在排序或沒有，

1188
00:58:48,850 --> 00:58:52,517
所以你把它們分解，在上半年，
成兩半，一半，直至最後，

1189
00:58:52,517 --> 00:58:53,600
你只有一個元素。

1190
00:58:53,600 --> 00:58:56,790
而一個元素總是排序，對吧？

1191
00:58:56,790 --> 00:59:01,560
>> 因此，我們知道，3，5，2，4，6，
1，由本身，進行排序。

1192
00:59:01,560 --> 00:59:05,870
現在，我們可以把他們重新走到一起。

1193
00:59:05,870 --> 00:59:07,510
因此，我們知道的3,5。

1194
00:59:07,510 --> 00:59:08,510
我們把這些在一起。

1195
00:59:08,510 --> 00:59:09,617
我們知道這是排序。

1196
00:59:09,617 --> 00:59:10,450
2.仍然存在。

1197
00:59:10,450 --> 00:59:11,830
我們可以把4和6一起。

1198
00:59:11,830 --> 00:59:13,996
我們知道，多數民眾贊成排序，
所以我們這身打扮。

1199
00:59:13,996 --> 00:59:14,940
而1是存在的。

1200
00:59:14,940 --> 00:59:18,720
>> 然後你只要看看
這兩個半就在這裡。

1201
00:59:18,720 --> 00:59:21,300
你有3,5，2，2，3，5。

1202
00:59:21,300 --> 00:59:23,465
你可以只比較
開始的一切。

1203
00:59:23,465 --> 00:59:26,340
因為你知道，這是排序
你知道，多數民眾贊成排序。

1204
00:59:26,340 --> 00:59:29,360
所以，那麼你甚至沒有給
對比5，你只要比較一下3。

1205
00:59:29,360 --> 00:59:32,070
和2小於3，所以
你知道2必須走到底。

1206
00:59:32,070 --> 00:59:33,120
>> 同樣的事情在那邊。

1207
00:59:33,120 --> 00:59:34,740
1.必須在這裡。

1208
00:59:34,740 --> 00:59:37,330
然後，當你去把
這兩個值加在一起，

1209
00:59:37,330 --> 00:59:39,950
你知道，這是分類和
你知道這是排序。

1210
00:59:39,950 --> 00:59:43,240
於是在1和
圖2中，1是小於2。

1211
00:59:43,240 --> 00:59:45,570
這告訴你，1
應該在本月底

1212
00:59:45,570 --> 00:59:47,480
看也不看3或5。

1213
00:59:47,480 --> 00:59:50,100
然後是4，你可以
檢查，它會就在這裡。

1214
00:59:50,100 --> 00:59:51,480
你不必看5。

1215
00:59:51,480 --> 00:59:52,570
同樣的事情在6。

1216
00:59:52,570 --> 00:59:55,860
你知道6--它只是
並不需要研究。

1217
00:59:55,860 --> 00:59:57,870
>> 所以這樣一來，你是
只是拯救自己

1218
00:59:57,870 --> 00:59:59,526
很多步驟，當你比較。

1219
00:59:59,526 --> 01:00:02,150
你不必比較每
元素與其他元素。

1220
01:00:02,150 --> 01:00:05,230
你只是比較反對的人
你需要將它與比較。

1221
01:00:05,230 --> 01:00:06,870
所以這是一種抽象的概念。

1222
01:00:06,870 --> 01:00:10,540
不用擔心，如果它不是
相當擊中你的權利呢。

1223
01:00:10,540 --> 01:00:14,740
但是總體來說，這是
如何合併排序工作。

1224
01:00:14,740 --> 01:00:17,750
問題，簡單的問題，
之前，我繼續前進？

1225
01:00:17,750 --> 01:00:18,550
是啊。

1226
01:00:18,550 --> 01:00:22,230
>> 聽眾：所以你說，你拿
1，然後在4和6

1227
01:00:22,230 --> 01:00:23,860
並把他們進來。

1228
01:00:23,860 --> 01:00:26,800
所以不those--不
你看他們

1229
01:00:26,800 --> 01:00:28,544
作為單獨的元素，而不是整？

1230
01:00:28,544 --> 01:00:29,210
ANDI彭：是的。

1231
01:00:29,210 --> 01:00:32,020
所以發生了什麼
是，你基本上

1232
01:00:32,020 --> 01:00:33,650
正在創造一個全新的陣列。

1233
01:00:33,650 --> 01:00:36,690
所以，你知道，在這裡，我有
尺寸3的兩個數組，對不對？

1234
01:00:36,690 --> 01:00:39,600
所以，你知道，我的排序的數組
需要有六個要素。

1235
01:00:39,600 --> 01:00:42,270
所以，你只要創建一個
新的內存量。

1236
01:00:42,270 --> 01:00:44,270
所以，你是那種喜​​歡
被浪費的存儲器，

1237
01:00:44,270 --> 01:00:46,186
但是，這並不重要
因為它是如此之小。

1238
01:00:46,186 --> 01:00:48,590
所以，你看1
你看2。

1239
01:00:48,590 --> 01:00:50,770
而你知道，1小於2。

1240
01:00:50,770 --> 01:00:53,840
所以，你知道，1應該在
所有這些的開始。

1241
01:00:53,840 --> 01:00:55,850
>> 你甚至都不需要
看3和5。

1242
01:00:55,850 --> 01:00:57,400
所以，你知道1去那裡。

1243
01:00:57,400 --> 01:00:59,300
然後，你基本上砍掉1。

1244
01:00:59,300 --> 01:01:00,370
這是一樣，死了我們。

1245
01:01:00,370 --> 01:01:03,690
然後，我們只是有2個，
3，5，然後4和6。

1246
01:01:03,690 --> 01:01:06,270
然後你知道，你
比較4和2，

1247
01:01:06,270 --> 01:01:07,560
呵呵，2應該在那裡。

1248
01:01:07,560 --> 01:01:09,685
所以，你撲通2下來，你砍了下來。

1249
01:01:09,685 --> 01:01:12,060
所以，那麼你只需要3
和5中的4個和6個。

1250
01:01:12,060 --> 01:01:14,650
而你只是不斷砍它關閉
直到你把他們到數組中。

1251
01:01:14,650 --> 01:01:17,110
>> 聽眾：所以，你只是總是
比較[聽不清]？

1252
01:01:17,110 --> 01:01:17,710
>> ANDI鵬：沒錯。

1253
01:01:17,710 --> 01:01:19,590
因此，在這個意義上說，你是
只是相比較，從本質上講，

1254
01:01:19,590 --> 01:01:21,240
一個號碼對另一個號碼。

1255
01:01:21,240 --> 01:01:22,990
而且因為你知道
，它的排序，

1256
01:01:22,990 --> 01:01:24,350
不必翻閱
所有的數值。

1257
01:01:24,350 --> 01:01:25,870
你只需要看看第一個。

1258
01:01:25,870 --> 01:01:27,582
然後你可以撲通
下來，因為你知道

1259
01:01:27,582 --> 01:01:29,640
他們屬於他們需要屬於。

1260
01:01:29,640 --> 01:01:31,030
是啊。

1261
01:01:31,030 --> 01:01:32,920
好問題。

1262
01:01:32,920 --> 01:01:35,290
>> 然後，如果哪
有點雄心勃勃，

1263
01:01:35,290 --> 01:01:38,660
隨意看看這段代碼。

1264
01:01:38,660 --> 01:01:40,680
這實際上是
物理實現

1265
01:01:40,680 --> 01:01:42,150
我們如何會寫歸併排序。

1266
01:01:42,150 --> 01:01:44,070
你可以看到，這是非常短的。

1267
01:01:44,070 --> 01:01:46,310
但背後的想法
這是相當複雜的。

1268
01:01:46,310 --> 01:01:50,865
所以，如果你覺得自己畫了這一點
在你的功課今晚，隨意。

1269
01:01:50,865 --> 01:01:54,050

1270
01:01:54,050 --> 01:01:54,740
>> 確定。

1271
01:01:54,740 --> 01:01:58,070
大衛也去了這個講座。

1272
01:01:58,070 --> 01:02:00,660
什麼是最好的情況下，
運行時，最壞的情況下運行時，

1273
01:02:00,660 --> 01:02:05,680
和合併排序的預計運行時間？

1274
01:02:05,680 --> 01:02:07,260
幾秒鐘思考。

1275
01:02:07,260 --> 01:02:11,198
這是相當困難的，但那種
直觀的，如果你仔細想想。

1276
01:02:11,198 --> 01:02:20,090

1277
01:02:20,090 --> 01:02:23,054
好的。

1278
01:02:23,054 --> 01:02:25,269
>> 聽眾：是最壞的情況的n log N +

1279
01:02:25,269 --> 01:02:26,060
ANDI鵬：沒錯。

1280
01:02:26,060 --> 01:02:29,380
為什麼說它是N日誌ñ。

1281
01:02:29,380 --> 01:02:32,230
>> 聽眾：是不是因為它
成為指數更快，

1282
01:02:32,230 --> 01:02:35,390
因此它就像一個函數
而不只是單純的為N

1283
01:02:35,390 --> 01:02:37,529
平方什麼？

1284
01:02:37,529 --> 01:02:38,320
ANDI鵬：沒錯。

1285
01:02:38,320 --> 01:02:40,750
這樣之所以
運行時在此為n日誌

1286
01:02:40,750 --> 01:02:44,310
n是因為 - 你是什麼人
在做所有這些步驟？

1287
01:02:44,310 --> 01:02:46,190
你只是砍了一半，對不對？

1288
01:02:46,190 --> 01:02:48,750
所以，當我們正在做的
日誌，所有它做

1289
01:02:48,750 --> 01:02:53,150
被分割的問題在一半，
成兩半，一半，在更半部。

1290
01:02:53,150 --> 01:02:56,430
而在這個意義上，可以種
對消除線性模型

1291
01:02:56,430 --> 01:02:57,510
我們一直在使用。

1292
01:02:57,510 --> 01:03:00,254
因為當你砍
事情的一半，這是一個記錄。

1293
01:03:00,254 --> 01:03:02,420
這只是數學
代表它的方式。

1294
01:03:02,420 --> 01:03:06,310
>> 然後終於，到了最後，你
只是讓通過一個最後一關

1295
01:03:06,310 --> 01:03:07,930
把所有的人都在秩序，對不對？

1296
01:03:07,930 --> 01:03:10,330
所以，如果你只需要
查一件事，那n值。

1297
01:03:10,330 --> 01:03:13,420
所以你是那種
乘兩者結合起來。

1298
01:03:13,420 --> 01:03:17,660
因此，這就像你已經得到了最終的
檢驗N-下來日誌的n這裡

1299
01:03:17,660 --> 01:03:18,390
在這裡。

1300
01:03:18,390 --> 01:03:21,060
如果你乘
他們，那是N日誌ñ。

1301
01:03:21,060 --> 01:03:26,100
>> 所以，最好的和最壞
情況和預期是所有N日誌N。

1302
01:03:26,100 --> 01:03:27,943
它也像另一個排序。

1303
01:03:27,943 --> 01:03:30,090
這就像選擇排序
在某種意義上說，它

1304
01:03:30,090 --> 01:03:32,131
不要緊，你的
列表，它只是會

1305
01:03:32,131 --> 01:03:34,801
做同樣的事情，每一次。

1306
01:03:34,801 --> 01:03:35,300
確定。

1307
01:03:35,300 --> 01:03:39,950
所以當你們可以看到，即使
我們已經走了through-- n中的種種

1308
01:03:39,950 --> 01:03:41,660
平方，這不是很有效。

1309
01:03:41,660 --> 01:03:47,060
而即使是這樣的n log n是
不是最有效的。

1310
01:03:47,060 --> 01:03:49,720
如果你們是好奇，
有某種機制

1311
01:03:49,720 --> 01:03:54,310
這是如此有效，以至於他們
幾乎是基本持平的運行時間。

1312
01:03:54,310 --> 01:03:55,420
>> 你有一些日誌ñ的。

1313
01:03:55,420 --> 01:03:58,190
你有一些loglogN個的。

1314
01:03:58,190 --> 01:04:00,330
我們不觸及他們
在這個類現在。

1315
01:04:00,330 --> 01:04:02,663
但是，如果你們是好奇，
隨意谷歌，什麼是

1316
01:04:02,663 --> 01:04:04,392
最有效的分類機制。

1317
01:04:04,392 --> 01:04:06,350
我不知道，有
一些很搞笑的人，

1318
01:04:06,350 --> 01:04:09,860
like--有一些真的
有趣的那些人做。

1319
01:04:09,860 --> 01:04:12,210
你想知道他們是如何
沒有想過這一點。

1320
01:04:12,210 --> 01:04:15,730
因此谷歌，如果你有一些空閒
時間上，都有些什麼有趣的方式

1321
01:04:15,730 --> 01:04:17,730
該people--以及
高效ways--人

1322
01:04:17,730 --> 01:04:20,371
之所以能夠實現排序。

1323
01:04:20,371 --> 01:04:20,870
確定。

1324
01:04:20,870 --> 01:04:22,880
而這裡只是一個方便的小圖。

1325
01:04:22,880 --> 01:04:26,850
我知道在座的各位，是競猜0之前，
會在你的房間可能是試圖

1326
01:04:26,850 --> 01:04:27,960
記住這一點。

1327
01:04:27,960 --> 01:04:30,940
所以這是很好的在那裡為你們。

1328
01:04:30,940 --> 01:04:37,120
但不要忘記，made--邏輯
為什麼這些數字正在發生。

1329
01:04:37,120 --> 01:04:39,870
如果你總是輸了，只是讓
確保你知道什麼是排序是。

1330
01:04:39,870 --> 01:04:40,820
你可以貫穿
它們在你的心中

1331
01:04:40,820 --> 01:04:42,903
弄清楚為什麼那些
答案是這些問題的答案。

1332
01:04:42,903 --> 01:04:46,250

1333
01:04:46,250 --> 01:04:47,600
>> 好的。

1334
01:04:47,600 --> 01:04:49,680
所以，我們要動
在最後，在搜索。

1335
01:04:49,680 --> 01:04:51,638
因為那些對你
誰看過處理器集，

1336
01:04:51,638 --> 01:04:55,175
搜索也是部分
這個星期的習題集。

1337
01:04:55,175 --> 01:04:57,300
你會被要求執行
兩種類型的搜索。

1338
01:04:57,300 --> 01:05:00,070
一個是線性搜索和
一個是一個二進制搜索。

1339
01:05:00,070 --> 01:05:01,760
>> 所以線性搜索是相當容易的。

1340
01:05:01,760 --> 01:05:04,070
你只是想搜索的元素
列表，看看你得到它。

1341
01:05:04,070 --> 01:05:05,444
你只需要遍歷。

1342
01:05:05,444 --> 01:05:08,170
如果它等於什麼，
你可以返回它，對嗎？

1343
01:05:08,170 --> 01:05:10,890
但是，一個我們最
興趣談論

1344
01:05:10,890 --> 01:05:14,550
是二進制搜索，右，這是
分而治之的機制，

1345
01:05:14,550 --> 01:05:18,190
大衛被證明在講座。

1346
01:05:18,190 --> 01:05:20,810
>> 還記得電話簿的例子
他不斷拉扯大，

1347
01:05:20,810 --> 01:05:23,960
一個那種他掙扎
有點過去的一年，

1348
01:05:23,960 --> 01:05:27,530
在那裡你把這個問題了一半，
一半，一半，一遍又一遍，

1349
01:05:27,530 --> 01:05:30,730
直到你找到你想要的？

1350
01:05:30,730 --> 01:05:33,727
而你已經得到了
那運行時也是如此。

1351
01:05:33,727 --> 01:05:35,810
你可以看到，它的
顯著更高效

1352
01:05:35,810 --> 01:05:39,080
比任何其他類型的搜索。

1353
01:05:39,080 --> 01:05:41,880
>> 所以我們會去的方式
實現的二進制搜索

1354
01:05:41,880 --> 01:05:46,510
是，如果我們有一個數組，
索引為0到6，7的元素，

1355
01:05:46,510 --> 01:05:49,790
我們可以看看在中間，right--
很抱歉，如果我們的問題first--

1356
01:05:49,790 --> 01:05:53,840
如果我們要問的問題，請問
該陣列含有的7的元件，

1357
01:05:53,840 --> 01:05:56,840
顯然，是人類，並且具有
這樣一小陣，很容易讓我們

1358
01:05:56,840 --> 01:05:58,210
說是。

1359
01:05:58,210 --> 01:06:05,750
但方式來實現二進制
搜索將是尋找在中間。

1360
01:06:05,750 --> 01:06:08,020
>> 我們知道，指數3
中間，因為我們

1361
01:06:08,020 --> 01:06:09,270
知道有七個要素。

1362
01:06:09,270 --> 01:06:10,670
什麼7除以2？

1363
01:06:10,670 --> 01:06:12,850
你可以額外1砍掉。

1364
01:06:12,850 --> 01:06:14,850
你在中間得到了3。

1365
01:06:14,850 --> 01:06:17,590
所以為3數組等於7？

1366
01:06:17,590 --> 01:06:18,900
它是不是，對不對？

1367
01:06:18,900 --> 01:06:21,050
但是，我們可以做一對夫婦的檢查。

1368
01:06:21,050 --> 01:06:25,380
是3小於7或陣列
是3陣列大於7？

1369
01:06:25,380 --> 01:06:27,240
>> 我們知道，這是不到7。

1370
01:06:27,240 --> 01:06:30,259
因此，我們知道，哦，就必須
不會在左半部。

1371
01:06:30,259 --> 01:06:32,300
我們知道，它必須是
在右前衛，對不對？

1372
01:06:32,300 --> 01:06:34,662
因此，我們可以只砍掉一半的陣列。

1373
01:06:34,662 --> 01:06:36,370
我們甚至不有
看它了。

1374
01:06:36,370 --> 01:06:38,711
因為我們知道，
一半的problem--的

1375
01:06:38,711 --> 01:06:41,210
我們知道答案是
我們的問題的右半部分。

1376
01:06:41,210 --> 01:06:42,580
因此，我們只看現在。

1377
01:06:42,580 --> 01:06:44,860
>> 所以，現在我們來看看
中間還剩下些什麼。

1378
01:06:44,860 --> 01:06:46,880
該指數5。

1379
01:06:46,880 --> 01:06:50,200
我們再次做同樣的檢查
而且我們看到，它的體積更小。

1380
01:06:50,200 --> 01:06:52,050
因此，我們期待的是左邊。

1381
01:06:52,050 --> 01:06:53,430
然後我們看到檢查。

1382
01:06:53,430 --> 01:06:57,600
是在陣列值
索引4等於7？

1383
01:06:57,600 --> 01:06:58,260
是的。

1384
01:06:58,260 --> 01:07:03,580
因此，我們可以返回true，因為
我們發現在我們的列表中選擇值。

1385
01:07:03,580 --> 01:07:06,738
我是否通過去的方式
是否有意義給大家？

1386
01:07:06,738 --> 01:07:08,760
確定。

1387
01:07:08,760 --> 01:07:11,670
我給你們也許一樣，
三，四分鐘，以搞清楚

1388
01:07:11,670 --> 01:07:13,270
如何在偽代碼本。

1389
01:07:13,270 --> 01:07:18,070
>> 所以，想像一下，我問你寫
函數調用搜索（）的返回

1390
01:07:18,070 --> 01:07:20,640
一個值，布爾值，
這是真的還是false--類似，

1391
01:07:20,640 --> 01:07:22,970
如果你找到了真正的
值，如果你沒有假的。

1392
01:07:22,970 --> 01:07:25,230
然後你
在值傳遞你

1393
01:07:25,230 --> 01:07:28,410
在尋找到值，
是array--哦，我一定會把

1394
01:07:28,410 --> 01:07:29,410
在錯誤的地方。

1395
01:07:29,410 --> 01:07:29,580
確定。

1396
01:07:29,580 --> 01:07:31,829
不管怎樣，應該有
到過的值的右側。

1397
01:07:31,829 --> 01:07:36,280
然後INT n是數
在該數組元素。

1398
01:07:36,280 --> 01:07:39,430
你會如何去努力
偽代碼在這個問題？

1399
01:07:39,430 --> 01:07:41,630
我給你們喜歡
三分鐘的時間做到這一點。

1400
01:07:41,630 --> 01:08:00,137

1401
01:08:00,137 --> 01:08:02,595
不，我認為有only--
是啊，有一個正確的在這裡。

1402
01:08:02,595 --> 01:08:03,261
聽眾：可以嗎？

1403
01:08:03,261 --> 01:08:04,388
ANDI彭：是啊，我給你。

1404
01:08:04,388 --> 01:08:09,410

1405
01:08:09,410 --> 01:08:11,050
是不是工作？

1406
01:08:11,050 --> 01:08:12,290
OK，涼。

1407
01:08:12,290 --> 01:10:43,590

1408
01:10:43,590 --> 01:10:44,720
>> 確定。

1409
01:10:44,720 --> 01:10:47,630
好球員，我們
要收服入。

1410
01:10:47,630 --> 01:10:49,730
確定。

1411
01:10:49,730 --> 01:10:54,020
因此，假設我們已經有了這個可愛的
小數組在它的n值。

1412
01:10:54,020 --> 01:10:55,170
我沒有畫線。

1413
01:10:55,170 --> 01:10:58,649
但是我們怎麼能去
嘗試寫這個？

1414
01:10:58,649 --> 01:11:00,440
有沒有人要
給我的第一行？

1415
01:11:00,440 --> 01:11:02,814
如果你想給我
第一行該偽代碼。

1416
01:11:02,814 --> 01:11:06,563

1417
01:11:06,563 --> 01:11:08,430
>> 聽眾：[聽不清]

1418
01:11:08,430 --> 01:11:10,138
聽眾：你想要
遍歷through--

1419
01:11:10,138 --> 01:11:11,094
聽眾：只為循環的另一個？

1420
01:11:11,094 --> 01:11:11,760
聽眾：──。

1421
01:11:11,760 --> 01:11:15,880

1422
01:11:15,880 --> 01:11:17,780
>> ANDI彭：所以這一塊是有點棘手。

1423
01:11:17,780 --> 01:11:23,130
想想about--你想
要繼續運行這個循環

1424
01:11:23,130 --> 01:11:27,950
一遍又一遍，直到什麼時候呢？

1425
01:11:27,950 --> 01:11:30,819
>> 聽眾：直到[聽不清]
值等於該值。

1426
01:11:30,819 --> 01:11:31,610
ANDI鵬：沒錯。

1427
01:11:31,610 --> 01:11:33,900
所以，你可以真正地寫 - 
我們甚至可以把它簡化了。

1428
01:11:33,900 --> 01:11:35,630
我們可以寫一個while循環，對不對？

1429
01:11:35,630 --> 01:11:39,380
所以，你可以有loop--
我們知道，這是一段時間。

1430
01:11:39,380 --> 01:11:42,850
但現在，我要去
說“循環” - 通過什麼？

1431
01:11:42,850 --> 01:11:46,640
環until--是什麼
我們結束條件？

1432
01:11:46,640 --> 01:11:47,510
我想我聽到了。

1433
01:11:47,510 --> 01:11:48,530
我聽到有人說了吧。

1434
01:11:48,530 --> 01:11:51,255
>> 聽眾：值等於中間。

1435
01:11:51,255 --> 01:11:52,255
ANDI彭：再說一遍。

1436
01:11:52,255 --> 01:11:54,470
聽眾：或者，直到
值要搜索

1437
01:11:54,470 --> 01:11:58,470
為等於中間值。

1438
01:11:58,470 --> 01:12:00,280
>> ANDI彭：如果有什麼是不是在那裡？

1439
01:12:00,280 --> 01:12:03,113
如果你正在尋找的價值
對於實際上不是在這陣？

1440
01:12:03,113 --> 01:12:05,890
聽眾：你返回1。

1441
01:12:05,890 --> 01:12:08,850
>> ANDI鵬：但是我們要
循環，直到如果我們有一個條件？

1442
01:12:08,850 --> 01:12:09,350
是啊。

1443
01:12:09,350 --> 01:12:11,239
>> 聽眾：直到有只有一個值？

1444
01:12:11,239 --> 01:12:13,530
ANDI彭：你可以循環
until--讓你知道，你是

1445
01:12:13,530 --> 01:12:15,714
將有一個最大值，對不對？

1446
01:12:15,714 --> 01:12:18,130
而你知道，你會
有一個最小值，對不對？

1447
01:12:18,130 --> 01:12:20,379
也因為，這東西
我忘了之前的說法，

1448
01:12:20,379 --> 01:12:22,640
這東西是
約二分查找關鍵

1449
01:12:22,640 --> 01:12:24,182
是你的數組已經排序。

1450
01:12:24,182 --> 01:12:26,973
因為沒有辦法做
這一點，如果他們只是隨機值。

1451
01:12:26,973 --> 01:12:29,190
你不知道，如果一個人的
比另一個大，對吧？

1452
01:12:29,190 --> 01:12:32,720
>> 所以，你知道你的最大和
您分鐘都在這裡，對不對？

1453
01:12:32,720 --> 01:12:35,590
如果你將要調整
你最大的您分鐘和mid--

1454
01:12:35,590 --> 01:12:38,470
就讓我們假設你的
中間值右這裡 - 

1455
01:12:38,470 --> 01:12:43,910
你要基本
循環，直到你的最小值是

1456
01:12:43,910 --> 01:12:47,510
大致相同的最大，右，或
如果你的max是不一樣的分。

1457
01:12:47,510 --> 01:12:48,040
對嗎？

1458
01:12:48,040 --> 01:12:51,340
因為當發生這種情況，你知道，
你最終擊中了相同的值。

1459
01:12:51,340 --> 01:12:59,135
所以，你要循環，直到你分鐘
小於或等於用於：哎呀，

1460
01:12:59,135 --> 01:13:01,510
不小於或等於
around--最大的另一種方法是。

1461
01:13:01,510 --> 01:13:15,110

1462
01:13:15,110 --> 01:13:16,160
>> 這是否有意義？

1463
01:13:16,160 --> 01:13:18,810
我花了一些嘗試，以獲得這一權利。

1464
01:13:18,810 --> 01:13:21,869
但循環，直到你的最大值
基本上是差不多少

1465
01:13:21,869 --> 01:13:23,410
大於或等於您的最低，對不對？

1466
01:13:23,410 --> 01:13:25,201
當你知道這是
你已經收斂。

1467
01:13:25,201 --> 01:13:29,290
聽眾：當你將最大
值是小於最小？

1468
01:13:29,290 --> 01:13:31,040
ANDI彭：如果你保持
調整它，這

1469
01:13:31,040 --> 01:13:32,380
就是我們要
在做這個。

1470
01:13:32,380 --> 01:13:33,460
這是否有意義？

1471
01:13:33,460 --> 01:13:35,750
最小和最大只是
整數，我們可能

1472
01:13:35,750 --> 01:13:39,260
將要創建的保留
賽道上，我們正​​在尋找的。

1473
01:13:39,260 --> 01:13:41,790
因為數組存在
無論我們在做什麼的。

1474
01:13:41,790 --> 01:13:45,030
就像，我們沒有實際的物理
斬去陣列，對不對？

1475
01:13:45,030 --> 01:13:47,261
我們只是調整
我們正在尋找。

1476
01:13:47,261 --> 01:13:48,136
這是否有意義？

1477
01:13:48,136 --> 01:13:48,472
>> 聽眾：是的。

1478
01:13:48,472 --> 01:13:49,110
>> ANDI彭：OK。

1479
01:13:49,110 --> 01:13:57,090
所以，如果這對我們的循環中的條件，
我們需要什麼這個循環裡面？

1480
01:13:57,090 --> 01:13:58,700
什麼是我們將要想要做什麼？

1481
01:13:58,700 --> 01:14:02,390
所以，現在，我們已經有了
一個最大和最小，權，

1482
01:14:02,390 --> 01:14:04,962
可能產生在這裡的某個地方。

1483
01:14:04,962 --> 01:14:07,170
我們將可能希望
找一個中間的，對不對？

1484
01:14:07,170 --> 01:14:08,450
我們該如何為
能找到中間？

1485
01:14:08,450 --> 01:14:09,491
什麼是mathematical--

1486
01:14:09,491 --> 01:14:11,079
聽眾：最大加分除以2。

1487
01:14:11,079 --> 01:14:11,870
ANDI鵬：沒錯。

1488
01:14:11,870 --> 01:14:20,300

1489
01:14:20,300 --> 01:14:21,620
這是否有意義？

1490
01:14:21,620 --> 01:14:25,780
做你們明白為什麼我們
不只是use--為什麼我們這樣做

1491
01:14:25,780 --> 01:14:27,850
而不是做了2只除以n？

1492
01:14:27,850 --> 01:14:30,310
這是因為n是一個值
那將保持不變。

1493
01:14:30,310 --> 01:14:30,979
對嗎？

1494
01:14:30,979 --> 01:14:34,020
但是，當我們調整我們的最低和
最大值，他們將改變。

1495
01:14:34,020 --> 01:14:36,040
其結果，我們的中間
都不會改變太多。

1496
01:14:36,040 --> 01:14:37,873
所以這就是為什麼我們要
在這裡做的權利。

1497
01:14:37,873 --> 01:14:38,510
確定。

1498
01:14:38,510 --> 01:14:41,600
>> 然後，現在
我們發現our--耶。

1499
01:14:41,600 --> 01:14:44,270
>> 聽眾：只是一個快速的問題 - 
當你說最大和最小，

1500
01:14:44,270 --> 01:14:46,410
在我們假設
它已經排序？

1501
01:14:46,410 --> 01:14:48,400
>> ANDI彭：是啊，這實際上是一個
先決條件二進制搜索，

1502
01:14:48,400 --> 01:14:49,816
你必須知道它​​的排序。

1503
01:14:49,816 --> 01:14:53,660
這就是為什麼排序，你寫你的
您的二進制搜索之前，習題集。

1504
01:14:53,660 --> 01:14:55,910
確定。

1505
01:14:55,910 --> 01:14:58,876
所以，現在我們知道我們的中點
是，你要什麼做的嗎？

1506
01:14:58,876 --> 01:15:01,789

1507
01:15:01,789 --> 01:15:04,319
>> 聽眾：我們想比較
即到另一個。

1508
01:15:04,319 --> 01:15:05,110
ANDI鵬：沒錯。

1509
01:15:05,110 --> 01:15:12,280
所以，你要比較
月中的價值，對不對？

1510
01:15:12,280 --> 01:15:14,900

1511
01:15:14,900 --> 01:15:18,670
而這是什麼告訴
我們，當我們比較？

1512
01:15:18,670 --> 01:15:22,226
什麼是我們想要做的之後？

1513
01:15:22,226 --> 01:15:25,389
>> 聽眾：如果該值越大
比中期，我們希望把它割下來。

1514
01:15:25,389 --> 01:15:26,180
ANDI鵬：沒錯。

1515
01:15:26,180 --> 01:15:33,940
因此，如果該值大
比中旬，我們

1516
01:15:33,940 --> 01:15:36,550
會想改變這些
最小和馬克塞斯，對不對？

1517
01:15:36,550 --> 01:15:38,980
我們需要什麼改變？

1518
01:15:38,980 --> 01:15:42,145
因此，如果我們知道價值的地方
在這裡，你有什麼，我們要改變？

1519
01:15:42,145 --> 01:15:44,758
我們要改變我們的
最小的是中端，對不對？

1520
01:15:44,758 --> 01:15:49,420

1521
01:15:49,420 --> 01:15:54,292
然後否則，如果它在這個
上半年，有什麼事我們要改變？

1522
01:15:54,292 --> 01:15:55,306
>> 聽眾：你最大的。

1523
01:15:55,306 --> 01:15:55,972
ANDI彭：是的。

1524
01:15:55,972 --> 01:16:02,597

1525
01:16:02,597 --> 01:16:04,680
然後，你只是去
保持循環，對不對？

1526
01:16:04,680 --> 01:16:08,920
因為現在，一次迭代後，
通過，你已經有了一個最大這裡。

1527
01:16:08,920 --> 01:16:10,760
然後你就可以重新計算中間。

1528
01:16:10,760 --> 01:16:11,990
然後你就可以比較。

1529
01:16:11,990 --> 01:16:14,766
而你要堅持下去
直到分鐘和馬克塞斯

1530
01:16:14,766 --> 01:16:15,890
已經基本收斂。

1531
01:16:15,890 --> 01:16:17,890
而且，當你知道這是
你打它的結束。

1532
01:16:17,890 --> 01:16:20,280
而無論你已經找到了
或者你有沒有在這一點上。

1533
01:16:20,280 --> 01:16:23,170
>> 這是否有意義給大家？

1534
01:16:23,170 --> 01:16:26,020

1535
01:16:26,020 --> 01:16:26,770
確定。

1536
01:16:26,770 --> 01:16:27,900
這是非常重要的，
因為你有

1537
01:16:27,900 --> 01:16:29,760
在您的代碼今晚這樣寫。

1538
01:16:29,760 --> 01:16:32,660
但是你們有一個相當不錯的
什麼，你應該做的意義，

1539
01:16:32,660 --> 01:16:34,051
這是很好的。

1540
01:16:34,051 --> 01:16:34,550
確定。

1541
01:16:34,550 --> 01:16:38,840
所以，我們已經得到了大約七
離開分鐘一節。

1542
01:16:38,840 --> 01:16:43,170
所以，我們要談談
這pset的，我們會做。

1543
01:16:43,170 --> 01:16:46,410
因此的pset分為兩半。

1544
01:16:46,410 --> 01:16:50,230
上半年涉及
實施發現

1545
01:16:50,230 --> 01:16:54,210
在你寫一個線性搜索，一
二進制搜索，和一個排序算法。

1546
01:16:54,210 --> 01:16:56,690
>> 因此，這是第一個
一次在PSET哪裡

1547
01:16:56,690 --> 01:17:00,050
我們會給予你們什麼所謂
分配代碼，這是代碼

1548
01:17:00,050 --> 01:17:02,740
我們已經預先寫好，
只是留下了一些棋子落

1549
01:17:02,740 --> 01:17:04,635
為你完成寫作。

1550
01:17:04,635 --> 01:17:07,510
所以你們這些傢伙，當你看這個
代碼中，你可能會真是嚇壞了。

1551
01:17:07,510 --> 01:17:08,630
如果你只是想，啊，我
不知道這是什麼在做，

1552
01:17:08,630 --> 01:17:11,670
我不知道一樣，這似乎
這麼複雜，啊，放鬆。

1553
01:17:11,670 --> 01:17:12,170
這是確定的。

1554
01:17:12,170 --> 01:17:12,930
閱讀規格。

1555
01:17:12,930 --> 01:17:16,920
該規範將解釋你到底
什麼所有這些方案都在做。

1556
01:17:16,920 --> 01:17:20,560
>> 例如，generate.c是一個程序
這會是你的pset中。

1557
01:17:20,560 --> 01:17:24,060
你實際上並沒有去觸摸它，但
你應該明白它在做什麼。

1558
01:17:24,060 --> 01:17:28,550
而generate.c，所有它做的是
或者產生隨機數

1559
01:17:28,550 --> 01:17:32,400
或者你可以給它一個種子，像
預先安排的號碼，它需要，

1560
01:17:32,400 --> 01:17:34,140
它產生更多的數字。

1561
01:17:34,140 --> 01:17:37,170
因此，有一種特定的方式來
實施generate.c其中

1562
01:17:37,170 --> 01:17:42,760
你可以做一串數字
為您測試您的其他方法上。

1563
01:17:42,760 --> 01:17:45,900
>> 所以，如果你想為
例如，測試你的發現，

1564
01:17:45,900 --> 01:17:48,970
你想運行generate.c，
生成一串數字，

1565
01:17:48,970 --> 01:17:50,880
然後運行你的助手功能。

1566
01:17:50,880 --> 01:17:53,930
你的助手功能就是你
實際的物理寫代碼。

1567
01:17:53,930 --> 01:17:59,330
並認為傭工作為庫文件
你寫的那些發現正在呼叫。

1568
01:17:59,330 --> 01:18:02,950
所以在helpers.c，你會
做搜索和排序。

1569
01:18:02,950 --> 01:18:06,500
>> 然後，你要基本上
只是把它們放在一起。

1570
01:18:06,500 --> 01:18:10,350
該規範將告訴你如何
把在命令行上。

1571
01:18:10,350 --> 01:18:14,880
你就可以測試是否
不是你的排序和搜索工作。

1572
01:18:14,880 --> 01:18:15,870
酷。

1573
01:18:15,870 --> 01:18:18,720
有沒有人已經開始，
遇到問題或疑問

1574
01:18:18,720 --> 01:18:20,520
他們現在所擁有的這個嗎？

1575
01:18:20,520 --> 01:18:21,020
確定。

1576
01:18:21,020 --> 01:18:21,476
>> 聽眾：等待。

1577
01:18:21,476 --> 01:18:21,932
我有一個問題。

1578
01:18:21,932 --> 01:18:22,844
>> ANDI彭：是的。

1579
01:18:22,844 --> 01:18:28,390
>> 聽眾：所以我就開始做
在helpers.c線性搜索

1580
01:18:28,390 --> 01:18:29,670
它並沒有真正的工作。

1581
01:18:29,670 --> 01:18:34,590
但後​​來，我發現我們只是
要刪除它，做二進制搜索。

1582
01:18:34,590 --> 01:18:36,991
因此，它的問題，如果它不能正常工作？

1583
01:18:36,991 --> 01:18:39,700

1584
01:18:39,700 --> 01:18:41,510
>> ANDI彭：簡短的答案是否定的。

1585
01:18:41,510 --> 01:18:42,642
但由於我們是不是 - 

1586
01:18:42,642 --> 01:18:44,350
聽眾：但是，沒有一個人的
其實檢查。

1587
01:18:44,350 --> 01:18:46,058
ANDI彭：我們從來沒有
要看到這一點。

1588
01:18:46,058 --> 01:18:49,590
但是，你可能想使
確保你的搜索工作。

1589
01:18:49,590 --> 01:18:51,700
因為如果你的線性
搜索無法正常工作，

1590
01:18:51,700 --> 01:18:54,410
那麼機會是你的二進制
搜索是不會正常工作。

1591
01:18:54,410 --> 01:18:56,646
因為你也有類似的
邏輯在兩人面前。

1592
01:18:56,646 --> 01:18:58,020
不，這其實並不重要。

1593
01:18:58,020 --> 01:19:01,300
所以唯一的，你轉
在有排序和二進制搜索。

1594
01:19:01,300 --> 01:19:02,490
是啊。

1595
01:19:02,490 --> 01:19:06,610
>> 而且，很多孩子們
嘗試編譯helpers.c。

1596
01:19:06,610 --> 01:19:09,550
你沒有真正允許
要做到這一點，因為helpers.c

1597
01:19:09,550 --> 01:19:11,200
不具有的主要功能。

1598
01:19:11,200 --> 01:19:13,550
所以，你只應該
是實際編制

1599
01:19:13,550 --> 01:19:18,670
產生和發現，因為找不到電話
helpers.c並在它的職能。

1600
01:19:18,670 --> 01:19:20,790
這樣就使得調試
一個痛苦的對接。

1601
01:19:20,790 --> 01:19:22,422
但是，這就是我們要做的。

1602
01:19:22,422 --> 01:19:23,880
聽眾：你剛才做的所有，對不對？

1603
01:19:23,880 --> 01:19:27,290
ANDI彭：你可以
讓所有的嗯，是的。

1604
01:19:27,290 --> 01:19:28,060
確定。

1605
01:19:28,060 --> 01:19:32,570
所以這是它在什麼條件
pset的要求你都做。

1606
01:19:32,570 --> 01:19:35,160
如果您有任何問題，請隨時
免費區之後問我。

1607
01:19:35,160 --> 01:19:37,580
我會在這裡一樣，20分鐘。

1608
01:19:37,580 --> 01:19:40,500
>> 和是的，處理器集的
真的沒有那麼糟糕。

1609
01:19:40,500 --> 01:19:41,680
你們應該沒問題。

1610
01:19:41,680 --> 01:19:43,250
這些，只是遵循的指導方針。

1611
01:19:43,250 --> 01:19:47,840
一種有意識，從邏輯上講，是什麼
應該發生，你會沒事的。

1612
01:19:47,840 --> 01:19:48,690
不要太害怕。

1613
01:19:48,690 --> 01:19:50,220
有很多的代碼
已經寫在那裡。

1614
01:19:50,220 --> 01:19:53,011
不要太害怕，如果你不
明白了這一切手段。

1615
01:19:53,011 --> 01:19:54,749
如果這是一個很大，這是完全罰款。

1616
01:19:54,749 --> 01:19:55,790
而來到辦公時間。

1617
01:19:55,790 --> 01:19:57,520
我們會幫你看看。

1618
01:19:57,520 --> 01:20:00,810
>> 聽眾：用多餘的
功能，我們看這些嗎？

1619
01:20:00,810 --> 01:20:03,417
>> ANDI彭：是的，這些都是在代碼中。

1620
01:20:03,417 --> 01:20:05,750
在遊戲中的15，一半的
它已經為你寫的。

1621
01:20:05,750 --> 01:20:09,310
因此，這些功能
已經在代碼中。

1622
01:20:09,310 --> 01:20:12,020
是的。

1623
01:20:12,020 --> 01:20:12,520
好的。

1624
01:20:12,520 --> 01:20:14,000
那麼，最好的運氣。

1625
01:20:14,000 --> 01:20:15,180
這是一個噁心的一天。

1626
01:20:15,180 --> 01:20:19,370
所以希望你們不要覺得太
不好呆在裡面和編碼。

1627
01:20:19,370 --> 01:20:22,133