1
00:00:00,000 --> 00:00:06,370

2
00:00:06,370 --> 00:00:08,150
>> JASON HIRSCHHORN：歡迎
三個星期，大家好。

3
00:00:08,150 --> 00:00:11,650
我們有一個忙碌的，但令人興奮的
擺在我們面前的一節。

4
00:00:11,650 --> 00:00:17,010
因此，首先，因為我們已經做了一些
進展的過程，但我們仍然

5
00:00:17,010 --> 00:00:20,570
有一個很大的學問剩下要做的，我
要告訴你們一些資源

6
00:00:20,570 --> 00:00:24,160
這應該被證明是令人難以置信
有用你不僅接近你

7
00:00:24,160 --> 00:00:28,130
習題集，而且還消化所有的
我們給你們的材料

8
00:00:28,130 --> 00:00:30,800
講座和短褲和一節。

9
00:00:30,800 --> 00:00:34,790
>> 然後，我們將先花20
節會超過25分鐘

10
00:00:34,790 --> 00:00:38,630
GDB，您可能會或可能不會有
用在這點上，但它是一個

11
00:00:38,630 --> 00:00:42,570
令人難以置信的有用工具，將
幫助你調試你的程序。

12
00:00:42,570 --> 00:00:46,060
很多您在可能使用的printf
你的程序的中間圖

13
00:00:46,060 --> 00:00:47,430
哪些變量望其項背。

14
00:00:47,430 --> 00:00:52,060
GDB甚至比printf的更好，
不搞砸了你的代碼，因為你

15
00:00:52,060 --> 00:00:53,320
對可執行文件運行它。

16
00:00:53,320 --> 00:00:56,500
所以我們就去了10個最有幫助
命令你需要GDB，我們很

17
00:00:56,500 --> 00:01:00,540
要繼續練習在一起，
在問題設定了三個超越，你

18
00:01:00,540 --> 00:01:03,320
可以用GDB來幫助調試
您的程序。

19
00:01:03,320 --> 00:01:06,420
最後，我們將介紹一些
排序和查找算法

20
00:01:06,420 --> 00:01:10,590
您在演講看見了，我們是
將實際的代碼，而不只是

21
00:01:10,590 --> 00:01:17,360
偽代碼，但代碼的二進制搜索，
冒泡排序和選擇排序。

22
00:01:17,360 --> 00:01:20,090
>> 因此，首先，我想去
以上的資源。

23
00:01:20,090 --> 00:01:23,530
這是一個廣泛的名單，它的
較小的字體，因為我有很多東西要

24
00:01:23,530 --> 00:01:24,390
適合在這裡。

25
00:01:24,390 --> 00:01:26,950
但這些不僅會幫助你，
再次，與習題集和

26
00:01:26,950 --> 00:01:30,760
你學到了消化信息，但
肯定，來測驗時間，這些都會

27
00:01:30,760 --> 00:01:32,130
說非常有用。

28
00:01:32,130 --> 00:01:34,700
因此，首先，演講筆記。

29
00:01:34,700 --> 00:01:39,480
如果你去cs50.net/lectures和
滾動到特定的星期和日，

30
00:01:39,480 --> 00:01:43,120
你會看到，有註釋為每個
講課，這不是一個簡單的

31
00:01:43,120 --> 00:01:47,250
成績單，而是一個編輯的版本
什麼是覆蓋在講座與代碼

32
00:01:47,250 --> 00:01:49,610
片段和其他有用的花絮。

33
00:01:49,610 --> 00:01:52,220
我強烈建議你對這些。

34
00:01:52,220 --> 00:01:55,340
然後還有，還有源代碼
可從每個講座。

35
00:01:55,340 --> 00:02:00,050
再次，這些幻燈片也將是
可在網上cs50.net/sections

36
00:02:00,050 --> 00:02:01,480
今天晚上。

37
00:02:01,480 --> 00:02:06,860
>> 因此，每個星期第二是短褲的
封面專題，一般為5〜15

38
00:02:06,860 --> 00:02:08,090
分的長度。

39
00:02:08,090 --> 00:02:12,310
而那些希望會給你一個
偉大的底漆上不同的主題。

40
00:02:12,310 --> 00:02:12,870
第三 - 

41
00:02:12,870 --> 00:02:16,370
這是全新的這
年 - 是study.cs50.net。

42
00:02:16,370 --> 00:02:20,110
如果你還沒有檢查出來，我
強烈建議您這樣做。

43
00:02:20,110 --> 00:02:21,100
你來挑一個話題。

44
00:02:21,100 --> 00:02:23,040
我們對有幾十個主題。

45
00:02:23,040 --> 00:02:24,770
因此，例如，你選擇的功能。

46
00:02:24,770 --> 00:02:27,270
它給你一些幻燈片
並注意到功能。

47
00:02:27,270 --> 00:02:31,190
這些都是實際的幻燈片，轉錄因子
鼓勵在使用我們的

48
00:02:31,190 --> 00:02:32,710
演示一節。

49
00:02:32,710 --> 00:02:35,040
還有處理的技巧和竅門
與功能，並有

50
00:02:35,040 --> 00:02:37,290
實踐中的問題，幫助
您使用的功能。

51
00:02:37,290 --> 00:02:41,500
我們也給你鏈接到的短
函數和時間，其功能

52
00:02:41,500 --> 00:02:42,750
已經提出了在課堂上。

53
00:02:42,750 --> 00:02:46,550
所以study.cs50.net，全新的這種
今年，一個奇妙的資源。

54
00:02:46,550 --> 00:02:52,180
>> 接下來，我有男人，也就是手動
命令，你可以在運行

55
00:02:52,180 --> 00:02:52,770
命令行。

56
00:02:52,770 --> 00:02:57,880
所以，如果您對任何問題
命令，例如，蘭特，這是我們

57
00:02:57,880 --> 00:03:00,900
部分在上週遭遇
而你在已可能遇到

58
00:03:00,900 --> 00:03:05,380
通過去當你的設置的問題
生成的代碼，但如果你輸入man

59
00:03:05,380 --> 00:03:09,980
蘭特，你會得到的頁面
告訴你所有關於蘭特。

60
00:03:09,980 --> 00:03:14,040
它給你什麼需要時，
它需要的參數，以及返回

61
00:03:14,040 --> 00:03:16,530
類型和簡要說明
那功能。

62
00:03:16,530 --> 00:03:17,500
>> 因此，請檢查蘭特。

63
00:03:17,500 --> 00:03:22,270
它可以是一個有點羅嗦和混亂，
所以有時我覺得

64
00:03:22,270 --> 00:03:26,150
簡單的谷歌搜索什麼我想知道的是
找到答案的最佳途徑。

65
00:03:26,150 --> 00:03:27,940
因此，與谷歌的做法。

66
00:03:27,940 --> 00:03:28,600
獲得良好的谷歌。

67
00:03:28,600 --> 00:03:30,600
它會成為你最好的朋友。

68
00:03:30,600 --> 00:03:34,300
>> 以及谷歌，如果你不能找到它
在谷歌，cs50.net/discuss，它的

69
00:03:34,300 --> 00:03:35,550
討論論壇。

70
00:03:35,550 --> 00:03:39,390
機會是，如果你有一個問題，一是
你的700 +的同齡人也有

71
00:03:39,390 --> 00:03:42,110
問題可能問
它已經在討論

72
00:03:42,110 --> 00:03:43,540
論壇上，並讓它回答。

73
00:03:43,540 --> 00:03:48,130
所以，如果你有一個共同的問題或
您有想一個問題

74
00:03:48,130 --> 00:03:52,300
也許其他人可能碰上，
退房cs50.net/discuss。

75
00:03:52,300 --> 00:03:55,450
>> 最後，最後兩個，如果你想要
跟一個真正的人，辦公室

76
00:03:55,450 --> 00:03:57,770
時間週一至週五。

77
00:03:57,770 --> 00:04:00,850
還有網上辦公時間
延期的學生。

78
00:04:00,850 --> 00:04:04,370
最後但並非最不重要的，
我的驚嘆號。

79
00:04:04,370 --> 00:04:05,960
你們都有我的聯繫方式。

80
00:04:05,960 --> 00:04:11,940
如果你需要什麼，請千萬不要
隨時與我聯繫。

81
00:04:11,940 --> 00:04:14,020
總覺得自由地這樣做。

82
00:04:14,020 --> 00:04:17,490
只有極少數的你加了我的Gchat，
讓一直令人失望，

83
00:04:17,490 --> 00:04:20,410
但我希望那會改變之間
這一點，下一節。

84
00:04:20,410 --> 00:04:22,105
到目前為止，對資源的任何問題嗎？

85
00:04:22,105 --> 00:04:25,670

86
00:04:25,670 --> 00:04:27,450
大。

87
00:04:27,450 --> 00:04:34,280
>> 最後，另一個插頭
反饋，sayat.me/cs50。

88
00:04:34,280 --> 00:04:37,050
你可以給我匿名反饋
關於我是如何做。

89
00:04:37,050 --> 00:04:38,320
那是真正有用的最後一周。

90
00:04:38,320 --> 00:04:41,890
我有一對夫婦的評論從你們
右後部分，再加上從

91
00:04:41,890 --> 00:04:44,750
誰看了其他學生
在一周內，並且它

92
00:04:44,750 --> 00:04:46,830
是難以置信的幫助。

93
00:04:46,830 --> 00:04:50,250
我要嘗試限制我使用
單詞“甜”，但我會告訴我的

94
00:04:50,250 --> 00:04:52,410
熱情和興奮
在其他方面。

95
00:04:52,410 --> 00:04:56,550
但也有其他附加
實質性的反饋，

96
00:04:56,550 --> 00:04:57,600
雙方的長處和三角洲。

97
00:04:57,600 --> 00:05:00,480
所以，請我給你們反饋
關於您的問題集。

98
00:05:00,480 --> 00:05:01,790
隨時給我反饋
在我的教學。

99
00:05:01,790 --> 00:05:04,010
我在這裡給你們。

100
00:05:04,010 --> 00:05:05,270
>> 大。

101
00:05:05,270 --> 00:05:07,020
這就是我對
首節。

102
00:05:07,020 --> 00:05:08,565
沒有任何人有任何
問題這麼遠嗎？

103
00:05:08,565 --> 00:05:12,370

104
00:05:12,370 --> 00:05:14,640
和我有記
控制中心。

105
00:05:14,640 --> 00:05:21,200
擴展學生短信給我
說他們沒有得到任何音訊，

106
00:05:21,200 --> 00:05:23,870
但是這是我的力量來解決的。

107
00:05:23,870 --> 00:05:25,280
所以希望，即得到
短期內得到解決。

108
00:05:25,280 --> 00:05:28,850
如果你正在看在線，喜，
但你聽不到我的聲音。

109
00:05:28,850 --> 00:05:33,860
>> 因此，首先，我們要
要經過GDB。

110
00:05:33,860 --> 00:05:37,100
GDB，因為我暗示較早，
是一個調試工具

111
00:05:37,100 --> 00:05:39,040
比printf的要好得多。

112
00:05:39,040 --> 00:05:44,700
因此開始使用GDB，你們這些傢伙，如果
你要打開你的設備

113
00:05:44,700 --> 00:05:49,070
走，我通過電子郵件發送給您的文件
前面 - 這個文件也將是

114
00:05:49,070 --> 00:05:51,940
可在網上在一個位 - 

115
00:05:51,940 --> 00:05:55,700
和運行GDB /文件的名稱。

116
00:05:55,700 --> 00:05:58,580
首先，當然，你必須編譯
文件因為GDB只適用於

117
00:05:58,580 --> 00:05:59,890
可執行文件。

118
00:05:59,890 --> 00:06:02,300
>> 但是，如果你想開始
GDB，你要做的第一件事，

119
00:06:02,300 --> 00:06:04,550
你運行GDB /凱撒。

120
00:06:04,550 --> 00:06:08,340
所以這是我們的程序的名稱
去，現在用它去。

121
00:06:08,340 --> 00:06:12,810
所以我打算寫使凱撒，這
會給我一個可執行文件

122
00:06:12,810 --> 00:06:14,100
在這裡綠色突出。

123
00:06:14,100 --> 00:06:19,250
然後我要去運行GDB /塞薩爾。

124
00:06:19,250 --> 00:06:19,810
>> 和你去。

125
00:06:19,810 --> 00:06:24,540
你看我們有一些文字告訴我
關於廣發行的版本，給我

126
00:06:24,540 --> 00:06:27,570
一些保修信息，然後我們
有國內生產總值提示，這看起來有點

127
00:06:27,570 --> 00:06:29,350
像我們的命令行提示符下，
但是你看它的開放

128
00:06:29,350 --> 00:06:32,510
括號，GDB，密切括號。

129
00:06:32,510 --> 00:06:36,520
在我們繼續之前和調試這個文件
那我給你的一切，讓我們來看看

130
00:06:36,520 --> 00:06:40,220
一些有用的命令，所以我們有一種感覺，
什麼我們要覆蓋。

131
00:06:40,220 --> 00:06:45,060
>> 這些命令列在這裡的
順序我一般使用它們。

132
00:06:45,060 --> 00:06:50,230
所以我通過運行啟動我的程序
該方案的GBD。/名稱，

133
00:06:50,230 --> 00:06:51,360
在這種情況下，愷撒。

134
00:06:51,360 --> 00:06:57,430
然後我首先要做99.9％
的時間類型休息的意思。

135
00:06:57,430 --> 00:06:59,070
，在主設置一個斷點。

136
00:06:59,070 --> 00:07:03,260
從本質上講，你在做什麼有
是該程序將停止在

137
00:07:03,260 --> 00:07:06,100
主這樣你就可以開始研究它線
按行，而不是運行的所有

138
00:07:06,100 --> 00:07:07,040
一路走過。

139
00:07:07,040 --> 00:07:09,730
可以在不同的點在破
你的代碼，但主要是一個普遍

140
00:07:09,730 --> 00:07:11,870
良好的開端。

141
00:07:11,870 --> 00:07:14,840
>> 下一個命令我跑是跑。

142
00:07:14,840 --> 00:07:17,400
啟動該程序運行，並
如果你需要輸入的命令行

143
00:07:17,400 --> 00:07:19,090
的論點，你運行它的命令。

144
00:07:19,090 --> 00:07:20,500
與參數運行。

145
00:07:20,500 --> 00:07:25,000
這樣以來，我們去那邊的一個版本
C，這是該計劃你們的

146
00:07:25,000 --> 00:07:26,160
寫了PSET 2  - 

147
00:07:26,160 --> 00:07:29,880
這其中，當然，有一些錯誤
在它那希望我們會發現 - 

148
00:07:29,880 --> 00:07:32,810
我們將用一些命令來運行運行
行參數，因為愷撒，

149
00:07:32,810 --> 00:07:34,860
按問題你們知道
設置規範，需要一些

150
00:07:34,860 --> 00:07:36,380
命令行參數。

151
00:07:36,380 --> 00:07:40,000
>> 在接下來的幾個命令，下一個
一個是實際調用下一個。

152
00:07:40,000 --> 00:07:42,470
那一個你需要一行一行
通過你們的節目。

153
00:07:42,470 --> 00:07:45,800
所以打n，則輸入帶你
行到下一行，執行

154
00:07:45,800 --> 00:07:46,880
上一行。

155
00:07:46,880 --> 00:07:49,440
步驟不僅需要你
下一行，但它

156
00:07:49,440 --> 00:07:51,070
你需要在函數內部。

157
00:07:51,070 --> 00:07:54,310
所以，如果你寫一個函數
你的代碼或者如果您想探索

158
00:07:54,310 --> 00:07:57,820
以我為例，你可以打s和
而不是去的下一行

159
00:07:57,820 --> 00:08:02,390
你正在經歷右邊的文件
現在，你將真正步入

160
00:08:02,390 --> 00:08:04,670
這個函數然後看看它的代碼。

161
00:08:04,670 --> 00:08:12,300
>> 列表顯示，在非常人性化
格式，10行左右左右

162
00:08:12,300 --> 00:08:14,940
您當前所在的代碼
所以實際上你可以看到文件

163
00:08:14,940 --> 00:08:17,810
而不必交換背部和
來回之間不同的看法。

164
00:08:17,810 --> 00:08:21,890
打印是如printf，
顧名思義。

165
00:08:21,890 --> 00:08:24,020
這表明你是什麼一個變量等於。

166
00:08:24,020 --> 00:08:25,870
>> 信息本地人是真正有用的。

167
00:08:25,870 --> 00:08:27,740
這是印刷的特殊版本。

168
00:08:27,740 --> 00:08:31,770
信息當地人告訴你所有的地方的
變量，它們打印全力為您

169
00:08:31,770 --> 00:08:33,380
目前可用。

170
00:08:33,380 --> 00:08:36,360
所以我一般，而不必
打印出來的四個變量，我很

171
00:08:36,360 --> 00:08:39,929
好奇，如果我在一個for循環中，為
舉例來說，我只是寫信息本地人，

172
00:08:39,929 --> 00:08:43,470
它會告訴我什麼我的計數器i
等於，以及我是陣列

173
00:08:43,470 --> 00:08:45,130
工作平等。

174
00:08:45,130 --> 00:08:47,530
>> 最後，繼續。

175
00:08:47,530 --> 00:08:49,300
鍵入中斷停止你
在破發點。

176
00:08:49,300 --> 00:08:51,380
你可以通過走線
旁邊和步線。

177
00:08:51,380 --> 00:08:55,640
繼續運行程序到下一個
突破點，或直至完成，如果

178
00:08:55,640 --> 00:08:57,180
有沒有更多的破發點。

179
00:08:57,180 --> 00:09:00,060
禁用刪除斷點，如果你
決定在主要的突破是

180
00:09:00,060 --> 00:09:01,890
不當之處，你要
設置在別的地方。

181
00:09:01,890 --> 00:09:05,090
最後Q，退出，得到了廣發行。

182
00:09:05,090 --> 00:09:10,784
>> 所以這個程序，/撒，我們將
仔細看看，現在，我們

183
00:09:10,784 --> 00:09:13,490
要使用GDB找
臭蟲此計劃。

184
00:09:13,490 --> 00:09:18,110
我跑這個程序與前面
檢查50，我得到了一個皺眉。

185
00:09:18,110 --> 00:09:22,310
一切它的存在，它編譯的，它
通過大量的試驗，但對於

186
00:09:22,310 --> 00:09:27,950
由於某些原因，它沒有通過第五
測試中，轉向BARFOO，全部大寫，成

187
00:09:27,950 --> 00:09:33,350
E-D-U-R-R，全部大寫，
使用3作為密鑰。

188
00:09:33,350 --> 00:09:34,090
我得到了八九不離十。

189
00:09:34,090 --> 00:09:35,410
我由一個字母下車。

190
00:09:35,410 --> 00:09:37,340
因此，有一些小的失誤在這裡。

191
00:09:37,340 --> 00:09:38,070
我已經通過我的代碼看起來。

192
00:09:38,070 --> 00:09:38,850
我無法弄清楚。

193
00:09:38,850 --> 00:09:41,740
希望你們能幫助我
找出這個bug是。

194
00:09:41,740 --> 00:09:44,610
>> 所以這是我們的錯誤
尋找。

195
00:09:44,610 --> 00:09:46,090
讓我們繼續前進到GDB。

196
00:09:46,090 --> 00:09:51,100
再次，我已經運行GDB /凱撒，
所以現在我們在廣發行。

197
00:09:51,100 --> 00:09:54,290
什麼是第一
我應該做的事情嗎？

198
00:09:54,290 --> 00:09:56,680
我剛剛進入GDB。

199
00:09:56,680 --> 00:10:00,316
有人給我一個很好的
命令進入。

200
00:10:00,316 --> 00:10:01,140
>> 學生：休息為主。

201
00:10:01,140 --> 00:10:01,800
>> JASON HIRSCHHORN：休息為主。

202
00:10:01,800 --> 00:10:02,900
太棒了。

203
00:10:02,900 --> 00:10:03,560
讓我們鍵入英寸

204
00:10:03,560 --> 00:10:06,390
你們可以在這裡觀看或跟隨
沿著你的電腦上。

205
00:10:06,390 --> 00:10:09,410
打破主，你會看到一個
斷點設定在 - 

206
00:10:09,410 --> 00:10:12,340
它給了我一些奇怪的內存地址，
而這也給我的行號。

207
00:10:12,340 --> 00:10:15,310
如果我回頭看這個文件，
我想知道，主

208
00:10:15,310 --> 00:10:17,700
發生在第21行。

209
00:10:17,700 --> 00:10:18,950
我應該怎麼跑下一個？

210
00:10:18,950 --> 00:10:22,970

211
00:10:22,970 --> 00:10:25,060
是我的程序運行？

212
00:10:25,060 --> 00:10:25,650
號

213
00:10:25,650 --> 00:10:27,175
所以，我應該怎麼跑下一個？

214
00:10:27,175 --> 00:10:27,520
>> 學生：運行。

215
00:10:27,520 --> 00:10:28,050
>> JASON HIRSCHHORN：運行。

216
00:10:28,050 --> 00:10:30,760
如果我只是跑跑步，還是應該
我在添加一些其他的東西？

217
00:10:30,760 --> 00:10:31,960
>> 學生：使用參數運行。

218
00:10:31,960 --> 00:10:33,320
>> JASON HIRSCHHORN：與運行
命令參數。

219
00:10:33,320 --> 00:10:36,420
而且因為我調試一個非常具體的
情況下，我應該輸入

220
00:10:36,420 --> 00:10:37,120
命令行參數。

221
00:10:37,120 --> 00:10:42,290
所以我會做運行三個，這是，再次，
我從50檢查了輸出。

222
00:10:42,290 --> 00:10:44,240
啟動程序。

223
00:10:44,240 --> 00:10:45,420
我們通過幾行。

224
00:10:45,420 --> 00:10:47,700
現在你會看到，我們是在第21行。

225
00:10:47,700 --> 00:10:49,200
我怎麼知道，我們是在第21行？

226
00:10:49,200 --> 00:10:52,170
因為如果你向左邊看
我的終端窗口中，有

227
00:10:52,170 --> 00:10:53,120
它說21行。

228
00:10:53,120 --> 00:10:57,010
這給了我，其實，
代碼是在第21行。

229
00:10:57,010 --> 00:10:58,440
所以我剛才講錯。

230
00:10:58,440 --> 00:10:59,770
主要是不實際在第21行。

231
00:10:59,770 --> 00:11:02,000
主要是上述21幾行。

232
00:11:02,000 --> 00:11:04,300
但在第21行，這是
我們正在打破。

233
00:11:04,300 --> 00:11:06,280
這行代碼有
尚未執行。

234
00:11:06,280 --> 00:11:06,890
這一點很重要。

235
00:11:06,890 --> 00:11:09,120
你看行不有
尚未執行。

236
00:11:09,120 --> 00:11:12,650
這就是下一行代碼
你即將執行。

237
00:11:12,650 --> 00:11:15,860
>> 所以下一行，因為你們是
可能熟悉，這是

238
00:11:15,860 --> 00:11:20,070
狀態檢查，看看我是否有
輸入的命令行參數。

239
00:11:20,070 --> 00:11:22,140
和A至I，什麼是第二
這樣做的一部分？

240
00:11:22,140 --> 00:11:23,457
什麼是對我？

241
00:11:23,457 --> 00:11:24,950
>> 學生：它更改為一個整數。

242
00:11:24,950 --> 00:11:25,450
>> JASON HIRSCHHORN：對不起？

243
00:11:25,450 --> 00:11:27,400
>> 學生：它改變了
參數的整數。

244
00:11:27,400 --> 00:11:30,890
>> JASON HIRSCHHORN：所以一到我的變化ARG
卷從一個字符串為整數。

245
00:11:30,890 --> 00:11:32,140
然後它是什麼檢查？

246
00:11:32,140 --> 00:11:35,414

247
00:11:35,414 --> 00:11:37,112
>> 學生：如果有一個第二
命令行參數，除了

248
00:11:37,112 --> 00:11:38,100
運行該程序。

249
00:11:38,100 --> 00:11:39,460
>> JASON HIRSCHHORN：什麼是
在此第二半

250
00:11:39,460 --> 00:11:41,220
布爾表達式檢查？

251
00:11:41,220 --> 00:11:42,540
這部分在這裡，一來我？

252
00:11:42,540 --> 00:11:44,080
>> 學生：如果是負數。

253
00:11:44,080 --> 00:11:45,380
>> JASON HIRSCHHORN：確保什麼？

254
00:11:45,380 --> 00:11:47,120
>> 學生：確保它
是，實際上正。

255
00:11:47,120 --> 00:11:47,650
>> JASON HIRSCHHORN：沒錯。

256
00:11:47,650 --> 00:11:50,600
這被檢查，看它是否
負的，而如果它是負的，我

257
00:11:50,600 --> 00:11:53,220
有一種感覺，下一行可能
被我罵的用戶。

258
00:11:53,220 --> 00:11:55,930
因此，讓我們打結束時執行這條線。

259
00:11:55,930 --> 00:11:59,925
我們沒有看到該行的你們
也許期望看到大喊大叫的

260
00:11:59,925 --> 00:12:03,030
用戶再回來，因為
這一行沒有執行。

261
00:12:03,030 --> 00:12:03,840
我進入3。

262
00:12:03,840 --> 00:12:06,860
所以，我沒有，事實上，輸入兩個命令
行參數，和3

263
00:12:06,860 --> 00:12:07,610
大於零。

264
00:12:07,610 --> 00:12:09,950
所以，我們看到那行，我們執行，
但我們沒踩

265
00:12:09,950 --> 00:12:11,300
裡面的if條件。

266
00:12:11,300 --> 00:12:17,060
>> 所以，現在，未來，我看到我設置
整型鍵等於給我精氨酸卷。

267
00:12:17,060 --> 00:12:18,840
所以這是我創建一個可變密鑰。

268
00:12:18,840 --> 00:12:22,450
所以，如果我打印出來的關鍵，現在，因為
這可以讓你看到的

269
00:12:22,450 --> 00:12:26,040
值裡面的變量，
關鍵等於47。

270
00:12:26,040 --> 00:12:28,810
這是奇怪的，但當然，
那是因為我沒有

271
00:12:28,810 --> 00:12:30,490
執行該行呢。

272
00:12:30,490 --> 00:12:35,880
所以，現在如果我打了N，執行該行，
並做打印鍵，鍵將等於3，

273
00:12:35,880 --> 00:12:37,740
這是我們期望它等於。

274
00:12:37,740 --> 00:12:41,170
>> 如此反复，在廣發行，行啦
看你有沒有執行。

275
00:12:41,170 --> 00:12:44,850
你必須打N或S或數字
其他命令來實際的

276
00:12:44,850 --> 00:12:46,610
執行該行。

277
00:12:46,610 --> 00:12:47,380
打印鍵。

278
00:12:47,380 --> 00:12:48,280
關鍵的第3。

279
00:12:48,280 --> 00:12:49,750
到目前為止，一切都很好。

280
00:12:49,750 --> 00:12:51,000
String是純文本。

281
00:12:51,000 --> 00:12:52,270
讓我們來執行該行。

282
00:12:52,270 --> 00:12:53,970
我是從用戶得到的字符串。

283
00:12:53,970 --> 00:12:58,690
>> 讓我們在我入住50看，我
進入BARFOO全部大寫，所以

284
00:12:58,690 --> 00:13:01,330
這就是我進入。

285
00:13:01,330 --> 00:13:07,300
如果我現在打印純文本。

286
00:13:07,300 --> 00:13:08,610
你會看到它等於一個字符串。

287
00:13:08,610 --> 00:13:11,100
它給了我一些其他怪異的十六進制
數，但它在

288
00:13:11,100 --> 00:13:13,620
其實說我的字符串是BARFOO。

289
00:13:13,620 --> 00:13:19,308
如果我想看看什麼鍵相當於在
這點，我怎麼可以檢查關鍵？

290
00:13:19,308 --> 00:13:20,710
>> 學生：打印鍵。

291
00:13:20,710 --> 00:13:22,010
>> JASON HIRSCHHORN：Print鍵，沒錯。

292
00:13:22,010 --> 00:13:23,260
而實際上，有一個快捷方式。

293
00:13:23,260 --> 00:13:25,910
如果你厭倦了打字印刷的，
你可以只輸入p。

294
00:13:25,910 --> 00:13:28,340
所以，p鍵做同樣的事情。

295
00:13:28,340 --> 00:13:29,730
又一次，我看到它等於3。

296
00:13:29,730 --> 00:13:34,760
>> 如果我想找出什麼兩大關鍵
和BARFOO相當於在同一時間

297
00:13:34,760 --> 00:13:37,215
但我累了打字每
一出單獨，我

298
00:13:37,215 --> 00:13:38,590
可以輸入信息本地人。

299
00:13:38,590 --> 00:13:41,170
這給了我鑰匙等於3。

300
00:13:41,170 --> 00:13:42,500
純文本等於BARFOO。

301
00:13:42,500 --> 00:13:45,265
這也給了我這兩個奇怪的事情
在頂部，該變量i和

302
00:13:45,265 --> 00:13:46,590
這個變量n。

303
00:13:46,590 --> 00:13:48,460
>> 這些都是實際存在的
在我的主程序。

304
00:13:48,460 --> 00:13:51,280
我們還沒有遇到過他們呢，
但作為預覽，那些

305
00:13:51,280 --> 00:13:52,880
存在於我的for循環。

306
00:13:52,880 --> 00:13:55,360
所以現在，他們平等有些怪異
數字，因為他們沒有被

307
00:13:55,360 --> 00:13:58,300
初始化還沒有，但它們仍然存在
在內存中，所以他們只是設置

308
00:13:58,300 --> 00:14:00,220
一些垃圾值。

309
00:14:00,220 --> 00:14:02,890
但是我們看到在關鍵平原
文字在那裡。

310
00:14:02,890 --> 00:14:06,390
>> 所以，我要執行這條線，
第34行，for循環。

311
00:14:06,390 --> 00:14:08,220
我們要跳進
for循環擊中ñ。

312
00:14:08,220 --> 00:14:10,050
而且我們內部的for循環。

313
00:14:10,050 --> 00:14:11,360
我們是在我們的第一次檢查。

314
00:14:11,360 --> 00:14:14,300
再次，這些都應該有點期待
你熟悉的，因為這是一個

315
00:14:14,300 --> 00:14:18,080
寫凱撒程序，但
再次，有一些類型的錯誤。

316
00:14:18,080 --> 00:14:21,940
>> 現在如果我做信息本地人，因為我
裡面的那個for循環，你會看到

317
00:14:21,940 --> 00:14:23,900
我等於零，正如我們期望的那樣。

318
00:14:23,900 --> 00:14:26,820
這就是我們將其設置為和初始化
它在for循環。

319
00:14:26,820 --> 00:14:27,560
n等於6。

320
00:14:27,560 --> 00:14:30,700
這也有道理，因為我們設置
它以純文本的strlen的。

321
00:14:30,700 --> 00:14:34,270
所以我喜歡做信息本地人或打印
到變量經常以確保

322
00:14:34,270 --> 00:14:36,370
一切總是什麼
我希望它等於。

323
00:14:36,370 --> 00:14:39,800
在這種情況下，一切都
我希望它等於。

324
00:14:39,800 --> 00:14:41,850
>> 因此，讓我們開始通過移動
這個for循環。

325
00:14:41,850 --> 00:14:45,715
我上線是36行，如果純
文字i大於一個樸素

326
00:14:45,715 --> 00:14:48,540
文本i小於或等於z。

327
00:14:48,540 --> 00:14:51,880
我知道我的問題是不是與我的第一次
信中，它與第二個字母。

328
00:14:51,880 --> 00:14:56,290
如果我們回頭看檢查
50，B進入到E的罰款。

329
00:14:56,290 --> 00:14:59,010
我要帶A和把它當作
一個A，而不是將其更改為D。所以，

330
00:14:59,010 --> 00:15:00,200
什麼是錯的
第二個字母。

331
00:15:00,200 --> 00:15:01,640
所以，我要動
在第二那裡。

332
00:15:01,640 --> 00:15:06,030
>> 但是，如果我沒有想檢查什麼純
文字我等於在這個特殊的

333
00:15:06,030 --> 00:15:07,760
情況下，我覺得應該是什麼？

334
00:15:07,760 --> 00:15:10,980
我應該明文等於我在這
通過第一輪的循環？

335
00:15:10,980 --> 00:15:14,046

336
00:15:14,046 --> 00:15:15,110
>> 學生：零？

337
00:15:15,110 --> 00:15:16,510
>> JASON HIRSCHHORN：我純文本？

338
00:15:16,510 --> 00:15:21,180
所以它應該是資本B的我，當然，
為零，但純文本

339
00:15:21,180 --> 00:15:25,600
支架零閉合支架等於乙
因為字符串，如我們上週看到的，

340
00:15:25,600 --> 00:15:28,650
是數組，所以我們得到的
第一個字符從。

341
00:15:28,650 --> 00:15:34,960
所以，再一次，如果我打印出來的純文本
我，我，其實得到的字符

342
00:15:34,960 --> 00:15:36,560
B.這就是整齊的，對不對？

343
00:15:36,560 --> 00:15:40,380
我實際上並沒有明文一
這不是我設置的變量之一

344
00:15:40,380 --> 00:15:42,950
或初始化，但你可以打印
出了事情一大堆

345
00:15:42,950 --> 00:15:45,640
如果你想。

346
00:15:45,640 --> 00:15:47,340
>> 但是，讓我們移動。

347
00:15:47,340 --> 00:15:50,050
如果純文本我是和大於
明文I小於或等於

348
00:15:50,050 --> 00:15:53,290
Z，這顯然是正確的，因為我們有
資本B.我要去跑

349
00:15:53,290 --> 00:15:54,230
它的一些命令。

350
00:15:54,230 --> 00:15:58,530
我們看到，數學最後一周，所以我們將
想當然，它的工作原理

351
00:15:58,530 --> 00:16:00,900
根據權利檢查50。

352
00:16:00,900 --> 00:16:03,720
>> 這些大括號，第一個
結果顯示，我是退出，如果

353
00:16:03,720 --> 00:16:07,030
條件，第二個顯示
那我退出for循環。

354
00:16:07,030 --> 00:16:10,400
所以現在當我打接下來，我們將看到
我們回來在for循環一次。

355
00:16:10,400 --> 00:16:11,970
我們正在經歷的
再次循環。

356
00:16:11,970 --> 00:16:18,110
讓我們真正步入第二
迭代的for循環和類型

357
00:16:18,110 --> 00:16:20,520
信息本地人。

358
00:16:20,520 --> 00:16:22,190
>> 所以我們在第二次迭代
我們的for循環。

359
00:16:22,190 --> 00:16:24,530
我等於1，這是我們期望的。

360
00:16:24,530 --> 00:16:26,650
N等於6，而我們預期。

361
00:16:26,650 --> 00:16:28,810
關鍵等於3，這是我們期望的。

362
00:16:28,810 --> 00:16:32,625
和純文本，你會看到，等於
EARFOO現在，沒有BARFOO了，因為

363
00:16:32,625 --> 00:16:37,930
在我們先前的迭代中，B為
改為大寫E。所以我們即將

364
00:16:37,930 --> 00:16:40,040
遇到的問題，所以這
在這裡我們要

365
00:16:40,040 --> 00:16:41,130
潛入調試。

366
00:16:41,130 --> 00:16:43,365
但是，沒有任何人有任何問題
關於我們到目前為止已經做了什麼？

367
00:16:43,365 --> 00:16:46,770

368
00:16:46,770 --> 00:16:47,910
太棒了。

369
00:16:47,910 --> 00:16:52,710
>> 所以我們一下，如果執行此
條件下，純文本支架我關閉

370
00:16:52,710 --> 00:16:57,500
比A和支架更大的純文本我
小於或等於Z。但在此之前

371
00:16:57,500 --> 00:17:00,450
我進入了，因為這是
我知道我的錯誤，我想點

372
00:17:00,450 --> 00:17:06,859
出一的純文本，以便
讓我們把打印出來。

373
00:17:06,859 --> 00:17:12,020
它等於字符A，使
似乎到目前為止，一切都很好，不錯。

374
00:17:12,020 --> 00:17:14,740
>> 所以我希望我的每邏輯這條線，
這條線應該是真實的。

375
00:17:14,740 --> 00:17:16,099
這是一個大寫字母。

376
00:17:16,099 --> 00:17:20,599
但如果我打了N，我們要明白，這個
行，其實並沒有執行。

377
00:17:20,599 --> 00:17:22,609
我跳進來的東西，如果。

378
00:17:22,609 --> 00:17:25,460
為什麼會這樣？

379
00:17:25,460 --> 00:17:27,480
>> 學生：因為你有你的條件
純文本的大

380
00:17:27,480 --> 00:17:29,130
比A，不等於或大於。

381
00:17:29,130 --> 00:17:32,260
>> JASON HIRSCHHORN：所以我有我的純文本
我大於A，不大於

382
00:17:32,260 --> 00:17:32,850
小於或等於。

383
00:17:32,850 --> 00:17:38,130
所以很明顯，資本A沒有
如果條件觸發這一點，我們做

384
00:17:38,130 --> 00:17:40,520
沒有踏進去，和我們做
沒有做必要的轉變。

385
00:17:40,520 --> 00:17:41,360
所以這是它，其實。

386
00:17:41,360 --> 00:17:42,920
我想通了，我的錯誤。

387
00:17:42,920 --> 00:17:46,775
我可以回去在我的源文件，
改變它，更新它，

388
00:17:46,775 --> 00:17:47,855
運行再次檢查50。

389
00:17:47,855 --> 00:17:52,590
>> 但我們會看到，只是為了教學的
的緣故，如果我堅持去做。

390
00:17:52,590 --> 00:17:59,580
本否則，如果不執行下去，但
什麼，而不是等於就是命令

391
00:17:59,580 --> 00:18:00,500
不改變。

392
00:18:00,500 --> 00:18:04,840
所以它沒有改變，如果我
這裡打印純文本，我們會看到去

393
00:18:04,840 --> 00:18:08,250
通過for循環沒有，事實上，
改變第二個字符的。

394
00:18:08,250 --> 00:18:09,600
它仍然是一個大寫字母A。

395
00:18:09,600 --> 00:18:12,690
>> 所以，再一次，我們調試我們的錯誤。

396
00:18:12,690 --> 00:18:17,380
我們意識到有
一些邏輯缺失。

397
00:18:17,380 --> 00:18:20,590
和我們之前調試它的時間提前
實際執行這條線，

398
00:18:20,590 --> 00:18:24,320
但你會注意到有我們只是
點擊Next，並跳轉到否則，如果，

399
00:18:24,320 --> 00:18:26,710
這意味著，如果條件
是不正確的。

400
00:18:26,710 --> 00:18:29,550
我們沒有，事實上，獲得
結果我們的預期。

401
00:18:29,550 --> 00:18:33,240
這樣的話，我們可能已經提示，有
我們沒有這麼精明，看

402
00:18:33,240 --> 00:18:38,510
如果條件和檢查的話，其實，
我們的條件應計算為

403
00:18:38,510 --> 00:18:41,150
真正在目前情況下。

404
00:18:41,150 --> 00:18:42,880
>> 這是所有用於調試這個程序。

405
00:18:42,880 --> 00:18:45,340
沒有任何人有任何問題嗎？

406
00:18:45,340 --> 00:18:50,486
我可以打什麼命令退出GDB？

407
00:18:50,486 --> 00:18:53,900
問：然後我就被提示，
退出呢？

408
00:18:53,900 --> 00:18:54,390
是或否。

409
00:18:54,390 --> 00:18:58,440
我會打，是的，我會相繼退出GDB。

410
00:18:58,440 --> 00:19:00,860
>> 所以這是一個快速入門到GDB。

411
00:19:00,860 --> 00:19:03,430
實際上，在實際情況下，
我這樣做是在辦公時間。

412
00:19:03,430 --> 00:19:06,710
我GDBed在這個確切的程序
辦公時間與學生。

413
00:19:06,710 --> 00:19:12,410
如果我們回去，我們看到的命令
之前，我們使用了破發主力，第一

414
00:19:12,410 --> 00:19:13,190
的事情，我們做到了。

415
00:19:13,190 --> 00:19:16,060
我們使用命令行參數運行，
第二件事情，我們做到了。

416
00:19:16,060 --> 00:19:18,520
接下來，我們用了很多移動
我們通過線。

417
00:19:18,520 --> 00:19:20,310
再次，短版
旁為n。

418
00:19:20,310 --> 00:19:22,920
這是在括號
在灰色的幻燈片。

419
00:19:22,920 --> 00:19:28,590
>> 我們沒有使用的步驟，但是我們並沒有
一定需要這種情況。

420
00:19:28,590 --> 00:19:32,150
但是，我們可能會在稍後使用它
今天，如果我們正在調試，為

421
00:19:32,150 --> 00:19:36,500
例如，二進制搜索二進制時
搜索被稱為在一個單獨的

422
00:19:36,500 --> 00:19:38,200
的功能，但有
與它的一些錯誤。

423
00:19:38,200 --> 00:19:40,440
我們將要步入
調用二進制搜索和

424
00:19:40,440 --> 00:19:41,840
實際調試它。

425
00:19:41,840 --> 00:19:45,130
列表中，我們沒有使用或者是因為我們有
我們的代碼感好，但如果我

426
00:19:45,130 --> 00:19:48,420
沒有想要得到的是什麼代碼，我感
在旁邊，我可以只使用列表中。

427
00:19:48,420 --> 00:19:50,310
>> 打印我們使用，我們使用信息的當地人。

428
00:19:50,310 --> 00:19:53,260
繼續我們並不需要在此使用
情況下，我們也沒有需要使用

429
00:19:53,260 --> 00:19:55,060
禁用的，但我們確實使用了退出。

430
00:19:55,060 --> 00:19:57,850
同樣，這些10的命令，
實踐它們。

431
00:19:57,850 --> 00:20:00,770
如果你了解這10個命令，
你應該調試任何設置

432
00:20:00,770 --> 00:20:02,525
發用GDB。

433
00:20:02,525 --> 00:20:05,230

434
00:20:05,230 --> 00:20:08,420
>> 所以我們馬上就要去上，再次向
部分的癥結今天，去了

435
00:20:08,420 --> 00:20:09,720
這些排序和搜索
算法。

436
00:20:09,720 --> 00:20:14,075
在這樣做之前，再次，有任何疑問，
意見，關注的廣發行？

437
00:20:14,075 --> 00:20:16,750

438
00:20:16,750 --> 00:20:20,960
所以大家是要使用
GDB而不是printf的？

439
00:20:20,960 --> 00:20:24,550
所以每個人都為永久的緣故，
大家都點頭他們的頭向右

440
00:20:24,550 --> 00:20:27,400
現在，我會看到你在辦公時間
和所有的轉錄因子會看到你和

441
00:20:27,400 --> 00:20:29,460
他們會說，告訴我怎麼用
GDB，你就可以

442
00:20:29,460 --> 00:20:31,240
向他們展示，對不對？

443
00:20:31,240 --> 00:20:31,760
樣的？

444
00:20:31,760 --> 00:20:32,640
也許有希望。

445
00:20:32,640 --> 00:20:33,670
涼爽。

446
00:20:33,670 --> 00:20:35,790
>> 所以，我們要進入
排序和搜索。

447
00:20:35,790 --> 00:20:40,710
你會看到我已經排序的列表
對我們來說，但不會

448
00:20:40,710 --> 00:20:42,220
是這種情況總是如此。

449
00:20:42,220 --> 00:20:49,170
所以在問題設置規範
問題設定了三個，你有短褲

450
00:20:49,170 --> 00:20:51,410
你可以看，它實際上
請你看看那些短褲。

451
00:20:51,410 --> 00:20:55,090
此外，在演講最後一周，我們走過去
很多這樣的算法，所以我

452
00:20:55,090 --> 00:20:59,150
不會花時間在課堂上會
一遍這些算法或圖紙

453
00:20:59,150 --> 00:21:01,130
圖片，如何將這些
算法工作。

454
00:21:01,130 --> 00:21:04,030
同樣，這些信息您可以重新手錶
講座中，或者該信息

455
00:21:04,030 --> 00:21:08,570
被捕獲出色的短褲
對於這些搜索所有的，

456
00:21:08,570 --> 00:21:10,920
這可在cs50.net。

457
00:21:10,920 --> 00:21:14,200
>> 所以，我們要去什麼
要做的就是編寫這些程序。

458
00:21:14,200 --> 00:21:18,190
我們有一個感覺，一個心智模式如何，
他們的工作，還等什麼，我們要去

459
00:21:18,190 --> 00:21:20,210
要做的就是對它們進行編碼真實的。

460
00:21:20,210 --> 00:21:23,430
我們打算把這一心智模式，
那張照片，如果你願意，進

461
00:21:23,430 --> 00:21:24,960
實際代碼。

462
00:21:24,960 --> 00:21:28,460
如果你是一個有點困惑或
朦朧的心智模式，我完全

463
00:21:28,460 --> 00:21:28,770
明白了。

464
00:21:28,770 --> 00:21:30,540
>> 我們不會實際去
跳轉到代碼通俗易懂。

465
00:21:30,540 --> 00:21:36,030
因此，儘管這個提示在這張幻燈片問
你的代碼的二進制搜索，並

466
00:21:36,030 --> 00:21:39,470
實際上，一個迭代版本
二進制搜索，第一件事我

467
00:21:39,470 --> 00:21:42,370
真的希望你做的是
寫一些偽代碼。

468
00:21:42,370 --> 00:21:47,020
所以，你有這個心理模型
如何二進制搜索作品。

469
00:21:47,020 --> 00:21:50,060
拿出一張紙，如果你有
1一應俱全，或者打開一個

470
00:21:50,060 --> 00:21:52,520
文本編輯器，我想
大家都來寫。

471
00:21:52,520 --> 00:21:57,470
連拿4分寫
偽代碼二進制​​搜索。

472
00:21:57,470 --> 00:21:58,990
>> 再次，想想心理模型。

473
00:21:58,990 --> 00:22:01,980
我會回來的，如果你有任何問題
我們可以得出的圖片出來。

474
00:22:01,980 --> 00:22:06,220
但首先，我們開始編程之前，
我想要寫

475
00:22:06,220 --> 00:22:09,920
偽代碼的二進制搜索，所以當我們
潛水，我們有一些方向

476
00:22:09,920 --> 00:22:12,110
的地方，我們應該前往。

477
00:22:12,110 --> 00:22:15,330
>> 學生：我們是否可以假設數組
我們得到的值已經排序？

478
00:22:15,330 --> 00:22:17,960
>> JASON HIRSCHHORN：所以對於二進制搜索
工作 - 優秀的問題 - 你

479
00:22:17,960 --> 00:22:20,970
必須採取以排序
數組值。

480
00:22:20,970 --> 00:22:22,290
所以，假設它會奏效。

481
00:22:22,290 --> 00:22:23,480
我們將回到這個幻燈片。

482
00:22:23,480 --> 00:22:27,220
紫色的功能，你會看到
聲明布爾整型binary_search的

483
00:22:27,220 --> 00:22:29,230
值，int值，詮釋n。

484
00:22:29,230 --> 00:22:32,910
這應該看起來很熟悉，如果你已經
已經接近或得到你

485
00:22:32,910 --> 00:22:34,580
手臟與習題集。

486
00:22:34,580 --> 00:22:35,910
>> 但是，這是你的函數聲明。

487
00:22:35,910 --> 00:22:39,080
再次，應該不需要擔心
這麼多在這一刻。

488
00:22:39,080 --> 00:22:43,660
我真的希望你做的是採取
四分鐘的偽代碼的二進制

489
00:22:43,660 --> 00:22:46,380
搜索，然後我們就去
以上，作為一個組。

490
00:22:46,380 --> 00:22:47,500
我會來到我身邊。

491
00:22:47,500 --> 00:22:49,590
如果您有任何疑問，請隨時
自由地舉起你的手。

492
00:22:49,590 --> 00:25:07,110

493
00:25:07,110 --> 00:25:09,680
>> 你為什麼不走兩分鐘
完成了偽碼？

494
00:25:09,680 --> 00:25:13,690

495
00:25:13,690 --> 00:25:15,820
我知道這可能看起來荒謬的，
我們花那麼多時間

496
00:25:15,820 --> 00:25:20,350
東西甚至不是真正的
C，但尤其是對於這些更

497
00:25:20,350 --> 00:25:24,030
具有挑戰性的算法和問題
集，我們要搞清楚，

498
00:25:24,030 --> 00:25:27,210
開始在偽不擔心
有關語法，只是擔心

499
00:25:27,210 --> 00:25:29,150
邏輯，是難以置信的幫助。

500
00:25:29,150 --> 00:25:32,720
而這樣一來，你不求解兩個
令人難以置信的困難問題一次。

501
00:25:32,720 --> 00:25:35,390
你只是專注於邏輯，
然後你進入的語法。

502
00:25:35,390 --> 00:25:59,960

503
00:25:59,960 --> 00:26:01,385
>> 確定。

504
00:26:01,385 --> 00:26:03,680
讓我們開始經歷
偽代碼。

505
00:26:03,680 --> 00:26:05,380
我已經寫在這裡，二進制
搜索偽代碼。

506
00:26:05,380 --> 00:26:07,360
我們會寫這篇文章的上
登上在一起。

507
00:26:07,360 --> 00:26:10,040
或者我會寫它，你會得到
我我需要的提示。

508
00:26:10,040 --> 00:26:15,010
所以，有誰能夠給我的第一個
偽代碼的行，你

509
00:26:15,010 --> 00:26:18,350
寫了二進制搜索？

510
00:26:18,350 --> 00:26:20,258
是的，安妮？

511
00:26:20,258 --> 00:26:22,698
>> 學生：雖然的長度
列表是大於零。

512
00:26:22,698 --> 00:26:26,114

513
00:26:26,114 --> 00:26:34,880
>> JASON HIRSCHHORN：雖然長度
的商大於零。

514
00:26:34,880 --> 00:26:38,810
又一次，我們看到一些C的前瞻性
在這裡語法的東西。

515
00:26:38,810 --> 00:26:41,550
但大部分是英文的。

516
00:26:41,550 --> 00:26:43,980
有沒有人有他們提出的任何行
在此之前他們的偽代碼？

517
00:26:43,980 --> 00:26:47,280

518
00:26:47,280 --> 00:26:50,210
>> 學生：獲得一個數組
的分類數字。

519
00:26:50,210 --> 00:26:53,600
>> JASON HIRSCHHORN：你寫了“得到一個
數組排序的數字。“每

520
00:26:53,600 --> 00:26:56,140
函數的聲明，我們將通過
排序的數字的陣列。

521
00:26:56,140 --> 00:26:57,280
>> 學生：[聽不清]。

522
00:26:57,280 --> 00:26:59,030
>> JASON HIRSCHHORN：所以
我們將具有。

523
00:26:59,030 --> 00:27:01,820
但是，是的，如果我們沒有，我們
就需要我們對數組進行排序

524
00:27:01,820 --> 00:27:04,850
數字，因為二進制搜索
僅適用於排序數組。

525
00:27:04,850 --> 00:27:11,300
因此，儘管列表的長度為零，我
打算把一些大括號

526
00:27:11,300 --> 00:27:15,420
使它看起來更有點像
C.但同時，似乎映射到

527
00:27:15,420 --> 00:27:19,550
while循環，所以這裡面，而
循環什麼，我們需要

528
00:27:19,550 --> 00:27:22,000
做二進制搜索？

529
00:27:22,000 --> 00:27:25,530
>> 別人誰沒有給我一個
但回答卻是誰寫的呢？

530
00:27:25,530 --> 00:27:31,750

531
00:27:31,750 --> 00:27:33,320
>> 學生：到列表的中間。

532
00:27:33,320 --> 00:27:33,980
>> JASON HIRSCHHORN：湯姆。

533
00:27:33,980 --> 00:27:35,230
轉到列表的中間。

534
00:27:35,230 --> 00:27:43,290

535
00:27:43,290 --> 00:27:45,530
和後續的問題，什麼
我們做一次，我們在

536
00:27:45,530 --> 00:27:46,870
列表中的中間？

537
00:27:46,870 --> 00:27:49,310
>> 學生：做一個檢查這是否是
你要找的數量。

538
00:27:49,310 --> 00:27:50,120
>> JASON HIRSCHHORN：優秀。

539
00:27:50,120 --> 00:28:05,500
走在列表的中間，並檢查
如果我們的價值在那裡 - 

540
00:28:05,500 --> 00:28:06,515
太棒了。

541
00:28:06,515 --> 00:28:10,460
沒有任何人有任何東西
這是比這有什麼不同？

542
00:28:10,460 --> 00:28:11,210
這是完全正確的。

543
00:28:11,210 --> 00:28:13,800
>> 我們在做二進制搜索的第一件事
被轉到列表的中間，

544
00:28:13,800 --> 00:28:15,870
檢查，看看是否我們的價值是存在的。

545
00:28:15,870 --> 00:28:19,682
所以我想，如果我們的價值
在那裡，我們該怎麼做？

546
00:28:19,682 --> 00:28:21,610
>> 學生：我們回到零[聽不清]。

547
00:28:21,610 --> 00:28:23,400
>> JASON HIRSCHHORN：是啊，如果我們的
價值是存在的，我們發現它。

548
00:28:23,400 --> 00:28:27,950
因此，我們可以不過告訴某種程度上，這
函數的定義，我們告訴用戶

549
00:28:27,950 --> 00:28:28,520
我們發現它。

550
00:28:28,520 --> 00:28:30,950
如果它不存在，雖然，這是
這哪裡得到棘手。

551
00:28:30,950 --> 00:28:35,120
所以，如果它不存在，別人誰
正在對二進制搜索或

552
00:28:35,120 --> 00:28:36,830
有一個想法，現在，我們該怎麼做？

553
00:28:36,830 --> 00:28:37,830
>> 學生：問題。

554
00:28:37,830 --> 00:28:38,100
>> JASON HIRSCHHORN：怎麼了？

555
00:28:38,100 --> 00:28:39,920
>> 學生：是的數組已經排序？

556
00:28:39,920 --> 00:28:42,200
>> JASON HIRSCHHORN：是的，我們假設
該數組已經排序。

557
00:28:42,200 --> 00:28:46,480
>> 學生：所以，你必須檢查
你看到的值大於

558
00:28:46,480 --> 00:28:51,745
你想要的值，你可以移動
到另一半的中間。

559
00:28:51,745 --> 00:28:54,110
>> JASON HIRSCHHORN：所以，如果中間
清單大於我們在做什麼

560
00:28:54,110 --> 00:28:57,440
尋找，然後我們做什麼？

561
00:28:57,440 --> 00:28:58,320
我們謹在哪裡？

562
00:28:58,320 --> 00:29:01,400
>> 學生：你想要移動到
列表中的與半

563
00:29:01,400 --> 00:29:02,780
數字低於。

564
00:29:02,780 --> 00:29:04,460
>> JASON HIRSCHHORN：所以我們會
調用的左側。

565
00:29:04,460 --> 00:29:15,435
因此，如果中間是更大的，我們可以搜索
列表的左邊一半。

566
00:29:15,435 --> 00:29:20,620

567
00:29:20,620 --> 00:29:22,980
然後通過搜索什麼
我的意思是搜索？

568
00:29:22,980 --> 00:29:24,010
>> 學生：[聽不清]。

569
00:29:24,010 --> 00:29:24,410
>> JASON HIRSCHHORN：我們去中間。

570
00:29:24,410 --> 00:29:25,740
事實上，我們重複這件事情。

571
00:29:25,740 --> 00:29:29,210
我們回去通過我們的while循環。

572
00:29:29,210 --> 00:29:31,480
我給你最後一個 - 

573
00:29:31,480 --> 00:29:39,047
否則，如果中間是少了什麼
我們做什麼，我們該怎麼做嗎？

574
00:29:39,047 --> 00:29:40,360
>> 學生：你可以向右邊。

575
00:29:40,360 --> 00:29:41,610
>> JASON HIRSCHHORN：搜索的權利。

576
00:29:41,610 --> 00:29:47,440

577
00:29:47,440 --> 00:29:51,710
這看起來不錯，但沒有任何人有
任何事情，我們可能會丟失或

578
00:29:51,710 --> 00:29:53,200
別的，你把
在你的偽代碼？

579
00:29:53,200 --> 00:29:57,080

580
00:29:57,080 --> 00:29:58,410
所以，這就是我們有這麼遠。

581
00:29:58,410 --> 00:30:00,960
而該列表的長度大
大於零，我們打算去

582
00:30:00,960 --> 00:30:03,220
到列表中的中間和
檢查我們的價值是存在的。

583
00:30:03,220 --> 00:30:06,970
>> 如果中間大，我們要
搜索離開，否則，如果中間是

584
00:30:06,970 --> 00:30:09,230
少，我們要搜索的權利。

585
00:30:09,230 --> 00:30:14,430
所以，我們都不得不與一些熟悉
我們在計算機科學使用條款

586
00:30:14,430 --> 00:30:15,550
和工具，我們有。

587
00:30:15,550 --> 00:30:18,300
但你已經注意到我們
講英文，但我們發現了一個

588
00:30:18,300 --> 00:30:24,790
很多事情，似乎在映射到
我們已經在我們的編碼工具包工具。

589
00:30:24,790 --> 00:30:27,210
於是馬上蝙蝠，我們不是
將實際的代碼呢。

590
00:30:27,210 --> 00:30:33,300
>> 我們看到了什麼英文在這裡，圖
上的東西，我們可以用C寫的？

591
00:30:33,300 --> 00:30:34,560
>> 學生：雖然。

592
00:30:34,560 --> 00:30:35,320
>> JASON HIRSCHHORN：雖然。

593
00:30:35,320 --> 00:30:40,610
因此，這同時就在這裡
地圖上的是什麼？

594
00:30:40,610 --> 00:30:42,630
>> 學生：一個while循環。

595
00:30:42,630 --> 00:30:43,200
>> JASON HIRSCHHORN：一個while循環？

596
00:30:43,200 --> 00:30:44,540
或可能更一般地，一個循環。

597
00:30:44,540 --> 00:30:46,260
我們想要做的事情一遍又一遍。

598
00:30:46,260 --> 00:30:49,050
所以我們要編寫一個循環。

599
00:30:49,050 --> 00:30:51,640
而我們已經知道了，因為我們已經做了
這幾次我們

600
00:30:51,640 --> 00:30:54,180
有大量的例子擺在那裡，
其實怎麼寫

601
00:30:54,180 --> 00:30:55,310
該指數為一個循環。

602
00:30:55,310 --> 00:30:56,160
所以這應該是相當容易的。

603
00:30:56,160 --> 00:30:58,070
我們應該能夠得到
啟動很快。

604
00:30:58,070 --> 00:31:01,830
>> 還有什麼我們在這裡看到了什麼？

605
00:31:01,830 --> 00:31:06,820
還有什麼其他的結構語法，事情
我們熟悉C語言，我們做

606
00:31:06,820 --> 00:31:09,790
已經有一個基於感
關閉我們所用的字眼？

607
00:31:09,790 --> 00:31:10,830
是的，安娜？

608
00:31:10,830 --> 00:31:11,360
[聽不清]

609
00:31:11,360 --> 00:31:12,990
只是在開玩笑。

610
00:31:12,990 --> 00:31:13,540
安娜，勇往直前。

611
00:31:13,540 --> 00:31:14,530
>> 學生：如果和其他人。

612
00:31:14,530 --> 00:31:16,260
>> JASON HIRSCHHORN：如果和
否則 - 就在這裡。

613
00:31:16,260 --> 00:31:18,840
那麼，做那些樣子？

614
00:31:18,840 --> 00:31:20,420
>> 學生：一個if else語句。

615
00:31:20,420 --> 00:31:21,560
>> JASON HIRSCHHORN：是啊，
條件，對不對？

616
00:31:21,560 --> 00:31:24,650
因此，我們可能會需要
寫一些條件。

617
00:31:24,650 --> 00:31:31,185
再次，雖然也許在混亂
首先，我們一般有一種感覺，現在

618
00:31:31,185 --> 00:31:34,010
如何寫條件和
語法條件。

619
00:31:34,010 --> 00:31:36,850
如果我們不這樣做，我們只是查查
語法條件下，剪切和粘貼

620
00:31:36,850 --> 00:31:39,950
如此，因為我們知道我們
在這裡需要一個條件。

621
00:31:39,950 --> 00:31:44,910
我們看到，地圖上的任何其他事情
事情，我們可能需要做C語言？

622
00:31:44,910 --> 00:31:48,312

623
00:31:48,312 --> 00:31:48,960
是啊，Aleha？

624
00:31:48,960 --> 00:31:50,370
>> 學生：這可能是顯而易見的，
通過只檢查，如果一個

625
00:31:50,370 --> 00:31:51,990
值等於什麼。

626
00:31:51,990 --> 00:31:54,578
>> JASON HIRSCHHORN：那麼我們該如何檢查
和 - 所以去到列表的中間

627
00:31:54,578 --> 00:31:55,610
並檢查我們的價值在那裡？

628
00:31:55,610 --> 00:31:56,570
我們怎麼做，在C？

629
00:31:56,570 --> 00:31:58,450
什麼是語法是什麼？

630
00:31:58,450 --> 00:31:59,235
>> 學生：等於，等於。

631
00:31:59,235 --> 00:32:00,650
>> JASON HIRSCHHORN：等於，等於。

632
00:32:00,650 --> 00:32:03,540
所以，這個檢查很可能會
是一種平等的，平等的。

633
00:32:03,540 --> 00:32:04,510
所以我們知道我們需要在某個地方。

634
00:32:04,510 --> 00:32:07,510
而實際上，只是在寫它，
我們看到其他的事情。

635
00:32:07,510 --> 00:32:11,400
我們將不得不做一些
比較操作符在那裡 - 

636
00:32:11,400 --> 00:32:12,010
太棒了。

637
00:32:12,010 --> 00:32:14,980
因此，它實際上看起來像，並通過
大，我們還沒有寫一個

638
00:32:14,980 --> 00:32:16,390
C代碼字呢。

639
00:32:16,390 --> 00:32:20,610
但我們得到的心智模式下來
通過講座和那些短褲。

640
00:32:20,610 --> 00:32:22,350
>> 我們寫的偽代碼為一組。

641
00:32:22,350 --> 00:32:27,110
而且，我們已經有80％，如果不
90％的是我們需要做的。

642
00:32:27,110 --> 00:32:28,550
現在，我們只需要編寫
它，這又是一個

643
00:32:28,550 --> 00:32:30,110
非平凡的問題要解決。

644
00:32:30,110 --> 00:32:31,890
但至少我們堅持的邏輯。

645
00:32:31,890 --> 00:32:38,040
至少現在，當我們去到上班時間，
我可以說，我知道我需要什麼

646
00:32:38,040 --> 00:32:40,160
這樣做，但你可以提醒
語法我嗎？

647
00:32:40,160 --> 00:32:42,940
或者即使上班時間都擠，你
可以為谷歌的語法，而

648
00:32:42,940 --> 00:32:45,040
不是被卡住的邏輯。

649
00:32:45,040 --> 00:32:48,570
>> 再次，而不是試圖解決
邏輯和語法問題都

650
00:32:48,570 --> 00:32:51,900
一次，它往往是要好得多
破解這兩個難題扎進

651
00:32:51,900 --> 00:32:58,280
2更易於管理的和做的
偽代碼在C中，然後再代碼

652
00:32:58,280 --> 00:33:00,620
因此，讓我們看看我做的
偽代碼的時間提前。

653
00:33:00,620 --> 00:33:04,060
>> 而該列表的長度大
大於零，看中間

654
00:33:04,060 --> 00:33:05,090
的列表。

655
00:33:05,090 --> 00:33:09,610
如果發現號返回true，否則
如果數值越高，搜索左。

656
00:33:09,610 --> 00:33:13,200
否則，如果數量少，搜索
右，返回false。

657
00:33:13,200 --> 00:33:18,710
這樣，看起來幾乎一模一樣，如果不
幾乎相同，我們寫了。

658
00:33:18,710 --> 00:33:23,030
事實上，湯姆，你先說什麼，
斷，如果在列表中，中間

659
00:33:23,030 --> 00:33:24,880
發現成兩個語句數
其實是我做了什麼。

660
00:33:24,880 --> 00:33:25,507
>> 我結合他們那裡。

661
00:33:25,507 --> 00:33:27,100
我應該聽
你的第一次。

662
00:33:27,100 --> 00:33:30,640
所以這是偽代碼，我們有。

663
00:33:30,640 --> 00:33:35,060
如果你想現在，對不起，請
回到我們最初的問題。

664
00:33:35,060 --> 00:33:37,780
讓我們的代碼binary.c。

665
00:33:37,780 --> 00:33:40,870
因此，實現一個迭代版本的
使用下面的二進制搜索

666
00:33:40,870 --> 00:33:42,420
函數聲明。

667
00:33:42,420 --> 00:33:44,550
>> 而且你也不需要複製
下來，只是還沒有。

668
00:33:44,550 --> 00:33:49,470
實際上，我要去開
右上這裡binary.c。

669
00:33:49,470 --> 00:33:52,880
因此，有函數聲明
在屏幕的中間。

670
00:33:52,880 --> 00:33:57,570
你會看到我拿著偽代碼
從我的兩側，但幾乎是相同的

671
00:33:57,570 --> 00:33:59,740
什麼，我們寫的，
把在為你。

672
00:33:59,740 --> 00:34:06,010
所以，現在，讓我們花五分鐘
編寫這個函數。

673
00:34:06,010 --> 00:34:08,199
>> 再次，如果您有任何疑問，
舉起你的手，讓我知道，我會

674
00:34:08,199 --> 00:34:08,710
來到我身邊。

675
00:34:08,710 --> 00:34:09,800
>> 學生：[聽不清]。

676
00:34:09,800 --> 00:34:12,380
>> JASON HIRSCHHORN：所以我把二進制
在定義搜索

677
00:34:12,380 --> 00:34:14,429
頂，上線12。

678
00:34:14,429 --> 00:34:16,429
這就是我為我的幻燈片。

679
00:34:16,429 --> 00:34:20,940
然後這一切的偽代碼，我只是
複製並從滑動粘貼

680
00:34:20,940 --> 00:34:22,190
偽代碼的幻燈片。

681
00:34:22,190 --> 00:35:22,830

682
00:35:22,830 --> 00:35:26,786
我仍然不聽[聽不清]。

683
00:35:26,786 --> 00:37:13,010

684
00:37:13,010 --> 00:37:15,820
>> 所以，如果你已經完成了你的
實現，我要檢查它。

685
00:37:15,820 --> 00:37:19,410
我發郵件給你的helpers.h文件
在前面這個類。

686
00:37:19,410 --> 00:37:22,360
這將是在網上以及
下載的人看

687
00:37:22,360 --> 00:37:24,750
本節的時間延遲。

688
00:37:24,750 --> 00:37:29,350
而我只是用一般的分佈
從pset3代碼。

689
00:37:29,350 --> 00:37:34,590
所以我把find.C，用我的helpers.h文件
而非helpers.h文件

690
00:37:34,590 --> 00:37:36,280
這是由於在分配碼。

691
00:37:36,280 --> 00:37:39,310
>> 我不得不做出一個其他變動
find.C而不是調用只是簡單地

692
00:37:39,310 --> 00:37:42,770
搜索，調用binary_search的。

693
00:37:42,770 --> 00:37:49,080
所以，如果你想測試你的代碼，
知道這是如何做到這一點。

694
00:37:49,080 --> 00:37:52,530
事實上，當我們將執行這個代碼
現在，我只是做副本

695
00:37:52,530 --> 00:37:59,820
我pset3目錄，再次換出
傭工文件，然後作出

696
00:37:59,820 --> 00:38:04,695
在find.C改變binary_search的調用
而不是簡單的搜索。

697
00:38:04,695 --> 00:40:08,620

698
00:40:08,620 --> 00:40:09,120
>> JASON HIRSCHHORN：是的。

699
00:40:09,120 --> 00:40:11,258
你有問題嗎？

700
00:40:11,258 --> 00:40:12,150
>> 學生：沒關係。

701
00:40:12,150 --> 00:40:12,600
>> JASON HIRSCHHORN：不用擔心。

702
00:40:12,600 --> 00:40:13,370
好吧，讓我們開始吧。

703
00:40:13,370 --> 00:40:15,090
我們將編寫此為一組。

704
00:40:15,090 --> 00:40:16,050
另外一個說明。

705
00:40:16,050 --> 00:40:20,600
再次，這是，可以很容易地進行交換
在對習題集三。

706
00:40:20,600 --> 00:40:25,530
我有我的helpers.h文件，該文件，而
比helpers.h我們給出，

707
00:40:25,530 --> 00:40:28,560
聲明二進制搜索，泡
排序和選擇排序。

708
00:40:28,560 --> 00:40:37,400
而在find.c你會發現就行，
那是什麼，第68行，我們稱之為二進制

709
00:40:37,400 --> 00:40:39,160
搜索，而不是搜索。

710
00:40:39,160 --> 00:40:42,930
所以，再一次，這是可用的代碼
在網上，或者您是代碼

711
00:40:42,930 --> 00:40:46,590
創建現在可以很容易地交換
在對p設置3進行檢查。

712
00:40:46,590 --> 00:40:50,620
>> 但首先，讓我們來編碼二進制搜索。

713
00:40:50,620 --> 00:40:53,690
我們的函數聲明，
我們返回一個布爾值。

714
00:40:53,690 --> 00:40:55,810
我們採取所謂的整數。

715
00:40:55,810 --> 00:40:59,285
我們以一個整數數組稱為
價值觀，我們取n是

716
00:40:59,285 --> 00:41:00,850
該數組的大小。

717
00:41:00,850 --> 00:41:05,640
在第10行，就在這裡，我有
犀利包括stdbool.h。

718
00:41:05,640 --> 00:41:07,360
有誰知道為什麼會在那裡？

719
00:41:07,360 --> 00:41:12,180

720
00:41:12,180 --> 00:41:16,600
那麼，這行代碼呢？

721
00:41:16,600 --> 00:41:19,880
>> 學生：它可以讓你
使用一個bool返回類型。

722
00:41:19,880 --> 00:41:20,350
>> JASON HIRSCHHORN：沒錯。

723
00:41:20,350 --> 00:41:22,300
>> 學生：或者它是一個庫，它允許
使用一個bool返回類型。

724
00:41:22,300 --> 00:41:27,590
>> JASON HIRSCHHORN：那麼尖銳包括
stdbool.h行給了我一些

725
00:41:27,590 --> 00:41:31,340
定義和聲明的東西
那我可以使用

726
00:41:31,340 --> 00:41:32,400
這個庫。

727
00:41:32,400 --> 00:41:36,570
因此，在那些被說有
這種類型被稱為布爾，並且它可以是

728
00:41:36,570 --> 00:41:37,750
真的還是假的。

729
00:41:37,750 --> 00:41:39,010
所以，這就是該行做。

730
00:41:39,010 --> 00:41:41,680
如果我沒有那行，我會
惹上麻煩寫這

731
00:41:41,680 --> 00:41:43,520
字就在這裡，布爾，在那裡。

732
00:41:43,520 --> 00:41:44,140
完全正確。

733
00:41:44,140 --> 00:41:46,430
所以我需要在這個代碼。

734
00:41:46,430 --> 00:41:47,690
確定。

735
00:41:47,690 --> 00:41:51,860
所以這再一次是一個迭代
版本，而不是遞歸1。

736
00:41:51,860 --> 00:41:53,820
因此，讓我們開始吧。

737
00:41:53,820 --> 00:41:56,200
>> 讓我們開始這第一
線的偽代碼。

738
00:41:56,200 --> 00:41:58,770
並希望，我們會 - 
或沒有希望。

739
00:41:58,770 --> 00:42:00,530
我們要繞過去了房間。

740
00:42:00,530 --> 00:42:05,110
我們會去一行一行的，我會幫助
你弄清楚，我們需要的行

741
00:42:05,110 --> 00:42:06,310
先寫。

742
00:42:06,310 --> 00:42:10,550
因此，儘管名單的長度
大於零。

743
00:42:10,550 --> 00:42:12,680
讓我們開始在前面。

744
00:42:12,680 --> 00:42:15,190
我應該寫什麼線
在這裡，在代碼中？

745
00:42:15,190 --> 00:42:19,470
>> 學生：雖然括號
n為大於0。

746
00:42:19,470 --> 00:42:21,900
>> JASON HIRSCHHORN：雖然
n是偉大大於0。

747
00:42:21,900 --> 00:42:26,550
因此n是一個列表的大小，
我們正在檢查，如果 - 

748
00:42:26,550 --> 00:42:26,800
>> [插VOICES]

749
00:42:26,800 --> 00:42:27,660
>> JASON HIRSCHHORN： - 對不起？

750
00:42:27,660 --> 00:42:29,360
>> 學生：我們如何知道
n是列表的大小？

751
00:42:29,360 --> 00:42:29,690
>> JASON HIRSCHHORN：對不起。

752
00:42:29,690 --> 00:42:34,690
每pset的規範，搜索
和排序功能，你需要寫，

753
00:42:34,690 --> 00:42:36,230
n是該列表的大小。

754
00:42:36,230 --> 00:42:37,710
我忘了解釋這一點。

755
00:42:37,710 --> 00:42:41,310
但肯定的。 n為的大小
的列表中，在這種情況下。

756
00:42:41,310 --> 00:42:44,740
所以，當n大於0。

757
00:42:44,740 --> 00:42:45,580
確定。

758
00:42:45,580 --> 00:42:50,090
這可能證明是有點問題
不過，如果事情繼續下去。

759
00:42:50,090 --> 00:42:54,510
因為我們將繼續了解
列表的大小在整個

760
00:42:54,510 --> 00:43:06,640
功能，但說我們開始
與由5個整數的數組。

761
00:43:06,640 --> 00:43:08,950
我們通過和我們已經
現在把範圍縮小到

762
00:43:08,950 --> 00:43:10,310
2個整數的數組。

763
00:43:10,310 --> 00:43:12,160
這2個整數是什麼？

764
00:43:12,160 --> 00:43:15,895
大小為2，現在我們要
看，但2是什麼？

765
00:43:15,895 --> 00:43:17,720
這是否有意義，這問題嗎？

766
00:43:17,720 --> 00:43:18,020
>> 確定。

767
00:43:18,020 --> 00:43:19,120
我會再問吧。

768
00:43:19,120 --> 00:43:26,640
因此，我們用5這個​​數組開始
整數，n等於5，對不對？

769
00:43:26,640 --> 00:43:28,050
我們將通過這裡運行。

770
00:43:28,050 --> 00:43:31,560
我們可能會改變大小，
權利，繼續發展下去。

771
00:43:31,560 --> 00:43:32,700
這就是我們說我們想做的事情。

772
00:43:32,700 --> 00:43:34,150
我們不希望搜索
完整的東西了。

773
00:43:34,150 --> 00:43:35,480
所以說，我們將其更改為2。

774
00:43:35,480 --> 00:43:36,970
我們把一半的任務列表，奇怪。

775
00:43:36,970 --> 00:43:38,800
所以，隨便挑2。

776
00:43:38,800 --> 00:43:40,590
所以，現在n等於2。

777
00:43:40,590 --> 00:43:42,780
我為窮人道歉
幹擦標記。

778
00:43:42,780 --> 00:43:43,080
對不對？

779
00:43:43,080 --> 00:43:45,670
我們正在尋找通過列表
再次用大小為2的列表。

780
00:43:45,670 --> 00:43:48,580
那麼，我們的數組的大小是5還是。

781
00:43:48,580 --> 00:43:51,920
我們說，我們只是想
搜索2點在裡面。

782
00:43:51,920 --> 00:43:53,590
因此，這2點是那些？

783
00:43:53,590 --> 00:43:57,640

784
00:43:57,640 --> 00:43:58,815
>> 這是否有道理？

785
00:43:58,815 --> 00:44:00,290
他們是左2點？

786
00:44:00,290 --> 00:44:01,940
他們是正確的2點？

787
00:44:01,940 --> 00:44:03,540
是他們中間的2點？

788
00:44:03,540 --> 00:44:06,350
我們已經分手了問題了，我們卻
居然不知道其中的一部分

789
00:44:06,350 --> 00:44:11,600
我們仍然在尋找這個問題，
只是通過讓這些2變量。

790
00:44:11,600 --> 00:44:16,450
因此，我們需要多一點的話，
而n為大於0。

791
00:44:16,450 --> 00:44:21,410
我們需要知道在哪裡
n是在我們實際的數組。

792
00:44:21,410 --> 00:44:26,660
>> 所以，沒有任何人有一個
改變這條直線？

793
00:44:26,660 --> 00:44:27,970
大多數這條線是
完全正確的。

794
00:44:27,970 --> 00:44:29,170
難道還有其他的另外？

795
00:44:29,170 --> 00:44:32,510
我們可以交換的東西出來n到
使這條線好一點？

796
00:44:32,510 --> 00:44:32,865
嗯？

797
00:44:32,865 --> 00:44:38,040
>> 學生：你能初始化變量
像長度為n的會被用來

798
00:44:38,040 --> 00:44:39,600
在後面的功能？

799
00:44:39,600 --> 00:44:42,060
>> JASON HIRSCHHORN：所以初始化
可變長度為n，

800
00:44:42,060 --> 00:44:42,900
我們使用以後呢？

801
00:44:42,900 --> 00:44:47,070
但是，我們剛剛更新的長度和我們
仍然會碰到這個問題，我們

802
00:44:47,070 --> 00:44:51,180
減少我們的問題的長度，
但我們永遠不知道，其實，

803
00:44:51,180 --> 00:44:52,510
該長度映射到。

804
00:44:52,510 --> 00:44:54,790
>> 學生：是不是要發生
以後當你說，搜索左，

805
00:44:54,790 --> 00:44:55,746
搜索吧？

806
00:44:55,746 --> 00:44:57,640
你會去一個不同的
您的區域 - 

807
00:44:57,640 --> 00:44:59,110
>> JASON HIRSCHHORN：我們打算去
一個地區，但我們怎麼知道

808
00:44:59,110 --> 00:45:01,150
這是去？

809
00:45:01,150 --> 00:45:03,800
如果我們只有數組，這
N，我們怎麼知道在哪裡

810
00:45:03,800 --> 00:45:05,050
到陣列中。

811
00:45:05,050 --> 00:45:05,900
在後面，是嗎？

812
00:45:05,900 --> 00:45:07,507
>> 學生：你有一樣，較低的
界和上界變量或

813
00:45:07,507 --> 00:45:08,586
類似的東西？

814
00:45:08,586 --> 00:45:09,060
>> JASON HIRSCHHORN：確定。

815
00:45:09,060 --> 00:45:10,780
所以這是另一種思路。

816
00:45:10,780 --> 00:45:13,490
而不是僅僅跟踪的
大小，我們保持了較低的軌道，

817
00:45:13,490 --> 00:45:14,770
上界變量。

818
00:45:14,770 --> 00:45:17,840
那麼，我們如何計算從大小
下限和上限？

819
00:45:17,840 --> 00:45:18,520
>> [插VOICES]

820
00:45:18,520 --> 00:45:19,710
>> JASON HIRSCHHORN：減法。

821
00:45:19,710 --> 00:45:23,650
並且還保持跟踪的下
綁定和上界，讓我們知道，

822
00:45:23,650 --> 00:45:26,215
我們正在尋找這兩個？

823
00:45:26,215 --> 00:45:28,220
難道我們尋找這兩個在這裡？

824
00:45:28,220 --> 00:45:29,540
我們正在尋找中間的兩個？

825
00:45:29,540 --> 00:45:32,810
也許不是中間的兩個，因為
這一點，其實是二進制搜索。

826
00:45:32,810 --> 00:45:37,320
但是，現在我們就可以得到大小，
而且該陣列的界限。

827
00:45:37,320 --> 00:45:40,020
從本質上講，如果我們有我們的巨人
電話簿，我們撕成兩半。

828
00:45:40,020 --> 00:45:42,990
我們現在知道，較小的
電話簿。

829
00:45:42,990 --> 00:45:45,260
但我們實際上並不翻錄
電話簿的一半。

830
00:45:45,260 --> 00:45:48,570
我們還需要知道在哪裡
我們的問題的新範圍是。

831
00:45:48,570 --> 00:45:51,645
沒有任何人有任何疑問，
有關？

832
00:45:51,645 --> 00:45:52,440
是嗎？

833
00:45:52,440 --> 00:45:56,020
>> 學生：它會通過創建工作
變量i，你然後就轉移

834
00:45:56,020 --> 00:46:00,770
我相對於它的位置
當前位置，並且長度中，n？

835
00:46:00,770 --> 00:46:01,710
>> JASON HIRSCHHORN：什麼是我？

836
00:46:01,710 --> 00:46:04,110
>> 學生：就像我是喜歡那種 - 

837
00:46:04,110 --> 00:46:08,040
就像你會初始化我是
陣列的中間位置。

838
00:46:08,040 --> 00:46:12,540
然後，如果在位置i的值在
在陣列的發現中間

839
00:46:12,540 --> 00:46:17,870
低於您所需要的價值，我現在
成為該陣列的長度，加上

840
00:46:17,870 --> 00:46:19,215
i的值除以2。

841
00:46:19,215 --> 00:46:20,270
像，看，你轉向我 - 

842
00:46:20,270 --> 00:46:20,770
>> JASON HIRSCHHORN：對。

843
00:46:20,770 --> 00:46:21,165
>> 學生： - 到 - 

844
00:46:21,165 --> 00:46:24,010
>> JASON HIRSCHHORN：所以我幾乎
正面，將工作。

845
00:46:24,010 --> 00:46:26,800
但問題是，你需要兩個
件的信息在這裡。

846
00:46:26,800 --> 00:46:30,050
您可以用開頭和結尾做，
或者你可以用大小做，然後

847
00:46:30,050 --> 00:46:31,060
一些標記。

848
00:46:31,060 --> 00:46:32,630
但你需要兩件
此處的信息。

849
00:46:32,630 --> 00:46:34,160
你不能用只有一個。

850
00:46:34,160 --> 00:46:35,830
這是否有道理？

851
00:46:35,830 --> 00:46:39,560
>> 所以，我們要通過，並
我們要做的[聽不清]

852
00:46:39,560 --> 00:46:41,330
並創建一些標記。

853
00:46:41,330 --> 00:46:42,690
所以，你在你的代碼寫的什麼了？

854
00:46:42,690 --> 00:46:46,190
>> 學生：我剛才說的整型界
1等於0。

855
00:46:46,190 --> 00:46:47,790
>> JASON HIRSCHHORN：讓我們把
這個int，開始。

856
00:46:47,790 --> 00:46:49,140
>> 學生：確定。

857
00:46:49,140 --> 00:46:50,590
>> JASON HIRSCHHORN：這使得
更有意義對我來說。

858
00:46:50,590 --> 00:46:51,670
和？

859
00:46:51,670 --> 00:46:54,340
>> 學生：我說，我猜，廉政結束。

860
00:46:54,340 --> 00:46:55,870
>> JASON HIRSCHHORN：INT結束。

861
00:46:55,870 --> 00:46:57,640
>> 學生：我猜，N減1，
或者類似的東西。

862
00:46:57,640 --> 00:46:59,100
像，最後一個元素。

863
00:46:59,100 --> 00:47:02,310
>> JASON HIRSCHHORN：所以你寫，詮釋
開始等於0，分號和INT

864
00:47:02,310 --> 00:47:04,320
結局等於n，減去1，分號。

865
00:47:04,320 --> 00:47:06,850
所以基本上，我們在做什麼
這裡，0的第一個位置。

866
00:47:06,850 --> 00:47:09,570
正如我們所知道的陣列，他們不走
最多n，它們上升到n減去1。

867
00:47:09,570 --> 00:47:11,110
因此，我們有我們的數組的一些界限。

868
00:47:11,110 --> 00:47:15,730
而這些初始範圍恰好是
我們的問題的初始邊界。

869
00:47:15,730 --> 00:47:16,640
確定。

870
00:47:16,640 --> 00:47:19,200
所以這聽起來不錯。

871
00:47:19,200 --> 00:47:22,380
然後，如果我們再回到這一行，而
列表的長度是大於0，

872
00:47:22,380 --> 00:47:24,752
什麼，而不是n，應
我們擺在這裡？

873
00:47:24,752 --> 00:47:28,820
>> 學生：寫結束減去開始。

874
00:47:28,820 --> 00:47:34,780
>> JASON HIRSCHHORN：雖然結束負
開始是大於0？

875
00:47:34,780 --> 00:47:35,480
確定。

876
00:47:35,480 --> 00:47:37,730
我們可以，如果我們想
做一個更好一點，有什麼

877
00:47:37,730 --> 00:47:38,980
我們還能做什麼？

878
00:47:38,980 --> 00:47:41,650

879
00:47:41,650 --> 00:47:43,412
如果我們想要清理
這段代碼了一點？

880
00:47:43,412 --> 00:47:46,716

881
00:47:46,716 --> 00:47:48,180
我們怎樣才能擺脫0？

882
00:47:48,180 --> 00:47:51,560

883
00:47:51,560 --> 00:47:52,690
這僅僅是一個風格問題。

884
00:47:52,690 --> 00:47:53,690
這是正確的現在。

885
00:47:53,690 --> 00:47:54,870
>> 學生：期末不
等於開始？

886
00:47:54,870 --> 00:47:55,740
>> JASON HIRSCHHORN：我們可以做什麼呢？

887
00:47:55,740 --> 00:47:56,730
>> [插VOICES]

888
00:47:56,730 --> 00:47:57,330
>> 學生：期末更大？

889
00:47:57,330 --> 00:47:57,720
>> JASON HIRSCHHORN：是啊。

890
00:47:57,720 --> 00:48:01,110
我們可以在剛剛結束的做
大於開始。

891
00:48:01,110 --> 00:48:03,580
右。

892
00:48:03,580 --> 00:48:06,240
我們增加了開始的另一邊
那，我們擺脫了0。

893
00:48:06,240 --> 00:48:08,000
因此，這只是看起來
點點清潔劑。

894
00:48:08,000 --> 00:48:08,990
確定。

895
00:48:08,990 --> 00:48:11,460
因此，儘管名單的長度為0，我們寫
，雖然結局是更大

896
00:48:11,460 --> 00:48:12,240
比開始。

897
00:48:12,240 --> 00:48:19,840
我們打算把我們的需要
大括號，然後第一件事

898
00:48:19,840 --> 00:48:22,090
我們想要做的是看
他們在一個小列表。

899
00:48:22,090 --> 00:48:22,510
你呢？

900
00:48:22,510 --> 00:48:23,320
你可以給我 - 

901
00:48:23,320 --> 00:48:26,460
>> 學生：如果括號
價值括號 - 

902
00:48:26,460 --> 00:48:30,450
>> JASON HIRSCHHORN：如果括號
值的方括號。

903
00:48:30,450 --> 00:48:33,210
>> 學生：結束除以2。

904
00:48:33,210 --> 00:48:33,952
>> JASON HIRSCHHORN：結束？

905
00:48:33,952 --> 00:48:35,280
>> 學生：我看到你的一個問題 - 

906
00:48:35,280 --> 00:48:35,750
>> JASON HIRSCHHORN：確定。

907
00:48:35,750 --> 00:48:39,150
好吧，看在中間。

908
00:48:39,150 --> 00:48:41,226
我們怎麼知道中間是什麼？

909
00:48:41,226 --> 00:48:42,450
是啊。

910
00:48:42,450 --> 00:48:43,070
因此，讓我刪除那些代碼。

911
00:48:43,070 --> 00:48:46,360
我們怎麼知道中間是什麼？

912
00:48:46,360 --> 00:48:48,003
在任何事情，當你有初
而最終，你怎麼找到

913
00:48:48,003 --> 00:48:48,876
中間？

914
00:48:48,876 --> 00:48:49,590
>> 學生：你平均。

915
00:48:49,590 --> 00:48:51,820
>> 學生：你將它們添加
在一起，然後 - 

916
00:48:51,820 --> 00:48:53,150
>> JASON HIRSCHHORN：加入他們
在一起，然後？

917
00:48:53,150 --> 00:48:54,090
>> 學生：你平均。

918
00:48:54,090 --> 00:48:55,050
除以2。

919
00:48:55,050 --> 00:48:56,500
>> JASON HIRSCHHORN：加入他們
在一起，除以2。

920
00:48:56,500 --> 00:48:59,400
所以整型中間等於？

921
00:48:59,400 --> 00:49:01,120
湯姆，你可以把它送給我嗎？

922
00:49:01,120 --> 00:49:03,550
>> 學生：期初加期末 - 

923
00:49:03,550 --> 00:49:04,950
>> JASON HIRSCHHORN：開始
加上結束。

924
00:49:04,950 --> 00:49:06,880
>> 學生：全部，支架，除以2。

925
00:49:06,880 --> 00:49:10,940
>> JASON HIRSCHHORN：所有在括號，
除以2。

926
00:49:10,940 --> 00:49:16,300
所以，讓我中間
任何事物，正確嗎？

927
00:49:16,300 --> 00:49:18,980
>> 學生：你還需要它向上舍入。

928
00:49:18,980 --> 00:49:19,990
>> JASON HIRSCHHORN：你這是什麼
意思是，我需要它向上舍入？

929
00:49:19,990 --> 00:49:20,400
>> [插VOICES]

930
00:49:20,400 --> 00:49:24,520
>> 學生：因為，如果這是一個奇怪的
號碼，然後它就像 - 

931
00:49:24,520 --> 00:49:25,440
>> JASON HIRSCHHORN：嗯，好吧。

932
00:49:25,440 --> 00:49:26,360
這樣我就可以把它向上舍。

933
00:49:26,360 --> 00:49:33,350
但如果它是奇數，5，我可以
服用1遠離中間。

934
00:49:33,350 --> 00:49:35,665
或者，如果它是偶數，相反，
這是一個更好的情況。

935
00:49:35,665 --> 00:49:39,600
如果是4，我們只有4，我可以帶
第一個“中間”，報價，引文或

936
00:49:39,600 --> 00:49:41,760
第二個“中間”之一。

937
00:49:41,760 --> 00:49:46,390
要么將工作二進制搜索，
所以我實際上並不需要圓形的。

938
00:49:46,390 --> 00:49:48,640
但有一件事我
需要看看這條線。

939
00:49:48,640 --> 00:49:50,530
我們可能沒有意識到這一點，
但我們會回來的。

940
00:49:50,530 --> 00:49:53,200
因為這條線實際上仍然
需要一件事。

941
00:49:53,200 --> 00:49:55,990
>> 但到目前為止，我們已經寫了
四行代碼。

942
00:49:55,990 --> 00:49:58,120
我們已經得到了我們的開始
和結束標記。

943
00:49:58,120 --> 00:50:01,320
我們有我們的while循環，它映射
對直接向我們的偽代碼。

944
00:50:01,320 --> 00:50:05,790
我們正在尋找一個映射中間
直接到我們的偽代碼。

945
00:50:05,790 --> 00:50:09,070
我會說這正好到中間
名單，這行代碼。

946
00:50:09,070 --> 00:50:11,560
然後，一旦我們去的中間
在列表中，我們需要做的下一件事

947
00:50:11,560 --> 00:50:14,880
被檢查，如果我們的價值如何，
偽代碼，我們之前寫的。

948
00:50:14,880 --> 00:50:17,100
>> 那麼我們該如何檢查，如果我們的價值
在列表的中間？

949
00:50:17,100 --> 00:50:17,300
您。

950
00:50:17,300 --> 00:50:18,511
你為什麼不這樣做呢？

951
00:50:18,511 --> 00:50:23,070
>> 學生：如果我們的價值的是
在中間是等於

952
00:50:23,070 --> 00:50:24,592
無論我們設定 - 

953
00:50:24,592 --> 00:50:26,190
我的意思是等於等於 - 

954
00:50:26,190 --> 00:50:26,690
>> JASON HIRSCHHORN：它 - 

955
00:50:26,690 --> 00:50:27,940
確定。

956
00:50:27,940 --> 00:50:30,080

957
00:50:30,080 --> 00:50:32,170
>> 學生：我不知道是什麼
變量，我們正在尋找

958
00:50:32,170 --> 00:50:32,850
因為雖然，是因為 - 

959
00:50:32,850 --> 00:50:33,330
>> [插VOICES]

960
00:50:33,330 --> 00:50:34,520
>> 學生：[聽不清]。

961
00:50:34,520 --> 00:50:35,060
>> JASON HIRSCHHORN：沒錯。

962
00:50:35,060 --> 00:50:37,260
每個函數的聲明，
我們正在尋找一個值。

963
00:50:37,260 --> 00:50:39,760
所以，我們正在尋找一個值
在值的數組。

964
00:50:39,760 --> 00:50:41,080
所以你完全正確。

965
00:50:41,080 --> 00:50:45,040
你會做，如果開放的括號值支架
中間閉合支架等號

966
00:50:45,040 --> 00:50:49,930
等於價值，裡面有
什麼我們需要做什麼？

967
00:50:49,930 --> 00:50:51,230
如果我們的價值的存在，是什麼
我們需要做什麼？

968
00:50:51,230 --> 00:50:51,420
>> [插VOICES]

969
00:50:51,420 --> 00:50:52,160
>> 學生：返回零。

970
00:50:52,160 --> 00:50:53,070
>> JASON HIRSCHHORN：返回true。

971
00:50:53,070 --> 00:50:54,790
>> 學生：返回true。

972
00:50:54,790 --> 00:50:57,856
>> JASON HIRSCHHORN：邁克爾，
這是什麼線路呢？

973
00:50:57,856 --> 00:51:01,105
>> 學生：[聽不清]程序已經運行
它的路線，那就是結束了，

974
00:51:01,105 --> 00:51:01,920
你已經什麼你需要做什麼？

975
00:51:01,920 --> 00:51:03,030
>> JASON HIRSCHHORN：程序還是什麼？

976
00:51:03,030 --> 00:51:03,700
在這種情況下？

977
00:51:03,700 --> 00:51:04,210
>> 學生：該功能。

978
00:51:04,210 --> 00:51:05,170
>> JASON HIRSCHHORN：該功能。

979
00:51:05,170 --> 00:51:08,420
因此，要返回到任何所謂的
它並給它的價值，真正的。

980
00:51:08,420 --> 00:51:09,890
完全正確。

981
00:51:09,890 --> 00:51:10,170
主。

982
00:51:10,170 --> 00:51:12,035
什麼是返回類型
主，邁克爾？

983
00:51:12,035 --> 00:51:16,480

984
00:51:16,480 --> 00:51:17,150
>> 學生：整型，整型？

985
00:51:17,150 --> 00:51:18,080
>> JASON HIRSCHHORN：整型，沒錯。

986
00:51:18,080 --> 00:51:18,680
一個整數。

987
00:51:18,680 --> 00:51:20,980
這僅僅是一個問題，以確保
你們已經在它的上面。

988
00:51:20,980 --> 00:51:24,250
這是什麼通常會返回，如果
所有的東西都運作良好？

989
00:51:24,250 --> 00:51:24,520
>> 學生：零。

990
00:51:24,520 --> 00:51:24,820
>> JASON HIRSCHHORN：零。

991
00:51:24,820 --> 00:51:25,430
完全正確。

992
00:51:25,430 --> 00:51:28,790
>> 學生：如果這只是返回true，
沒有信息報錯

993
00:51:28,790 --> 00:51:30,675
關於什麼的 - 

994
00:51:30,675 --> 00:51:34,040
呵呵，這只是說了
值的數組裡面。

995
00:51:34,040 --> 00:51:35,350
>> JASON HIRSCHHORN：沒錯。

996
00:51:35,350 --> 00:51:38,080
這個程序沒有提供資料
的確切位置值。

997
00:51:38,080 --> 00:51:41,850
它只是說，是的，我們發現
它，或者沒有，我們沒有發現它。

998
00:51:41,850 --> 00:51:42,990
所以，如果發現號，返回true。

999
00:51:42,990 --> 00:51:45,500
嗯，其實我們只是做了真正
迅速與一行代碼。

1000
00:51:45,500 --> 00:51:47,500
因此，我將動議該行偽代碼的。

1001
00:51:47,500 --> 00:51:50,045
>> 學生：不，我們需要
改變數組？

1002
00:51:50,045 --> 00:51:52,830
它應該是值，而不是價值，對不對？

1003
00:51:52,830 --> 00:51:53,430
>> JASON HIRSCHHORN：對不起。

1004
00:51:53,430 --> 00:51:54,010
謝謝。

1005
00:51:54,010 --> 00:51:54,800
>> 學生：是啊。

1006
00:51:54,800 --> 00:51:55,850
>> JASON HIRSCHHORN：此行
應該是價值觀。

1007
00:51:55,850 --> 00:51:57,150
完全正確。

1008
00:51:57,150 --> 00:51:57,920
確定。

1009
00:51:57,920 --> 00:51:59,170
因此，我們已經看了看中間列表。

1010
00:51:59,170 --> 00:52:00,790
如果發現號返回true。

1011
00:52:00,790 --> 00:52:04,470
我們的偽代碼繼續，如果
中間是更大的，搜索就走了。

1012
00:52:04,470 --> 00:52:09,640
所以，我在這裡，如果數
更高，搜索就走了。

1013
00:52:09,640 --> 00:52:12,700

1014
00:52:12,700 --> 00:52:14,462
康斯坦丁，你可以給
我這行代碼？

1015
00:52:14,462 --> 00:52:17,240

1016
00:52:17,240 --> 00:52:23,520
>> 學生：如果中間值 - 

1017
00:52:23,520 --> 00:52:24,890
>> JASON HIRSCHHORN：所以，如果值 - 

1018
00:52:24,890 --> 00:52:28,890
如果開括號值支架
中間靠近支架 - 

1019
00:52:28,890 --> 00:52:31,500
>> 學生：是不是值小？

1020
00:52:31,500 --> 00:52:32,760
>> JASON HIRSCHHORN：是小於。

1021
00:52:32,760 --> 00:52:33,800
>> 學生：比價值減。

1022
00:52:33,800 --> 00:52:34,060
>> JASON HIRSCHHORN：值。

1023
00:52:34,060 --> 00:52:35,310
嗯，其實，你要
檢查數量 - 

1024
00:52:35,310 --> 00:52:38,310

1025
00:52:38,310 --> 00:52:38,490
抱歉。

1026
00:52:38,490 --> 00:52:39,140
這是一個有點混亂。

1027
00:52:39,140 --> 00:52:43,920
但如果其他的數
名單的中間是更大的。

1028
00:52:43,920 --> 00:52:45,170
>> 學生：哦，好吧。

1029
00:52:45,170 --> 00:52:49,800

1030
00:52:49,800 --> 00:52:50,410
>> JASON HIRSCHHORN：我會改變這種狀況。

1031
00:52:50,410 --> 00:52:55,060
否則，如果中間是較高的，我們
要搜索左，好不好？

1032
00:52:55,060 --> 00:52:57,310
而我們該怎麼做內部
這一點，如果條件？

1033
00:52:57,310 --> 00:53:03,660

1034
00:53:03,660 --> 00:53:07,510
>> 學生：我可以做一個小改動
的情況下，如果將其更改為別的嗎？

1035
00:53:07,510 --> 00:53:08,380
>> JASON HIRSCHHORN：否則，如果？

1036
00:53:08,380 --> 00:53:09,270
確定。

1037
00:53:09,270 --> 00:53:12,840
所以這段代碼將執行
大致相同。

1038
00:53:12,840 --> 00:53:18,620
但是如果左右，其他使用好處
如果，否則，如果還是如果，否則，如果，否則

1039
00:53:18,620 --> 00:53:22,320
也就是說，只有其中的一個是要
進行檢查，而不是他們三個，

1040
00:53:22,320 --> 00:53:23,290
可能。

1041
00:53:23,290 --> 00:53:25,530
這使得它一點點
電腦這是上更好

1042
00:53:25,530 --> 00:53:26,670
運行你的程序。

1043
00:53:26,670 --> 00:53:27,620
>> 所以，[？康斯坦丁？]

1044
00:53:27,620 --> 00:53:31,330
我們這一行裡面，否則，如果值，
支架中間右方括號

1045
00:53:31,330 --> 00:53:32,260
大於價值。

1046
00:53:32,260 --> 00:53:33,150
什麼是我們需要做什麼？

1047
00:53:33,150 --> 00:53:33,970
我們需要搜索的左側。

1048
00:53:33,970 --> 00:53:35,220
我們該怎麼做呢？

1049
00:53:35,220 --> 00:53:46,960

1050
00:53:46,960 --> 00:53:48,720
我想給你一個開始。

1051
00:53:48,720 --> 00:53:52,210
>> 我們有這兩樣東西叫
開始和結束。

1052
00:53:52,210 --> 00:53:57,340
因此，需要做些什麼
要開始？

1053
00:53:57,340 --> 00:53:59,640
如果您要搜索的左邊
列表中，我們得到我們當前開始的。

1054
00:53:59,640 --> 00:54:01,080
我們需要什麼做的呢？

1055
00:54:01,080 --> 00:54:04,220
>> 學生：我們設置開始
到中間加1。

1056
00:54:04,220 --> 00:54:05,120
>> JASON HIRSCHHORN：所以，如果我們
尋找左側？

1057
00:54:05,120 --> 00:54:06,250
>> 學生：對不起，中間減去 - 

1058
00:54:06,250 --> 00:54:11,310
這樣的結局會是中間
減1和開始 - 

1059
00:54:11,310 --> 00:54:12,450
>> JASON HIRSCHHORN：什麼
碰巧的開始？

1060
00:54:12,450 --> 00:54:13,210
>> 學生：它保持不變。

1061
00:54:13,210 --> 00:54:14,120
>> JASON HIRSCHHORN：所以
含義保持不變。

1062
00:54:14,120 --> 00:54:16,040
如果我們在搜索的左邊，我們
使用相同的開頭 - 

1063
00:54:16,040 --> 00:54:16,860
完全正確。

1064
00:54:16,860 --> 00:54:17,870
而故事的結局？

1065
00:54:17,870 --> 00:54:19,390
對不起，什麼是
再次結束平等的嗎？

1066
00:54:19,390 --> 00:54:20,750
>> 學生：中減去1。

1067
00:54:20,750 --> 00:54:21,620
>> JASON HIRSCHHORN：中減去1。

1068
00:54:21,620 --> 00:54:23,470
現在，為什麼減1，不只是中間？

1069
00:54:23,470 --> 00:54:32,870

1070
00:54:32,870 --> 00:54:35,570
>> 學生：中間是出
圖片已經，因為我們有

1071
00:54:35,570 --> 00:54:36,700
檢查它的呢？

1072
00:54:36,700 --> 00:54:37,630
>> JASON HIRSCHHORN：這是
完全正確。

1073
00:54:37,630 --> 00:54:38,580
中間是出來的圖片。

1074
00:54:38,580 --> 00:54:39,800
我們已經檢查了中間。

1075
00:54:39,800 --> 00:54:44,730
所以，我們不希望“中間，”報價
引文結束後，繼續在該

1076
00:54:44,730 --> 00:54:46,110
數組，我們正在尋找。

1077
00:54:46,110 --> 00:54:47,670
因此，這是夢幻般的。

1078
00:54:47,670 --> 00:54:50,670
>> 否則，如果值支架中間是更大
比值等於結束

1079
00:54:50,670 --> 00:54:51,920
中間減1。

1080
00:54:51,920 --> 00:54:55,060

1081
00:54:55,060 --> 00:54:57,340
傑夫，你看這個最後一行？

1082
00:54:57,340 --> 00:54:58,590
>> 學生：否則。

1083
00:54:58,590 --> 00:55:02,486

1084
00:55:02,486 --> 00:55:06,000
中間值小於值？

1085
00:55:06,000 --> 00:55:07,570
>> JASON HIRSCHHORN：我們會
你給我的東西。

1086
00:55:07,570 --> 00:55:09,310
所以，如果你不給我 - 

1087
00:55:09,310 --> 00:55:12,270
>> 學生：所以後來開始
將中間加1。

1088
00:55:12,270 --> 00:55:16,100

1089
00:55:16,100 --> 00:55:19,070
>> JASON HIRSCHHORN：平等開始
中間加1，再一次，對於相同的

1090
00:55:19,070 --> 00:55:20,820
原因是君士坦丁
給了我們前面。

1091
00:55:20,820 --> 00:55:24,280
並在最後，誰沒有給
我的代碼行了嗎？

1092
00:55:24,280 --> 00:55:26,600
返回false，Aleha什麼
我們寫在這裡？

1093
00:55:26,600 --> 00:55:28,590
>> 學生：返回false。

1094
00:55:28,590 --> 00:55:29,320
>> JASON HIRSCHHORN：返回false。

1095
00:55:29,320 --> 00:55:33,340
而我們需要做的，因為如果我們
並不覺得，我們需要說我們

1096
00:55:33,340 --> 00:55:34,080
沒有發現它。

1097
00:55:34,080 --> 00:55:36,270
和我們說我們要返回一個
布爾，所以我們肯定是要返回

1098
00:55:36,270 --> 00:55:38,150
一個bool地方。

1099
00:55:38,150 --> 00:55:42,590
>> 因此，讓我們運行此代碼。

1100
00:55:42,590 --> 00:55:44,520
實際上，我要 - 

1101
00:55:44,520 --> 00:55:45,930
所以我們在終端。

1102
00:55:45,930 --> 00:55:47,230
我們將清除我們的窗口。

1103
00:55:47,230 --> 00:55:49,270
讓我們把所有的。

1104
00:55:49,270 --> 00:55:50,340
我們發現有一個錯誤。

1105
00:55:50,340 --> 00:55:54,280
還有第15行錯誤，預期
分號的結束

1106
00:55:54,280 --> 00:55:54,890
聲明。

1107
00:55:54,890 --> 00:55:56,454
所以，我怎麼忘了？

1108
00:55:56,454 --> 00:55:57,230
>> 學生：分號。

1109
00:55:57,230 --> 00:56:00,200
>> JASON HIRSCHHORN：分號
直到這裡。

1110
00:56:00,200 --> 00:56:00,950
我認為這是湯姆的代碼。

1111
00:56:00,950 --> 00:56:01,870
因此，湯姆，[聽不清]。

1112
00:56:01,870 --> 00:56:03,120
只是在開玩笑。

1113
00:56:03,120 --> 00:56:05,010

1114
00:56:05,010 --> 00:56:07,310
讓我們做所有的再製作。

1115
00:56:07,310 --> 00:56:10,180
>> 學生：什麼Dropbox的目錄
我們應該在這？

1116
00:56:10,180 --> 00:56:11,345
>> JASON HIRSCHHORN：所以，你可以
只是看這一點。

1117
00:56:11,345 --> 00:56:16,380
但同樣，如果你​​想提出這個
代碼到您的pset3目錄試試

1118
00:56:16,380 --> 00:56:17,050
出來，這就是我所做的。

1119
00:56:17,050 --> 00:56:18,600
如果你會發現在這裡 - 
對不起，很好的問題。

1120
00:56:18,600 --> 00:56:19,460
>> [？ LS，？]

1121
00:56:19,460 --> 00:56:24,700
我在這裡find.c代碼
從本週的發行版的代碼。

1122
00:56:24,700 --> 00:56:26,300
我有helpers.h。

1123
00:56:26,300 --> 00:56:30,010
我有一個Make文件我實際上是
編輯了一下，包括這些新

1124
00:56:30,010 --> 00:56:30,710
我們正在編寫的文件。

1125
00:56:30,710 --> 00:56:34,120
所有這些代碼將是可用的，不
分配的代碼，但新

1126
00:56:34,120 --> 00:56:39,510
製作文件，新helpers.h文件將
是下載在網上提供。

1127
00:56:39,510 --> 00:56:41,800
同樣地，所以這些都是在
額外的代碼，我們有。

1128
00:56:41,800 --> 00:56:46,130
>> 因此，請所有，每本線，使得查找，
二，泡選擇 - 品牌

1129
00:56:46,130 --> 00:56:50,930
他們三個都和編譯成
這個可執行文件代碼中找到。

1130
00:56:50,930 --> 00:56:54,090
所以一般情況下，我們不希望
直到check50。

1131
00:56:54,090 --> 00:56:57,580
我們要對我們自己運行一些測試。

1132
00:56:57,580 --> 00:57:11,750
但是，僅僅如此可加快我們這一點，
check50 2013 pset3.find將通過

1133
00:57:11,750 --> 00:57:14,630
在helpers.c- - 我的壞。

1134
00:57:14,630 --> 00:57:16,050
>> 我沒有說現在。

1135
00:57:16,050 --> 00:57:20,670
因此，我們實際上是要
運行實際的代碼。

1136
00:57:20,670 --> 00:57:23,570
Usage.find /，你知道這意味著什麼？

1137
00:57:23,570 --> 00:57:25,970
>> 學生：你需要第二個
在它的命令行。

1138
00:57:25,970 --> 00:57:26,980
>> JASON HIRSCHHORN：我需要
第二個命令行。

1139
00:57:26,980 --> 00:57:30,640
並根據規範要求，我需要
進入我們正在尋找的東西。

1140
00:57:30,640 --> 00:57:33,750
因此，讓我們來看看42。

1141
00:57:33,750 --> 00:57:37,030
我們將保持它在排序的，因為我們
沒有寫一個排序功能，但 - 

1142
00:57:37,030 --> 00:57:41,830
42，43，44。

1143
00:57:41,830 --> 00:57:46,240
>> 和控制D沒找到
大海撈針。

1144
00:57:46,240 --> 00:57:46,505
這是不好的。

1145
00:57:46,505 --> 00:57:47,200
這是肯定有的。

1146
00:57:47,200 --> 00:57:48,090
讓我們試試別的。

1147
00:57:48,090 --> 00:57:49,860
也許這是因為我把
但在開頭。

1148
00:57:49,860 --> 00:57:54,490
>> 讓我們做41，42，43。

1149
00:57:54,490 --> 00:57:55,012
我們走吧。

1150
00:57:55,012 --> 00:57:56,400
它發現了它。

1151
00:57:56,400 --> 00:58:00,040
讓我們把它在結束現在，只
所以我們可以徹底的 - 

1152
00:58:00,040 --> 00:58:03,580
40，41，42。

1153
00:58:03,580 --> 00:58:05,760
沒有找到針頭。

1154
00:58:05,760 --> 00:58:07,550
所以我提到這點。

1155
00:58:07,550 --> 00:58:08,980
不幸的是，我知道這
將要發生。

1156
00:58:08,980 --> 00:58:11,490
>> 但用於教學目的，
這是很好的探索它。

1157
00:58:11,490 --> 00:58:12,990
這是行不通的。

1158
00:58:12,990 --> 00:58:16,020
出於某種原因，它無法找到它。

1159
00:58:16,020 --> 00:58:18,970
我們知道什麼是在那裡，但
我們目前還沒有找到它。

1160
00:58:18,970 --> 00:58:24,140
所以，有一件事我們可以做的是通過
GDB找到它，但確實有人，

1161
00:58:24,140 --> 00:58:27,850
無需通過GDB，有
在哪裡，我們搞砸了有意義嗎？

1162
00:58:27,850 --> 00:58:28,480
[？摩杜？ ？]

1163
00:58:28,480 --> 00:58:30,960
>> 學生：我想可能是結束的時候
等於開頭，它的

1164
00:58:30,960 --> 00:58:33,090
只是一個元素的列表。

1165
00:58:33,090 --> 00:58:35,560
然後，它只是忽略它，而不是
實際檢查它。

1166
00:58:35,560 --> 00:58:36,940
>> JASON HIRSCHHORN：這是
完全正確。

1167
00:58:36,940 --> 00:58:41,110
當結束等於開始，我們做
還有在我們的列表中的元素？

1168
00:58:41,110 --> 00:58:42,480
>> 學生：是的。

1169
00:58:42,480 --> 00:58:45,450
>> JASON HIRSCHHORN：是的，事實上，我們
有一個且僅有一個元件。

1170
00:58:45,450 --> 00:58:50,500
而這將極有可能發生時，
每次我們測試過的代碼，我們在

1171
00:58:50,500 --> 00:58:54,640
幹草堆或櫃檯
幹草堆的結束。

1172
00:58:54,640 --> 00:58:56,000
這就是開始和
結局是要等於

1173
00:58:56,000 --> 00:58:57,820
之一，二分查找。

1174
00:58:57,820 --> 00:59:01,440
因此，在這兩個情況下，沒有工作，
因為結束等於開始。

1175
00:59:01,440 --> 00:59:06,030
>> 但是，如果結束等於開始，
這是否while循環執行？

1176
00:59:06,030 --> 00:59:06,390
它沒有。

1177
00:59:06,390 --> 00:59:08,660
而且我們也可以檢查
這再通過GDB。

1178
00:59:08,660 --> 00:59:14,000
那麼，如何才能解決這個問題的代碼，因為
當結束時等於

1179
00:59:14,000 --> 00:59:16,070
開始，我們也希望這
while循環運行。

1180
00:59:16,070 --> 00:59:18,620
>> 因此，我們可以做什麼修復到第18行？

1181
00:59:18,620 --> 00:59:21,060
>> 學生：[聽不清]大
小於或等於。

1182
00:59:21,060 --> 00:59:21,700
>> JASON HIRSCHHORN：完全正確。

1183
00:59:21,700 --> 00:59:24,600
雖然結局是大於
或等於開始。

1184
00:59:24,600 --> 00:59:27,300
所以，現在，我們一定要得到那
角落的情況在年底。

1185
00:59:27,300 --> 00:59:27,870
讓我們來看看。

1186
00:59:27,870 --> 00:59:29,560
讓我們運行此一次。

1187
00:59:29,560 --> 00:59:31,266
>> 讓我們所有。

1188
00:59:31,266 --> 00:59:33,910
同樣，你必須只
跟著在這裡。

1189
00:59:33,910 --> 00:59:36,280
找到41這個時間。

1190
00:59:36,280 --> 00:59:37,360
只要保持一致。

1191
00:59:37,360 --> 00:59:38,210
>> 找到42。

1192
00:59:38,210 --> 00:59:38,930
讓我們把它在開始 - 

1193
00:59:38,930 --> 00:59:41,630
42，43，44。

1194
00:59:41,630 --> 00:59:42,860
我們發現了它。

1195
00:59:42,860 --> 00:59:47,710
所以這的確是變化
我們需要做。

1196
00:59:47,710 --> 00:59:51,090
>> 這是一個很大的編碼，我們的
只是做了，二進制搜索。

1197
00:59:51,090 --> 00:59:55,760
沒有任何人有之前的任何問題
我謹對為我們寫了線

1198
00:59:55,760 --> 00:59:58,750
二進制搜索或者我們怎麼想通
什麼我們沒有搞清楚？

1199
00:59:58,750 --> 01:00:01,900

1200
01:00:01,900 --> 01:00:06,270
在我們繼續之前，我也想點
指出，總的來說，我們映射

1201
01:00:06,270 --> 01:00:09,300
我們的偽代碼之一
1到我們的代碼。

1202
01:00:09,300 --> 01:00:11,550
>> 我們確實有一個棘手的事情
找出與

1203
01:00:11,550 --> 01:00:12,890
開始和結束。

1204
01:00:12,890 --> 01:00:17,380
但你有沒有計算過了，你
會寫相當多的

1205
01:00:17,380 --> 01:00:20,740
相同的代碼，保存為
那些最上面兩行。

1206
01:00:20,740 --> 01:00:23,380
然後你會意識到，當
您在檢查和案件有否規定

1207
01:00:23,380 --> 01:00:24,840
你需要別的東西。

1208
01:00:24,840 --> 01:00:28,510
所以，即使你曾跟隨我們
偽代碼行來行，你就已經

1209
01:00:28,510 --> 01:00:31,130
得到了所有，但兩行
你需要編寫代碼。

1210
01:00:31,130 --> 01:00:33,900
>> 而我願意打賭，你們
本來都想通了這一點

1211
01:00:33,900 --> 01:00:37,940
很快，你需要把
某種標誌物在有圖

1212
01:00:37,940 --> 01:00:39,190
出你在哪裡。

1213
01:00:39,190 --> 01:00:41,540

1214
01:00:41,540 --> 01:00:44,550
這又是幹什麼的力量
偽代碼的時間提前。

1215
01:00:44,550 --> 01:00:47,310
所以我們可以做的邏輯，然後再
大家可以放心使用的語法。

1216
01:00:47,310 --> 01:00:51,470
>> 如果我們一直感到困惑的邏輯
而試圖寫這段代碼在C中，

1217
01:00:51,470 --> 01:00:53,110
我們會得到全亂了。

1218
01:00:53,110 --> 01:00:56,340
然後我們就可以問的問題
邏輯和語法和網格

1219
01:00:56,340 --> 01:00:57,320
它們放在一起。

1220
01:00:57,320 --> 01:01:02,170
我們會得到丟失
在哪可以迅速成為一個

1221
01:01:02,170 --> 01:01:04,000
非常棘手的問題。

1222
01:01:04,000 --> 01:01:08,680
現在讓我們繼續前進
要選擇排序。

1223
01:01:08,680 --> 01:01:10,760
>> 我們還剩下20分鐘。

1224
01:01:10,760 --> 01:01:14,130
所以，我有，我們將不能夠感覺
通過所有選擇排序的獲得

1225
01:01:14,130 --> 01:01:15,940
和冒泡排序。

1226
01:01:15,940 --> 01:01:20,670
但是，讓我們至少嘗試
完成選擇排序。

1227
01:01:20,670 --> 01:01:23,540
因此，實現選擇排序使用
下面的函數聲明。

1228
01:01:23,540 --> 01:01:27,530
>> 再次，這是從
問題設置規範。

1229
01:01:27,530 --> 01:01:31,560
int值是括號，是
整數數組。

1230
01:01:31,560 --> 01:01:33,490
和int.n是該數組的大小。

1231
01:01:33,490 --> 01:01:36,840
選擇排序是怎麼回事
這個數組進行排序。

1232
01:01:36,840 --> 01:01:43,580
>> 因此，根據我們的心智選擇的模型
排序，我們拉 - 

1233
01:01:43,580 --> 01:01:47,720
首先，我們通過列表中的第一
時間，找到最小的數字，

1234
01:01:47,720 --> 01:01:52,860
把它放在開頭，找到第二
最小的數字，把它放在

1235
01:01:52,860 --> 01:01:56,380
如果我們要第二位置
排序按升序排序。

1236
01:01:56,380 --> 01:01:58,440
我不會強迫你寫
偽代碼現在。

1237
01:01:58,440 --> 01:02:01,350
>> 但在此之前我們做的代碼作為一個階級的
五分鐘，我們將寫

1238
01:02:01,350 --> 01:02:03,550
偽代碼，所以我們有一些感
的我們要去的地方。

1239
01:02:03,550 --> 01:02:05,630
因此，嘗試寫偽代碼
在你自己的。

1240
01:02:05,630 --> 01:02:08,610
然後再嘗試打開該
偽代碼轉換成代碼。

1241
01:02:08,610 --> 01:02:10,740
我們將做到這一點作為一個群體
在五分鐘內。

1242
01:02:10,740 --> 01:02:32,560

1243
01:02:32,560 --> 01:02:33,895
>> 當然，讓我知道，如果
您有任何問題。

1244
01:02:33,895 --> 01:03:56,738

1245
01:03:56,738 --> 01:03:58,230
>> 學生：那呢？

1246
01:03:58,230 --> 01:04:00,280
>> JASON HIRSCHHORN：看看有多少你
可以在兩分鐘搞定。

1247
01:04:00,280 --> 01:04:01,790
我知道你不會
能夠完成。

1248
01:04:01,790 --> 01:04:03,050
但我們將在此為一組。

1249
01:04:03,050 --> 01:04:57,830

1250
01:04:57,830 --> 01:05:00,630
>> 你所有的編碼等等[聽不清]，所以我
對不起暫停自己在做什麼。

1251
01:05:00,630 --> 01:05:02,530
但是，讓我們通過這作為一個群體。

1252
01:05:02,530 --> 01:05:07,590
再次，二分查找，大家給
我一個，如果沒有更多行的代碼。

1253
01:05:07,590 --> 01:05:08,530
謝謝你的。

1254
01:05:08,530 --> 01:05:11,730
我們打算做同樣的事情
這裡，作為一組一起碼。

1255
01:05:11,730 --> 01:05:15,170
>> 所以，選擇排序 - 讓我們寫
一些快速的偽代碼。

1256
01:05:15,170 --> 01:05:20,380
每心智模式，可以有人給我
第一線的偽代碼，好嗎？

1257
01:05:20,380 --> 01:05:23,000

1258
01:05:23,000 --> 01:05:24,270
我想要什麼做的？

1259
01:05:24,270 --> 01:05:27,070
>> 學生：雖然名單
出了毛病。

1260
01:05:27,070 --> 01:05:30,630
>> JASON HIRSCHHORN：OK，而
該列表是不合乎規程。

1261
01:05:30,630 --> 01:05:33,540
和你是什麼意思“壞了？”

1262
01:05:33,540 --> 01:05:34,960
>> 學生：在[聽不清]

1263
01:05:34,960 --> 01:05:36,210
沒有被排序。

1264
01:05:36,210 --> 01:05:38,460

1265
01:05:38,460 --> 01:05:40,290
>> JASON HIRSCHHORN：雖然名單
出了毛病，我們該怎麼辦？

1266
01:05:40,290 --> 01:05:44,200
給我的第二行，
請，馬庫斯。

1267
01:05:44,200 --> 01:05:47,186
>> 學生：所以找到下一個
最小的數字。

1268
01:05:47,186 --> 01:05:49,000
這將縮進。

1269
01:05:49,000 --> 01:05:55,140
>> JASON HIRSCHHORN：所以找到
下一個最小的數。

1270
01:05:55,140 --> 01:05:56,460
然後別人？

1271
01:05:56,460 --> 01:06:01,030
一旦我們找到下一個最小的
數，我們該怎麼做？

1272
01:06:01,030 --> 01:06:03,010
我要說找
的最小數量。

1273
01:06:03,010 --> 01:06:04,820
這就是我們想要做的。

1274
01:06:04,820 --> 01:06:06,210
>> 因此，找到最小的數字。

1275
01:06:06,210 --> 01:06:08,061
那麼我們該怎麼做？

1276
01:06:08,061 --> 01:06:09,480
>> 學生：[聽不清]為開端。

1277
01:06:09,480 --> 01:06:10,680
>> JASON HIRSCHHORN：對不起？

1278
01:06:10,680 --> 01:06:12,700
>> 學生：在將其放置
開始列表。

1279
01:06:12,700 --> 01:06:18,540
>> JASON HIRSCHHORN：所以把它放在
在列表的開頭。

1280
01:06:18,540 --> 01:06:20,140
而我們做的事情是什麼
這是在開始

1281
01:06:20,140 --> 01:06:20,830
列表中的，對不對？

1282
01:06:20,830 --> 01:06:21,910
我們覆蓋的東西。

1283
01:06:21,910 --> 01:06:23,130
那麼，我們把那？

1284
01:06:23,130 --> 01:06:24,120
是啊，安娜？

1285
01:06:24,120 --> 01:06:25,520
>> 學生：其中最小
數字是？

1286
01:06:25,520 --> 01:06:32,530
>> JASON赫希洪：所以把開始
列表中的其中

1287
01:06:32,530 --> 01:06:35,180
最小的數字了。

1288
01:06:35,180 --> 01:06:38,510
因此，儘管名單已經出來的順序，找到
最小的數字，將其放置在

1289
01:06:38,510 --> 01:06:40,630
該列表的開頭，把
開始列表的其中

1290
01:06:40,630 --> 01:06:42,900
最小的數字了。

1291
01:06:42,900 --> 01:06:45,780
馬庫斯，你可以整理這條線
而名單已經出來了的秩序？

1292
01:06:45,780 --> 01:06:51,160

1293
01:06:51,160 --> 01:06:53,900
>> 學生：雖然數字
未分類的？

1294
01:06:53,900 --> 01:06:55,920
>> JASON赫希洪：OK，所以為了
知道這些數字都沒有

1295
01:06:55,920 --> 01:06:58,670
排序的，什麼是我們需要做什麼？

1296
01:06:58,670 --> 01:07:00,640
有多少，我們需要
通過這個名單？

1297
01:07:00,640 --> 01:07:09,650
>> 學生：所以我想一個for循環，或
同時，在檢查數量較少

1298
01:07:09,650 --> 01:07:11,900
比列表的長度是多少？

1299
01:07:11,900 --> 01:07:13,160
>> JASON赫希洪：好，這是很好的。

1300
01:07:13,160 --> 01:07:15,000
我想我misphrased
我的問題知之甚少。

1301
01:07:15,000 --> 01:07:15,990
我只是試圖讓在
我們將不得不去

1302
01:07:15,990 --> 01:07:17,580
在整個列表。

1303
01:07:17,580 --> 01:07:20,490
因此，儘管名單已經出來的順序，
對我來說，是很難地圖。

1304
01:07:20,490 --> 01:07:24,940
但基本上，這就是如何
我想這個問題。

1305
01:07:24,940 --> 01:07:28,880
通過整個列表中，找到
最小數，將其放置在

1306
01:07:28,880 --> 01:07:30,130
開始 - 其實，你說得對。

1307
01:07:30,130 --> 01:07:31,380
讓我們把他們兩個。

1308
01:07:31,380 --> 01:07:33,470

1309
01:07:33,470 --> 01:07:39,050
>> 因此，儘管名單已經出來了的訂單，我們
需要經過整個列表

1310
01:07:39,050 --> 01:07:42,250
一次，找到最小的數字，地點
它在列表的開頭，把

1311
01:07:42,250 --> 01:07:45,430
在列表的開頭，其中
最小數目是，然後，如果

1312
01:07:45,430 --> 01:07:47,460
列表仍然失靈，我們已經
得去通過這個

1313
01:07:47,460 --> 01:07:48,620
進程再次，對不對？

1314
01:07:48,620 --> 01:07:51,610
這就是為什麼選擇排序，大O運行
選擇排序的，任何人嗎？

1315
01:07:51,610 --> 01:07:52,830
>> 學生：無平方。

1316
01:07:52,830 --> 01:07:53,590
>> JASON赫希洪：無平方。

1317
01:07:53,590 --> 01:07:57,040
因為像馬庫斯，我才意識到
在這裡，我們將不得不

1318
01:07:57,040 --> 01:08:00,310
通過列表名單
的次數。

1319
01:08:00,310 --> 01:08:03,420
所以，經歷的事
長度為n的n次號

1320
01:08:03,420 --> 01:08:04,990
其實是在Ñ平方。

1321
01:08:04,990 --> 01:08:08,100
>> 所以這是我們的偽代碼。

1322
01:08:08,100 --> 01:08:09,360
這看起來很不錯。

1323
01:08:09,360 --> 01:08:11,870
沒有任何人有任何疑問，
關於偽？

1324
01:08:11,870 --> 01:08:14,440
因為實際上選擇排序應該
大概要一對一，代碼

1325
01:08:14,440 --> 01:08:14,980
偽代碼。

1326
01:08:14,980 --> 01:08:17,569
因此，任何有關問題
偽代碼的邏輯是什麼？

1327
01:08:17,569 --> 01:08:18,819
現在請提問。

1328
01:08:18,819 --> 01:08:22,609

1329
01:08:22,609 --> 01:08:25,379
>> 選擇排序 - 而名單已經出來了
的順序，我們將通過它

1330
01:08:25,379 --> 01:08:27,529
並找出最小的每次
並把它放在前面。

1331
01:08:27,529 --> 01:08:33,470
因此，儘管名單已經出來了，可以順序
有人給我說行代碼誰

1332
01:08:33,470 --> 01:08:39,689
還沒有給我行
然而，代碼好嗎？

1333
01:08:39,689 --> 01:08:40,939
這聽起來像一個什麼？

1334
01:08:40,939 --> 01:08:43,669

1335
01:08:43,669 --> 01:08:44,649
>> 學生：這是一個for循環。

1336
01:08:44,649 --> 01:08:45,830
>> JASON赫希洪：聽起來
喜歡一個for循環。

1337
01:08:45,830 --> 01:08:47,653
OK，你可以給我的for循環？

1338
01:08:47,653 --> 01:08:48,925
對於 - 

1339
01:08:48,925 --> 01:08:50,219
>> 學生：我等於0。

1340
01:08:50,219 --> 01:08:52,705
>> JASON赫希洪：我還是 - 

1341
01:08:52,705 --> 01:08:55,111
什麼是我們缺少什麼？

1342
01:08:55,111 --> 01:08:56,819
善有善報就在這裡？

1343
01:08:56,819 --> 01:08:57,550
>> 學生：詮釋。

1344
01:08:57,550 --> 01:08:59,270
>> JASON赫希洪：沒錯。

1345
01:08:59,270 --> 01:09:02,590
（INT I = 0;  - 

1346
01:09:02,590 --> 01:09:07,843
>> 學生：我<N; i + +）。

1347
01:09:07,843 --> 01:09:09,319
>> JASON赫希洪：釘它，傑夫。

1348
01:09:09,319 --> 01:09:10,660
我們正在經歷的列表中，右鍵？

1349
01:09:10,660 --> 01:09:11,880
我們以前見過的代碼。

1350
01:09:11,880 --> 01:09:12,850
完美的。

1351
01:09:12,850 --> 01:09:14,790
所以，讓我們把我們的大括號在這裡。

1352
01:09:14,790 --> 01:09:17,859
我打算把一些
大括號在這裡。

1353
01:09:17,859 --> 01:09:21,660
>> 因此，儘管它是0，我們需要去
整個列表。

1354
01:09:21,660 --> 01:09:26,612
所以每次我們去通過列表，
什麼我們想跟踪的？

1355
01:09:26,612 --> 01:09:28,260
>> 學生：如果有任何掉期進行。

1356
01:09:28,260 --> 01:09:29,069
>> JASON赫希洪：查找
的最小數量。

1357
01:09:29,069 --> 01:09:31,479
因此，我們或許應該跟踪
最小的數字各一次。

1358
01:09:31,479 --> 01:09:34,590
所以，行，我可以做些什麼來保持跟踪
最小是多少？

1359
01:09:34,590 --> 01:09:37,720
Aleha，我怎麼能保持
軌道的東西？

1360
01:09:37,720 --> 01:09:38,460
>> 學生：開始一個新的變量。

1361
01:09:38,460 --> 01:09:39,390
>> JASON赫希洪：開始一個新的變量。

1362
01:09:39,390 --> 01:09:40,069
因此，讓我們創建一個變量。

1363
01:09:40,069 --> 01:09:41,830
什麼類型的？

1364
01:09:41,830 --> 01:09:42,930
>> 學生：詮釋。

1365
01:09:42,930 --> 01:09:43,710
>> JASON赫希洪：詮釋。

1366
01:09:43,710 --> 01:09:44,939
讓我們把它稱為最小的。

1367
01:09:44,939 --> 01:09:47,600
以及它等於什麼時候
我們剛剛起步的？

1368
01:09:47,600 --> 01:09:48,910
我們並沒有在列表中消失了呢。

1369
01:09:48,910 --> 01:09:50,540
我們在的第一部分
通過列出我們的第一次。

1370
01:09:50,540 --> 01:09:51,930
什麼是平等的，
最小的數字？

1371
01:09:51,930 --> 01:09:54,140
>> 學生：我的值。

1372
01:09:54,140 --> 01:09:54,900
>> JASON赫希洪：值I。

1373
01:09:54,900 --> 01:09:56,980
這聽起來完全正確的，對不對？

1374
01:09:56,980 --> 01:09:59,590
最小數目的開頭
就是我們在哪裡。

1375
01:09:59,590 --> 01:10:01,960
所以現在我們有我們最小的，我們需要
要經過整個列表和

1376
01:10:01,960 --> 01:10:05,080
比較這最小的
到一切。

1377
01:10:05,080 --> 01:10:08,150
那麼，我們通過清單了嗎？

1378
01:10:08,150 --> 01:10:08,630
邁克爾？

1379
01:10:08,630 --> 01:10:10,000
>> 學生：你需要做
另一個循環。

1380
01:10:10,000 --> 01:10:10,383
>> JASON赫希洪：另一個for循環。

1381
01:10:10,383 --> 01:10:11,276
讓我們開始吧。

1382
01:10:11,276 --> 01:10:12,540
給我一些代碼。

1383
01:10:12,540 --> 01:10:13,790
>> 學生：For循環 - 

1384
01:10:13,790 --> 01:10:16,750

1385
01:10:16,750 --> 01:10:19,470
為最小 - 

1386
01:10:19,470 --> 01:10:23,040

1387
01:10:23,040 --> 01:10:25,770
只是詮釋J，你可以說？

1388
01:10:25,770 --> 01:10:31,150
= 0;使得 - 

1389
01:10:31,150 --> 01:10:34,014

1390
01:10:34,014 --> 01:10:35,710
>> JASON赫希洪：嗯，如果我們想
要經過整個列表 - 

1391
01:10:35,710 --> 01:10:37,847
>> 學生：百靈<N，J + +）。

1392
01:10:37,847 --> 01:10:42,140

1393
01:10:42,140 --> 01:10:42,405
>> JASON赫希洪：神奇。

1394
01:10:42,405 --> 01:10:46,100
我們將通過
for循環一次。

1395
01:10:46,100 --> 01:10:51,380
我們如何找到
最小的數字？

1396
01:10:51,380 --> 01:10:52,630
湯姆？

1397
01:10:52,630 --> 01:10:54,570

1398
01:10:54,570 --> 01:11:00,520
我們目前最小的數字，
那麼如何才能找到新的最小？

1399
01:11:00,520 --> 01:11:07,200
>> 學生：我們可以檢查最小
我們也數大於

1400
01:11:07,200 --> 01:11:09,040
重視支架Ĵ。

1401
01:11:09,040 --> 01:11:14,740
>> JASON赫希洪：所以，如果最小的是
比數值支架Ĵ更大。

1402
01:11:14,740 --> 01:11:19,350
因此，如果我們目前最小的
大於 - 

1403
01:11:19,350 --> 01:11:21,770
我要在這兩個線
對於第二個在那裡的代碼。

1404
01:11:21,770 --> 01:11:26,010
因為之前我們做任何交換，我們
需要經過整個列表。

1405
01:11:26,010 --> 01:11:28,880
所以這個偽代碼實際上應該
在外面的內循環。

1406
01:11:28,880 --> 01:11:30,390
這樣下去整個列表。

1407
01:11:30,390 --> 01:11:34,520
如果最小的大於
值Ĵ然後呢？

1408
01:11:34,520 --> 01:11:37,830
>> 學生：那最小的
等於值Ĵ。

1409
01:11:37,830 --> 01:11:41,190

1410
01:11:41,190 --> 01:11:42,600
>> JASON赫希洪：神奇。

1411
01:11:42,600 --> 01:11:44,580
一個簡單的問題 - 

1412
01:11:44,580 --> 01:11:47,236
我們第一次去通過這個循環，
我是怎麼回事等於0，J是怎麼回事

1413
01:11:47,236 --> 01:11:50,710
等於0，一旦我們在這裡得到的。

1414
01:11:50,710 --> 01:11:52,410
所以，我們要進行比較
一個數字本身。

1415
01:11:52,410 --> 01:11:53,660
是有效的？

1416
01:11:53,660 --> 01:11:57,260

1417
01:11:57,260 --> 01:11:58,390
不，這不是真的有效。

1418
01:11:58,390 --> 01:12:02,915
因此，沒有我們的Ĵ需要去
從0到n每次？

1419
01:12:02,915 --> 01:12:06,310
我們總是需要檢查
整個列表？

1420
01:12:06,310 --> 01:12:06,520
[聽不清]？

1421
01:12:06,520 --> 01:12:07,564
>> 學生：開始我代替。

1422
01:12:07,564 --> 01:12:09,405
>> JASON赫希洪：j的
先從什麼？

1423
01:12:09,405 --> 01:12:09,990
>> 學生：我。

1424
01:12:09,990 --> 01:12:13,040
>> JASON赫希洪：j的與我開始。

1425
01:12:13,040 --> 01:12:18,840
所以，現在我們開始比較
有一個我們的。

1426
01:12:18,840 --> 01:12:21,020
但即便如此，是因為
盡可能高效？

1427
01:12:21,020 --> 01:12:22,320
>> 學生：我+ 1。

1428
01:12:22,320 --> 01:12:25,420
>> JASON赫希洪：I + 1似乎是
最有效的，因為我們

1429
01:12:25,420 --> 01:12:26,120
已經有我。

1430
01:12:26,120 --> 01:12:28,100
我們指出，由於
最小的線15。

1431
01:12:28,100 --> 01:12:29,350
我們將開始與
自動下單。

1432
01:12:29,350 --> 01:12:34,470

1433
01:12:34,470 --> 01:12:38,540
所以，我們通過for循環。

1434
01:12:38,540 --> 01:12:39,620
我們將通過各一次。

1435
01:12:39,620 --> 01:12:40,860
我們將通過數次。

1436
01:12:40,860 --> 01:12:42,860
現在，我們通過已經得到了
這種內在的for循環。

1437
01:12:42,860 --> 01:12:44,350
我們有最小的值保存。

1438
01:12:44,350 --> 01:12:46,045
我們需要將其放置在
開始列表。

1439
01:12:46,045 --> 01:12:48,390
所以，我怎麼把它放置在
開始清單？

1440
01:12:48,390 --> 01:12:51,290

1441
01:12:51,290 --> 01:12:55,926
這是指該變量
到列表的開始？

1442
01:12:55,926 --> 01:13:00,500
我們在此為外循環，
還等什麼指

1443
01:13:00,500 --> 01:13:01,280
開始清單？

1444
01:13:01,280 --> 01:13:02,880
>> 學生：我的值。

1445
01:13:02,880 --> 01:13:03,510
>> JASON赫希洪：完全正確。

1446
01:13:03,510 --> 01:13:04,650
值i是的開始 - 

1447
01:13:04,650 --> 01:13:06,320
或不好意思，不是開始。

1448
01:13:06,320 --> 01:13:07,090
這是令人困惑的。

1449
01:13:07,090 --> 01:13:11,620
這也正是我們在年初
列表中的未排序的部分。

1450
01:13:11,620 --> 01:13:12,800
因此，重視我。

1451
01:13:12,800 --> 01:13:14,050
而這是什麼平等？

1452
01:13:14,050 --> 01:13:15,925

1453
01:13:15,925 --> 01:13:17,326
>> 學生：最小。

1454
01:13:17,326 --> 01:13:18,862
>> JASON赫希洪：值i等於什麼？

1455
01:13:18,862 --> 01:13:19,310
>> 學生：最小。

1456
01:13:19,310 --> 01:13:20,030
>> JASON赫希洪：最小。

1457
01:13:20,030 --> 01:13:20,980
完全正確。

1458
01:13:20,980 --> 01:13:23,510
所以我們將它放在開頭
名單的，現在我們需要把

1459
01:13:23,510 --> 01:13:25,710
該列表的開始的地方
最小的數字了。

1460
01:13:25,710 --> 01:13:29,700
所以，我怎麼寫的地方
最小的數是？

1461
01:13:29,700 --> 01:13:31,670
什麼價值觀？

1462
01:13:31,670 --> 01:13:33,170
>> 學生：0。

1463
01:13:33,170 --> 01:13:34,090
>> JASON赫希洪：小
數字是0？

1464
01:13:34,090 --> 01:13:35,340
>> 學生：是啊。

1465
01:13:35,340 --> 01:13:38,680

1466
01:13:38,680 --> 01:13:39,910
>> JASON赫希洪：那如果最小
人數在年底

1467
01:13:39,910 --> 01:13:40,860
這個無序列表？

1468
01:13:40,860 --> 01:13:42,460
>> 學生：對不起，究竟是什麼問題？

1469
01:13:42,460 --> 01:13:44,020
>> JASON赫希洪：哪裡是
最小的數字？

1470
01:13:44,020 --> 01:13:46,940
我們採取了最小，並把它在
開始，這條線就在這裡。

1471
01:13:46,940 --> 01:13:48,987
>> 學生：它應該有
被存儲在某種 - 

1472
01:13:48,987 --> 01:13:50,510
>> 學生：值Ĵ。

1473
01:13:50,510 --> 01:13:51,520
>> JASON赫希洪：嗯，這是
不一定值Ĵ。

1474
01:13:51,520 --> 01:13:54,100
它甚至沒有在這一點上存在。

1475
01:13:54,100 --> 01:13:55,960
>> 學生：你要申報
一個變量更早，

1476
01:13:55,960 --> 01:13:58,230
然後將其分配到 - 

1477
01:13:58,230 --> 01:14:01,150
當你發現的最小的數字，
該號碼的索引分配給

1478
01:14:01,150 --> 01:14:02,480
一些變量或類似的東西。

1479
01:14:02,480 --> 01:14:04,790
>> JASON赫希洪：所以可以
你再說一遍嗎？

1480
01:14:04,790 --> 01:14:08,390
>> 學生：那麼，您聲明整型
最小的，你也應該申報詮釋

1481
01:14:08,390 --> 01:14:10,750
最小的index = i或
類似的東西。

1482
01:14:10,750 --> 01:14:13,280
>> JASON赫希洪：那麼，我INT
最小的，我不應該只跟踪

1483
01:14:13,280 --> 01:14:16,150
的價值，但位置。

1484
01:14:16,150 --> 01:14:20,850
整型smallest_location =在這
情況下，我們就做我。

1485
01:14:20,850 --> 01:14:22,390
我們需要知道它在哪裡。

1486
01:14:22,390 --> 01:14:26,820
我們到了代碼的末尾，我們
意識到我們根本不知道在哪裡。

1487
01:14:26,820 --> 01:14:29,810
於是再次，我們的映射
這在一一對應的。

1488
01:14:29,810 --> 01:14:32,890
你們在自己的意志編碼這種
可能得到了同樣的問題。

1489
01:14:32,890 --> 01:14:34,130
如何赫克我找到它？

1490
01:14:34,130 --> 01:14:36,720
然後你意識到，等待，我
需要跟踪的那個。

1491
01:14:36,720 --> 01:14:38,500
>> 所以，如果最小的是更大
比的值Ĵ。

1492
01:14:38,500 --> 01:14:39,740
我們設定最小等於值Ĵ。

1493
01:14:39,740 --> 01:14:42,090
我們需要改變什麼？

1494
01:14:42,090 --> 01:14:43,710
康斯坦丁，還有什麼
我們需要改變？

1495
01:14:43,710 --> 01:14:44,560
>> 學生：位置。

1496
01:14:44,560 --> 01:14:45,270
>> JASON赫希洪：沒錯。

1497
01:14:45,270 --> 01:14:46,925
所以給我的代碼行。

1498
01:14:46,925 --> 01:14:53,310
>> 學生：smallest_location = j的。

1499
01:14:53,310 --> 01:14:54,790
>> JASON赫希洪：沒錯。

1500
01:14:54,790 --> 01:14:58,210
然後降底，如果我們想
放在列表的開頭，其中

1501
01:14:58,210 --> 01:15:00,790
最小的數字是，如何
我們指該

1502
01:15:00,790 --> 01:15:02,200
最小的數是？

1503
01:15:02,200 --> 01:15:03,580
馬庫斯？

1504
01:15:03,580 --> 01:15:08,530
>> 學生：最小數為
位於最小位置。

1505
01:15:08,530 --> 01:15:12,230
>> JASON赫希洪：所以在價值觀
smallest_location。

1506
01:15:12,230 --> 01:15:14,700
而我們放什麼呢？

1507
01:15:14,700 --> 01:15:17,600
的初
列表中，那是什麼？

1508
01:15:17,600 --> 01:15:19,710
>> 學生：嗯，我們真的不知道
了，因為我們改寫。

1509
01:15:19,710 --> 01:15:23,250
所以這是一個交換位置
在這兩行？

1510
01:15:23,250 --> 01:15:26,110
如果你周圍的切換這兩行。

1511
01:15:26,110 --> 01:15:30,740
>> JASON赫希洪：好了，我們不
了，因為我們已經復位線

1512
01:15:30,740 --> 01:15:31,960
前值i到最小。

1513
01:15:31,960 --> 01:15:33,810
所以我們失去了初始值。

1514
01:15:33,810 --> 01:15:37,350
所以你說的交換這兩行。

1515
01:15:37,350 --> 01:15:41,780
所以現在把列表的開頭
其中最小的數是。

1516
01:15:41,780 --> 01:15:47,060
所以smallest_location等於值I。

1517
01:15:47,060 --> 01:15:51,310
這是移動今年年初
的列表中的未排序的部分

1518
01:15:51,310 --> 01:15:52,090
最小的位置。

1519
01:15:52,090 --> 01:15:54,860
然後進入我的值我們正在
即最小數。

1520
01:15:54,860 --> 01:15:57,450
>> 這是否有意義，為什麼我們
不得不作出這樣的交換？

1521
01:15:57,450 --> 01:15:59,650
我們會覆蓋該值 - 
另一件事，你可能會有

1522
01:15:59,650 --> 01:16:02,740
想通了，並在國內生產總值中找到。

1523
01:16:02,740 --> 01:16:05,310
因此，我們已經照顧
所有的偽代碼。

1524
01:16:05,310 --> 01:16:10,935
還有什麼我們
需要在這裡寫？

1525
01:16:10,935 --> 01:16:14,911
有誰能夠想到什麼？

1526
01:16:14,911 --> 01:16:16,180
>> 學生：你怎麼知道
當你做了什麼？

1527
01:16:16,180 --> 01:16:17,680
>> JASON赫希洪：我們如何
知道什麼時候我們做了什麼？

1528
01:16:17,680 --> 01:16:18,890
大的問題。

1529
01:16:18,890 --> 01:16:21,684
那麼，我們如何知道什麼時候，我們就大功告成了。

1530
01:16:21,684 --> 01:16:24,720
>> 學生：創建一個變量來計數
如果有做了一個交換與否

1531
01:16:24,720 --> 01:16:27,810
並辦理了一通。

1532
01:16:27,810 --> 01:16:30,180
>> JASON赫希洪：確定。

1533
01:16:30,180 --> 01:16:31,800
將工作在冒泡排序。

1534
01:16:31,800 --> 01:16:35,210
但對於選擇排序，如果我們不這樣做
做一個交換，那可能只是

1535
01:16:35,210 --> 01:16:38,670
因為最小的值是
在它正確的位置。

1536
01:16:38,670 --> 01:16:41,240
我們可能有一個列表1，2，4，3。

1537
01:16:41,240 --> 01:16:42,830
通過我們的第二次
不會讓任何掉期。

1538
01:16:42,830 --> 01:16:47,260
我們將在2號，但我們會
仍然需要繼續下去。

1539
01:16:47,260 --> 01:16:49,390
那麼，我們需要跟踪的時候
我們就大功告成了，還是我們只是想去

1540
01:16:49,390 --> 01:16:50,640
直到完成？

1541
01:16:50,640 --> 01:16:54,098

1542
01:16:54,098 --> 01:16:56,740
>> 學生：我們可以去
直到它完成。

1543
01:16:56,740 --> 01:16:58,090
>> JASON赫希洪：我們可以只
去，直到這個完成。

1544
01:16:58,090 --> 01:17:01,720
在冒泡排序，你是完全正確的，
傑夫和Aleha，與您的解決方案 - 

1545
01:17:01,720 --> 01:17:04,990
它是偉大的跟踪有多少
掉期你做，因為在泡沫

1546
01:17:04,990 --> 01:17:07,920
排序，如果你實際上做不作任何掉期，
大功告成，你也許可以減少你

1547
01:17:07,920 --> 01:17:09,000
問題倒有幾分。

1548
01:17:09,000 --> 01:17:11,440
但對於選擇排序，你真的
有要經過的結束

1549
01:17:11,440 --> 01:17:14,940
列出在每個時間。

1550
01:17:14,940 --> 01:17:16,200
>> 因此，這是一點。

1551
01:17:16,200 --> 01:17:18,530
我們有兩分鐘時間。

1552
01:17:18,530 --> 01:17:21,560
讓我們所有。

1553
01:17:21,560 --> 01:17:24,340
讓我開在這裡找到，讓
相信我，其實調出 - 

1554
01:17:24,340 --> 01:17:25,610
我不是叫冒泡排序。

1555
01:17:25,610 --> 01:17:29,230
讓我們改變這個來選擇排序。

1556
01:17:29,230 --> 01:17:31,060
使所有/找到。

1557
01:17:31,060 --> 01:17:32,360
讓我們來看看42。

1558
01:17:32,360 --> 01:17:38,110
這一次，我們要傳遞一個
未排序的列表中，因為它應該排序

1559
01:17:38,110 --> 01:17:43,790
首先，每找到代碼 - 要排序
第一次使用我們的排序函數，然後

1560
01:17:43,790 --> 01:17:44,995
尋找的東西。

1561
01:17:44,995 --> 01:17:46,245
手指交叉大家。

1562
01:17:46,245 --> 01:17:48,530

1563
01:17:48,530 --> 01:17:49,370
>> 哦，我的天啊。

1564
01:17:49,370 --> 01:17:50,800
哇，我的心臟跳動。

1565
01:17:50,800 --> 01:17:52,320
所以這是正確的。

1566
01:17:52,320 --> 01:17:57,270
事實上，如果我們跑這更
大量的代碼，盡我所能

1567
01:17:57,270 --> 01:17:59,280
說，是完全正確的。

1568
01:17:59,280 --> 01:18:02,150
還有一些建議
我會為你。

1569
01:18:02,150 --> 01:18:06,215
例如，15和16似乎
有點多餘。

1570
01:18:06,215 --> 01:18:09,450
好像你不一定
需要保存這兩個。

1571
01:18:09,450 --> 01:18:12,790
如果您有最小的位置，你
可以很容易地找到最小值

1572
01:18:12,790 --> 01:18:14,750
只是打字的i值。

1573
01:18:14,750 --> 01:18:18,100
>> 所以，如果我是被分級代碼，
我其實會，我會

1574
01:18:18,100 --> 01:18:21,160
大概起飛點，如果你
包括這兩種，因為你

1575
01:18:21,160 --> 01:18:22,670
不需要這兩個。

1576
01:18:22,670 --> 01:18:25,400
如果你有位置，可以
很容易獲得的價值。

1577
01:18:25,400 --> 01:18:27,520
這似乎有點不可思議
來存儲它們。

1578
01:18:27,520 --> 01:18:31,070
也許不拿一個點，而是
當然評論說，這也許是

1579
01:18:31,070 --> 01:18:32,670
不是一個風格上的選擇
你需要做。

1580
01:18:32,670 --> 01:18:35,290
當然，該代碼仍然
運轉很好。

1581
01:18:35,290 --> 01:18:36,860
>> 所以很遺憾，我們沒
得到冒泡排序。

1582
01:18:36,860 --> 01:18:37,940
我很抱歉這一點。

1583
01:18:37,940 --> 01:18:39,135
我們確實完成選擇排序。

1584
01:18:39,135 --> 01:18:41,450
沒有任何人有任何問題，最終
關於選擇排序？

1585
01:18:41,450 --> 01:18:44,320

1586
01:18:44,320 --> 01:18:47,690
>> 好了，我們才探出頭來，我要你
打開你的Chrome瀏覽器。

1587
01:18:47,690 --> 01:18:54,340
對不起，這僅僅是一個赤裸裸的插頭
一種類型的互聯網瀏覽器。

1588
01:18:54,340 --> 01:18:57,770
你可以打開任何類型的瀏覽器，
但它很可能是Chrome瀏覽器。

1589
01:18:57,770 --> 01:19:01,250
和去這個網站之後 - 

1590
01:19:01,250 --> 01:19:06,410
sayat.me/cs50。

1591
01:19:06,410 --> 01:19:07,685
如果你不鍵入您的電腦
現在，你是清楚的

1592
01:19:07,685 --> 01:19:10,210
不這樣做，湯姆。

1593
01:19:10,210 --> 01:19:12,870
>> 並且請做任何權利
現在還是在接下來的一個小時 - 

1594
01:19:12,870 --> 01:19:14,260
給我一些反饋。

1595
01:19:14,260 --> 01:19:15,660
這只是部分中的兩個。

1596
01:19:15,660 --> 01:19:18,060
我們有更多的共同擁有的，所以我
有很多的提升空間。

1597
01:19:18,060 --> 01:19:19,620
我希望也做了一些事情做好。

1598
01:19:19,620 --> 01:19:22,160
所以，你可以讓我覺得全是壞事，但如果
你也想​​給我一個笑臉

1599
01:19:22,160 --> 01:19:24,250
臉，我將不勝感激這一點。

1600
01:19:24,250 --> 01:19:25,330
填補英寸

1601
01:19:25,330 --> 01:19:28,210
>> 並與留一分鐘，
這是三週。

1602
01:19:28,210 --> 01:19:30,750
我就站在外面了一下
如果您有任何疑問。

1603
01:19:30,750 --> 01:19:32,220
我會看到你們
講課的明天。

1604
01:19:32,220 --> 01:19:34,742