1
00:00:00,000 --> 00:00:03,000
[Powered by Google Translate] [第3] [舒適]

2
00:00:03,000 --> 00:00:05,000
>> 內特 - 哈迪森] [哈佛大學]

3
00:00:05,000 --> 00:00:08,000
>> 這是CS50。[CS50.TV]

4
00:00:08,000 --> 00:00:10,000
>> 好吧，讓我們開始吧。

5
00:00:10,000 --> 00:00:13,000
歡迎CS50 4週。

6
00:00:13,000 --> 00:00:19,000
如果你們打開Web瀏覽器和打開的pset 3，

7
00:00:19,000 --> 00:00:23,000
爭奪與CS50，我們要開始

8
00:00:23,000 --> 00:00:26,000
通過的部分的問題存在。

9
00:00:26,000 --> 00:00:32,000
就像上週，我們將工作在CS50空間，

10
00:00:32,000 --> 00:00:35,000
，如果你也拉，以及，

11
00:00:35,000 --> 00:00:43,000
如果你繼續前進，請訪問此鏈接，我已經起身在頂部。

12
00:00:43,000 --> 00:00:45,000
現在是時候開始瀏覽網頁。

13
00:00:45,000 --> 00:00:51,000
我們有我們的小喜這裡的程序。沒有什麼神秘的。

14
00:00:51,000 --> 00:00:55,000
我想你們今天做的第一件事情就是去了幾個解決方案

15
00:00:55,000 --> 00:00:58,000
問題1，種示例解決方案，

16
00:00:58,000 --> 00:01:03,000
只是，這樣你可以得到什麼樣的代碼的工作人員正在寫一個感覺，

17
00:01:03,000 --> 00:01:07,000
什麼樣的代碼其他學生寫作，

18
00:01:07,000 --> 00:01:10,000
你看看它，因為我知道它的怪異

19
00:01:10,000 --> 00:01:14,000
當您提交問題集的解決方案，並獲得評論

20
00:01:14,000 --> 00:01:18,000
你自己的版本，但有時它是有益的，看看其他人如何做，

21
00:01:18,000 --> 00:01:22,000
尤其是很不錯的期待。

22
00:01:22,000 --> 00:01:27,000
在大多數情況下，我真的很感動，你們生產的解決方案。

23
00:01:27,000 --> 00:01:31,000
我還沒有開始看習題集2，但如果他們是什麼第一，

24
00:01:31,000 --> 00:01:34,000
這意味著什麼，但好東西。

25
00:01:34,000 --> 00:01:40,000
>> 如果你看一下我的修改，讓我們開始一路下跌，在第1次修訂，

26
00:01:40,000 --> 00:01:47,000
我們將採取一個快速的看看馬里奧解決方案的。

27
00:01:47,000 --> 00:01:54,000
如果你拉這件事，我們會提出這些程序是正確的。

28
00:01:54,000 --> 00:01:56,000
有沒有這些問題的正確性問題，而是

29
00:01:56,000 --> 00:01:59,000
我們要談一點點的不同的設計問題

30
00:01:59,000 --> 00:02:03,000
被用在這裡。

31
00:02:03,000 --> 00:02:08,000
的事情，這是有趣的解決方案之一

32
00:02:08,000 --> 00:02:11,000
是，它使用這個新的構造稱為磅的定義，

33
00:02:11,000 --> 00:02:15,000
有時也被稱為作為一個哈希定義。

34
00:02:15,000 --> 00:02:18,000
讓我在這裡放大。

35
00:02:18,000 --> 00:02:24,000
A＃定義允許您給這些數字在你的程序中。

36
00:02:24,000 --> 00:02:28,000
在這種情況下，它的最大高度在Mario金字塔

37
00:02:28,000 --> 00:02:34,000
為23，而不是把23在我的代碼

38
00:02:34,000 --> 00:02:37,000
我們將參照硬編碼23  - 

39
00:02:37,000 --> 00:02:43,000
提供的名稱，而不是MAX_HEIGHT這個數字，

40
00:02:43,000 --> 00:02:48,000
所以，在這裡我do-whil​​e循環

41
00:02:48,000 --> 00:02:51,000
實際上，你可以參考MAX_HEIGHT

42
00:02:51,000 --> 00:02:55,000
而不是把號碼23英寸

43
00:02:55,000 --> 00:02:57,000
[學生]：這樣做的優點是什麼？

44
00:02:57,000 --> 00:02:59,000
這是一個很大的問題。

45
00:02:59,000 --> 00:03:03,000
一個是可讀性。

46
00:03:03,000 --> 00:03:08,000
使用此＃定義的優點是可讀性。

47
00:03:08,000 --> 00:03:11,000
當我讀這段代碼中，可以看到發生了什麼事情。

48
00:03:11,000 --> 00:03:15,000
>> 我在這裡可以看到，在這種情況下，我們正在測試

49
00:03:15,000 --> 00:03:19,000
的高度，即<0，我們也可以定義

50
00:03:19,000 --> 00:03:22,000
是最低限度的高度或最低高度。

51
00:03:22,000 --> 00:03:25,000
另一個好處是，我可以讀取行的其餘部分

52
00:03:25,000 --> 00:03:30,000
我們還在檢查，以確保高度不大於最大高度，

53
00:03:30,000 --> 00:03:35,000
因為我們要繼續下去，而高度大於最大高度。

54
00:03:35,000 --> 00:03:40,000
另一個好處是，如果我放大了一點點

55
00:03:40,000 --> 00:03:49,000
如果我運行這個程序，我運行它，說，現在有23，

56
00:03:49,000 --> 00:03:52,000
它會打印出23行一樣，。

57
00:03:52,000 --> 00:03:54,000
但說我想改變的最大高度，

58
00:03:54,000 --> 00:03:57,000
現在我想限制的最大高度金字塔

59
00:03:57,000 --> 00:04:06,000
只能說人，那是時髦的。

60
00:04:06,000 --> 00:04:14,000
＃包括<stdio.h>，定義MAX_HEIGHT，

61
00:04:14,000 --> 00:04:18,000
讓我們說，我們要設置它等於10。

62
00:04:18,000 --> 00:04:22,000
現在，在這一點上，所有我需要做的是改變它在這一個位置。

63
00:04:22,000 --> 00:04:27,000
我可以重新編譯代碼，現在如果我嘗試輸入12，

64
00:04:27,000 --> 00:04:30,000
它會提示我了。

65
00:04:30,000 --> 00:04:33,000
在這種情況下，我們只用MAX_HEIGHT一次。

66
00:04:33,000 --> 00:04:37,000
這並不是說大的麻煩去

67
00:04:37,000 --> 00:04:40,000
並改變它在while循環中，如果你需要的話。

68
00:04:40,000 --> 00:04:44,000
但是，在您在何處引用了相同的幻數的程序

69
00:04:44,000 --> 00:04:47,000
一遍又一遍，這樣的機制是非常方便的

70
00:04:47,000 --> 00:04:52,000
因為你只需要改變一個時間的文件，它通常你把他們的頂端

71
00:04:52,000 --> 00:04:57,000
和變化滲濾通過文件的其餘部分。

72
00:04:57,000 --> 00:05:02,000
>> 其他的事情，我想指出，我認為在這個任務看起來真的很不錯，

73
00:05:02,000 --> 00:05:05,000
一個是變量的命名。

74
00:05:05,000 --> 00:05:14,000
你在這裡看到的，我們已經有了整數變量稱為行，所謂的高度。

75
00:05:14,000 --> 00:05:20,000
空間，哈希，它有助於使代碼更具可讀性一點，

76
00:05:20,000 --> 00:05:25,000
多一點理解什麼實際事情。

77
00:05:25,000 --> 00:05:31,000
這是在對比使用，也就是說，隨機字母

78
00:05:31,000 --> 00:05:35,000
或只是官樣文章完全。

79
00:05:35,000 --> 00:05:39,000
最後記住一件事，我要指出的是，在for循環中，

80
00:05:39,000 --> 00:05:45,000
通常這些迭代器變量，計數器，您在您的循環使用，

81
00:05:45,000 --> 00:05:51,000
它的標準和傳統的開始，我和那麼j，則k

82
00:05:51,000 --> 00:05:54,000
從那裡，如果你需要更多的變數，

83
00:05:54,000 --> 00:05:56,000
這僅僅是一個慣例。

84
00:05:56,000 --> 00:05:58,000
有很多的公約。

85
00:05:58,000 --> 00:06:00,000
這取決於你使用的編程語言。

86
00:06:00,000 --> 00:06:04,000
但在C中，我們通常開始與我同在。

87
00:06:04,000 --> 00:06:08,000
使用它沒有意義，也就是說，a或b

88
00:06:08,000 --> 00:06:13,000
視情況而定。

89
00:06:13,000 --> 00:06:15,000
這是這一個。

90
00:06:15,000 --> 00:06:25,000
如果你現在拉了第二次修訂，你會看到一個馬里奧，

91
00:06:25,000 --> 00:06:29,000
而這一次是我們剛剛看到另一個類似，

92
00:06:29,000 --> 00:06:32,000
但它確實挺酷的東西。

93
00:06:32,000 --> 00:06:38,000
如果我們看一下在本節內內循環，

94
00:06:38,000 --> 00:06:44,000
他們使用的是一些瘋狂的尋找在此行中的語法在這裡。

95
00:06:44,000 --> 00:06:47,000
這就是所謂的三元運算符。

96
00:06:47,000 --> 00:06:53,000
這是一個if else語句，凝結成一條線。

97
00:06:53,000 --> 00:06:57,000
條件是這部分括號內。

98
00:06:57,000 --> 00:07:05,000
這相當於說，如果j <高度 - 我 -  1。

99
00:07:05,000 --> 00:07:10,000
然後的內容是什麼，如果塊的空間

100
00:07:10,000 --> 00:07:16,000
然後將內容的else將＃。

101
00:07:16,000 --> 00:07:20,000
它本質上是一個空間分配給這個變量。

102
00:07:20,000 --> 00:07:24,000
它把一個空間中的內容的塊變量，

103
00:07:24,000 --> 00:07:29,000
如果滿足此條件，如果該條件沒有被滿足，

104
00:07:29,000 --> 00:07:32,000
然後塊變量得到＃。

105
00:07:32,000 --> 00:07:37,000
然後，當然，而不是建立整個字符串

106
00:07:37,000 --> 00:07:43,000
印刷一切結束時，該解決方案把它打印出一個字符的時間。

107
00:07:43,000 --> 00:07:48,000
很酷。

108
00:07:48,000 --> 00:07:53,000
>> 另外一對夫婦的事情來看待。我們將要討論的貪婪。

109
00:07:53,000 --> 00:07:58,000
現在，如果我們看貪婪，這第一個解決方案

110
00:07:58,000 --> 00:08:00,000
使用＃定義相當多的。

111
00:08:00,000 --> 00:08:06,000
我們已經有了一個常量定義在這個程序的每一個不同的數字。

112
00:08:06,000 --> 00:08:12,000
我們已經有了一個美分美元，一個季度，助攻，鎳，和便士，

113
00:08:12,000 --> 00:08:15,000
現在如果我們向下滾動和閱讀代碼，

114
00:08:15,000 --> 00:08:22,000
我們可以看到一個標準的do-whil​​e循環打印了。

115
00:08:22,000 --> 00:08:25,000
一種意識到這個問題的癥結所在，

116
00:08:25,000 --> 00:08:29,000
你需要轉換的浮動，你在閱讀的用戶整數

117
00:08:29,000 --> 00:08:32,000
準確地做數學題，這是因為

118
00:08:32,000 --> 00:08:36,000
浮點數字，就像我們在演講中簡要地談到，

119
00:08:36,000 --> 00:08:41,000
這是不可能的，準確地反映每一個價值數行

120
00:08:41,000 --> 00:08:47,000
因為有無窮多個值之間，並說，甚至3.1。

121
00:08:47,000 --> 00:08:54,000
你可以有3.01和3.001及3.0001，你可以繼續下去。

122
00:08:54,000 --> 00:09:00,000
事實證明，用錢時，你的工作，你經常需要將其轉換

123
00:09:00,000 --> 00:09:05,000
轉換為整數，所以你不會失去便士和諸如此類的東西。

124
00:09:05,000 --> 00:09:09,000
這樣做，和舍入是關鍵。

125
00:09:09,000 --> 00:09:14,000
該解決方案使用了一個完全直接的，巨大的算法，

126
00:09:14,000 --> 00:09:17,000
遞減數剩餘美分，第一季度，

127
00:09:17,000 --> 00:09:19,000
然後通過硬幣，然後由鎳，然後通過便士，

128
00:09:19,000 --> 00:09:24,000
和添加的硬幣的數目，每次。

129
00:09:24,000 --> 00:09:31,000
>> 另一種解決方案，我們會看到，我縮小到4修訂版，

130
00:09:31,000 --> 00:09:40,000
有一個非常類似的開始，而是採用div和mod

131
00:09:40,000 --> 00:09:44,000
在這裡的數量來計算美分。

132
00:09:44,000 --> 00:09:50,000
這樣，宿舍的數量是等於除以25美分的數量，

133
00:09:50,000 --> 00:09:53,000
這個工作的原因是因為我們正在做整數除法，

134
00:09:53,000 --> 00:09:58,000
所以它丟棄任何剩餘的。

135
00:09:58,000 --> 00:10:02,000
[學生]：我們要不要發表評論，搜索嗎？

136
00:10:02,000 --> 00:10:05,000
這真的視情況而定。

137
00:10:05,000 --> 00:10:08,000
[學生]：你註釋以上代碼就在這裡。

138
00:10:08,000 --> 00:10:16,000
是啊，所以有一堆不同的哲學。

139
00:10:16,000 --> 00:10:21,000
我的個人哲學是你的代碼是真正的真理，

140
00:10:21,000 --> 00:10:24,000
喜歡你的代碼是什麼實際的計算機上執行，

141
00:10:24,000 --> 00:10:29,000
所以你的代碼應該盡可能地易讀沒有必要了許多意見。

142
00:10:29,000 --> 00:10:33,000
這就是說，當你正在做的事情，是一種棘手的數學

143
00:10:33,000 --> 00:10:38,000
或算法，這是很好的評論，這樣就可以

144
00:10:38,000 --> 00:10:43,000
誰是閱讀你的代碼中添加一個額外的維度，一個額外的層。

145
00:10:43,000 --> 00:10:49,000
在這些解決方案中，他們往往更多地只是因為被註釋掉

146
00:10:49,000 --> 00:10:52,000
我們希望能夠分發給才有人接他們時，

147
00:10:52,000 --> 00:10:56,000
讀他們很容易。

148
00:10:56,000 --> 00:11:05,000
但可以肯定的是，我同意，這是沉重的。

149
00:11:05,000 --> 00:11:07,000
[學生]：但是，當疑問，請重？

150
00:11:07,000 --> 00:11:10,000
如果有疑問，去重了。

151
00:11:10,000 --> 00:11:17,000
有時，有些人會說，返回0或類似的東西。

152
00:11:17,000 --> 00:11:20,000
我認為這是一個荒謬的評論。

153
00:11:20,000 --> 00:11:22,000
顯然，這是發生了什麼。

154
00:11:22,000 --> 00:11:25,000
我不需要英語告訴我。

155
00:11:25,000 --> 00:11:28,000
有時候人們會寫的東西像​​“kthxbai！”

156
00:11:28,000 --> 00:11:32,000
這是種可愛，但也未

157
00:11:32,000 --> 00:11:35,000
這不是評論點或不之間的差異。

158
00:11:35,000 --> 00:11:41,000
這些類型的評論是，哈哈哈。

159
00:11:41,000 --> 00:11:43,000
酷。

160
00:11:43,000 --> 00:11:48,000
>> 在這一點上，讓我們開始工作的習題集3節的問題。

161
00:11:48,000 --> 00:11:52,000
如果你們拉起來了，

162
00:11:52,000 --> 00:11:55,000
與上週一樣，我們不打算在本節觀看短褲。

163
00:11:55,000 --> 00:12:00,000
我們將讓你們這樣做對你自己的時間和談論的問題。

164
00:12:00,000 --> 00:12:05,000
但是，現在在本節中，我們將要花費多一點的時間

165
00:12:05,000 --> 00:12:11,000
談論的編碼基礎

166
00:12:11,000 --> 00:12:15,000
像我們一樣上週，而不是，我們會更專注於

167
00:12:15,000 --> 00:12:22,000
多一點點的理論，所以在談論二進制搜索和排序。

168
00:12:22,000 --> 00:12:27,000
你已經遵循了演講，

169
00:12:27,000 --> 00:12:30,000
有人可以給我一個概括的區別是什麼

170
00:12:30,000 --> 00:12:35,000
之間的二進制搜索和線性搜索？

171
00:12:35,000 --> 00:12:37,000
這是怎麼回事呢？當然。

172
00:12:37,000 --> 00:12:42,000
線性搜索可通過在排序列表中的每一個元素

173
00:12:42,000 --> 00:12:45,000
一個由一個一個逐個

174
00:12:45,000 --> 00:12:50,000
二進制搜索將列表分為2組，

175
00:12:50,000 --> 00:12:57,000
檢查，如果你正在尋找的關鍵值，大於或小於中間值

176
00:12:57,000 --> 00:13:00,000
你剛剛發現的，如果是小於，它會與下面的列表中

177
00:13:00,000 --> 00:13:03,000
然後將再次做同樣的功能

178
00:13:03,000 --> 00:13:07,000
一路下來，直到它找到中點，等於本身的價值。

179
00:13:07,000 --> 00:13:10,000
右。

180
00:13:10,000 --> 00:13:12,000
>> 我們為什麼要關心？

181
00:13:12,000 --> 00:13:20,000
我們為什麼要談論與線性搜索的二進制搜索？

182
00:13:20,000 --> 00:13:22,000
是啊。

183
00:13:22,000 --> 00:13:24,000
二進制是快了很多，所以如果你的問題的規模增加一倍

184
00:13:24,000 --> 00:13:27,000
它需要一個步驟，而不是兩倍多。

185
00:13:27,000 --> 00:13:29,000
沒錯。

186
00:13:29,000 --> 00:13:31,000
這是一個偉大的答案。

187
00:13:31,000 --> 00:13:36,000
線性搜索是非常檢查在一個時間，一個元件

188
00:13:36,000 --> 00:13:39,000
正如我們所看到的第一天的演講

189
00:13:39,000 --> 00:13:42,000
當大衛•多姆德（David Drummond）通過他的手機，書中的例子

190
00:13:42,000 --> 00:13:45,000
一次撕開了一個頁的電話本

191
00:13:45,000 --> 00:13:47,000
並不停地一遍又一遍，再這樣做，

192
00:13:47,000 --> 00:13:51,000
它要帶他在電話簿中找到任何的很長一段時間，

193
00:13:51,000 --> 00:13:55,000
除非，當然，他要找的人在一開始的字母。

194
00:13:55,000 --> 00:14:00,000
在二進制搜索，你可以去快了很多，

195
00:14:00,000 --> 00:14:05,000
它不只是兩次以最快的速度或快3倍或4倍的速度。

196
00:14:05,000 --> 00:14:13,000
但是，問題變得更小和更小的和更小的要快得多。

197
00:14:13,000 --> 00:14:17,000
為了說明這一點，我們就開始談論這是怎麼回事

198
00:14:17,000 --> 00:14:21,000
當我們寫二進制搜索。

199
00:14:21,000 --> 00:14:27,000
目前的問題是，如果我有一個數組的數字，

200
00:14:27,000 --> 00:14:40,000
說，1，2，3，5，7，23，45，78，12323，

201
00:14:40,000 --> 00:14:47,000
然後一噸的0後，

202
00:14:47,000 --> 00:14:52,000
我們希望能夠真的很快弄清楚什麼是

203
00:14:52,000 --> 00:14:57,000
這個數組。

204
00:14:57,000 --> 00:15:00,000
我知道這似乎有點傻，有點做作，

205
00:15:00,000 --> 00:15:02,000
因為現在它是。

206
00:15:02,000 --> 00:15:05,000
我們有一個數組，沒有很多的元素在裡面，

207
00:15:05,000 --> 00:15:08,000
如果我問你是否找出

208
00:15:08,000 --> 00:15:11,000
23是在數組中，你能做到這一點很快

209
00:15:11,000 --> 00:15:16,000
只是掃了一眼，告訴我“是”或“否”。

210
00:15:16,000 --> 00:15:20,000
要考慮的是模擬想像一下，如果這個份上，說，

211
00:15:20,000 --> 00:15:27,000
一個Excel電子表格有10000行，20000行。

212
00:15:27,000 --> 00:15:31,000
當然，你可以執行命令F或控制F，看的東西了。

213
00:15:31,000 --> 00:15:33,000
您還可以使用過濾器和搜索的東西，

214
00:15:33,000 --> 00:15:37,000
但如果你有看通過該文件中的行由行線，

215
00:15:37,000 --> 00:15:40,000
它會花費你很長的時間來找到它。

216
00:15:40,000 --> 00:15:42,000
這是一種在電話簿的例子一樣，太，其中

217
00:15:42,000 --> 00:15:44,000
沒有人期待通過一次的電話簿1頁。

218
00:15:44,000 --> 00:15:47,000
通常情況下，他們開到中間，

219
00:15:47,000 --> 00:15:50,000
或在的情況下，大量的電話本和字典

220
00:15:50,000 --> 00:15:54,000
你實際上它的第一個字母鍵，

221
00:15:54,000 --> 00:16:01,000
你翻轉，第一個字母，打開並開始經過那裡。

222
00:16:01,000 --> 00:16:03,000
>> 再次提醒我你的名字。>>山姆。

223
00:16:03,000 --> 00:16:05,000
山姆。

224
00:16:05,000 --> 00:16:11,000
像Sam說，該線性搜索過程將是很慢的，

225
00:16:11,000 --> 00:16:15,000
，而不是二進制搜索的工作方式是，

226
00:16:15,000 --> 00:16:21,000
我們每次去通過我們的搜索算法的迭代，

227
00:16:21,000 --> 00:16:27,000
我們要分一半的列表中，基本上，

228
00:16:27,000 --> 00:16:33,000
成兩個較小的列表。

229
00:16:33,000 --> 00:16:39,000
然後在循環的下一次迭代，我們將其劃分再

230
00:16:39,000 --> 00:16:44,000
進入其他較小列表。

231
00:16:44,000 --> 00:16:48,000
正如你可以看到，這個問題繼續變得更小和更小的

232
00:16:48,000 --> 00:16:55,000
因為我們保持每一次放棄一半的列表。

233
00:16:55,000 --> 00:16:59,000
丟棄它是如何工作？

234
00:16:59,000 --> 00:17:05,000
正如一個提醒，我們要做的，如果我們的電腦

235
00:17:05,000 --> 00:17:11,000
和我們說，在此列表中，尋找5號

236
00:17:11,000 --> 00:17:15,000
是，我們會選擇一個中間的數字。

237
00:17:15,000 --> 00:17:26,000
在此列表中，因為有1，2，3，4，5，6，7，8，9，10的號碼，

238
00:17:26,000 --> 00:17:32,000
我們會選擇在第4位或第5位，

239
00:17:32,000 --> 00:17:38,000
我們會打電話給我們的名單中。

240
00:17:38,000 --> 00:17:42,000
選擇在中間。

241
00:17:42,000 --> 00:17:51,000
然後，就像山姆說，我們將測試一下，看看如果這個數字是相等的

242
00:17:51,000 --> 00:17:59,000
的數量，我們希望得到我們想要的號碼。

243
00:17:59,000 --> 00:18:06,000
如果相等的話，我們已經找到了。我們贏了。

244
00:18:06,000 --> 00:18:12,000
如果不相等，則有一對夫婦的情況下。

245
00:18:12,000 --> 00:18:15,000
這兩種情況是數數大於我們正在尋找，

246
00:18:15,000 --> 00:18:19,000
或者是小於。

247
00:18:19,000 --> 00:18:25,000
如果是更大的，我們移動到右邊。

248
00:18:25,000 --> 00:18:33,000
如果是，我們移動到左側。

249
00:18:33,000 --> 00:18:41,000
然後，我們再次重複整個過程，

250
00:18:41,000 --> 00:18:48,000
右半或列表中的左半邊。

251
00:18:48,000 --> 00:18:51,000
>> 在今天的部分的第一個問題是要弄清楚

252
00:18:51,000 --> 00:18:55,000
實際上，我們可以在C代碼中開始表達。

253
00:18:55,000 --> 00:18:58,000
我們在這裡得到的偽。

254
00:18:58,000 --> 00:19:04,000
我們將開始做的是我拉了一個全新的空間，

255
00:19:04,000 --> 00:19:09,000
保存本次修訂，使我們有這些說明後，

256
00:19:09,000 --> 00:19:20,000
我們將刪除所有這一切，然後複製並粘貼問題集

257
00:19:20,000 --> 00:19:26,000
此信息進入我們的空間，並希望這不會打破。

258
00:19:26,000 --> 00:19:28,000
完美的。

259
00:19:28,000 --> 00:19:33,000
如果你們都這樣做，這段代碼複製並粘貼到新的空間，

260
00:19:33,000 --> 00:19:43,000
進入一個空白。

261
00:19:43,000 --> 00:19:47,000
讓我們嘗試丹尼爾。如果你編譯並運行這個程序，它的工作嗎？

262
00:19:47,000 --> 00:19:49,000
號>>什麼是它在說什麼？

263
00:19:49,000 --> 00:19:53,000
它說，控制到達非void函數的結束。

264
00:19:53,000 --> 00:19:55,000
是啊，所以我嘗試運行它。

265
00:19:55,000 --> 00:19:59,000
你們見過嗎？你知道這意味著什麼嗎？

266
00:19:59,000 --> 00:20:01,000
好吧，讓我們來剖析這一點點。

267
00:20:01,000 --> 00:20:10,000
它說在file.c在第9行，第1列，我們有一個錯誤，就像你說的，

268
00:20:10,000 --> 00:20:16,000
它說，它源於錯誤警告和返回類型的警告。

269
00:20:16,000 --> 00:20:18,000
它看起來喜歡的東西是怎麼回事，這是有道理的返回類型。

270
00:20:18,000 --> 00:20:21,000
我們有一個非void函數，這意味著我們已經有了一個功能

271
00:20:21,000 --> 00:20:24,000
不返回void。

272
00:20:24,000 --> 00:20:27,000
一個void函數，是一個看起來是這樣的：

273
00:20:27,000 --> 00:20:35,000
無效的foo（），它是無效的，因為返回類型為void，

274
00:20:35,000 --> 00:20:38,000
這意味著，如果我們有一些東西在這裡

275
00:20:38,000 --> 00:20:45,000
如返回1，我們會得到一個編譯錯誤。

276
00:20:45,000 --> 00:20:49,000
但是，我們有一個非void函數。

277
00:20:49,000 --> 00:20:51,000
在這種情況下，我們的非void函數是我們的搜索功能

278
00:20:51,000 --> 00:20:56,000
因為它有一個返回布爾類型的。

279
00:20:56,000 --> 00:20:59,000
當它的控制達到了一個非void函數，

280
00:20:59,000 --> 00:21:02,000
這是因為搜索沒有一個return語句。

281
00:21:02,000 --> 00:21:04,000
它沒有返回bool類型的任何東西。

282
00:21:04,000 --> 00:21:09,000
>> 我們可以解決這個問題，你們怎麼想

283
00:21:09,000 --> 00:21:13,000
搜索返回的默認？

284
00:21:13,000 --> 00:21:16,000
搜索默認的返回值應該是什麼？

285
00:21:16,000 --> 00:21:19,000
因為這是我們可以放在最後。

286
00:21:19,000 --> 00:21:21,000
夏洛特，你有什麼？

287
00:21:21,000 --> 00:21:23,000
真還是假的？>> TRUE或FALSE。

288
00:21:23,000 --> 00:21:26,000
哪一個？

289
00:21:26,000 --> 00:21:28,000
為False。我不知道。

290
00:21:28,000 --> 00:21:30,000
假的？讓我們試試吧。

291
00:21:30,000 --> 00:21:32,000
為什麼你會說，返回假的？這是偉大的直覺。

292
00:21:32,000 --> 00:21:35,000
[夏洛特]我不知道。

293
00:21:35,000 --> 00:21:39,000
我們將返回false，在這種情況下，因為這將是我們的默認

294
00:21:39,000 --> 00:21:44,000
如果由於某種原因，該列表為空，或針

295
00:21:44,000 --> 00:21:46,000
我們正在尋找不存在的。

296
00:21:46,000 --> 00:21:50,000
然後在最後，如果我們不返回true早些時候在這個函數中，

297
00:21:50,000 --> 00:21:55,000
我們一直知道，這個函數會說，不，這不是在數組中。

298
00:21:55,000 --> 00:21:58,000
這不是在草堆裡。

299
00:21:58,000 --> 00:22:03,000
現在，如果我們要編譯和運行它讓我節省，所以我們可以把它拽上來。

300
00:22:03,000 --> 00:22:08,000
現在，如果我們要編譯和運行我們的程序，它的基礎之上。

301
00:22:08,000 --> 00:22:12,000
我們得到了我們的小提示。

302
00:22:12,000 --> 00:22:20,000
如果我打了4架UH-OH。

303
00:22:20,000 --> 00:22:25,000
它沒有打印出任何東西。它看起來像一切結束行。

304
00:22:25,000 --> 00:22:35,000
我們必須填寫此英寸

305
00:22:35,000 --> 00:22:39,000
我們談到了該算法的偽代碼一點點。

306
00:22:39,000 --> 00:22:44,000
讓我看看，保存，

307
00:22:44,000 --> 00:22:49,000
，我會拉算法備份。

308
00:22:49,000 --> 00:22:51,000
讓我們來打這傢伙。不。

309
00:22:51,000 --> 00:22:58,000
在那裡，它是。

310
00:22:58,000 --> 00:23:03,000
如何才能做到這一點呢？

311
00:23:03,000 --> 00:23:11,000
這將是一個很好的策略開始這段代碼嗎？

312
00:23:11,000 --> 00:23:16,000
你必須選擇一個中間的數字。

313
00:23:16,000 --> 00:23:23,000
我們如何在一個數組中挑選一些呢？

314
00:23:23,000 --> 00:23:25,000
有什麼建議嗎？

315
00:23:25,000 --> 00:23:27,000
[學生]：STRLEN除以2。

316
00:23:27,000 --> 00:23:32,000
STRLEN除以2。這是一個偉大的。

317
00:23:32,000 --> 00:23:35,000
strlen的作品特殊類型的數組。

318
00:23:35,000 --> 00:23:38,000
什麼類型的數組？

319
00:23:38,000 --> 00:23:44,000
String數組，字符數組。

320
00:23:44,000 --> 00:23:48,000
這是同樣的概念，我們要申請，

321
00:23:48,000 --> 00:23:52,000
但我們不能使用strlen，因為我們沒有一個字符數組。

322
00:23:52,000 --> 00:23:55,000
我們有一個整型數組。

323
00:23:55,000 --> 00:23:58,000
但到底是什麼strlen的我們嗎？

324
00:23:58,000 --> 00:24:01,000
你知道它會為我們嗎？

325
00:24:01,000 --> 00:24:03,000
[學生]：STRLEN讓我們長。

326
00:24:03,000 --> 00:24:05,000
沒錯，它使我們的長度。

327
00:24:05,000 --> 00:24:09,000
STRLEN得到我們的數組的長度。

328
00:24:09,000 --> 00:24:14,000
>> 我們怎樣才能在我們的二進制搜索程序？

329
00:24:14,000 --> 00:24:18,000
你會得到一個數組的長度？

330
00:24:18,000 --> 00:24:20,000
[學生]：STRLEN？

331
00:24:20,000 --> 00:24:25,000
你可以得到一個正確格式化C字符串數組的長度與strlen的。

332
00:24:25,000 --> 00:24:31,000
，不過，問題是，我們沒有一個字符串數組。

333
00:24:31,000 --> 00:24:36,000
如果我們回頭看這段代碼，我們有這樣的整數數組。

334
00:24:36,000 --> 00:24:38,000
我們怎麼知道它有多長？

335
00:24:38,000 --> 00:24:44,000
[學生]：是否有一個相當於一個端點，如INT L或什麼的？

336
00:24:44,000 --> 00:24:49,000
事實證明，實際上不是，因此，在某種程度上，這是

337
00:24:49,000 --> 00:24:52,000
這些事情，只是知道關於C之一，

338
00:24:52,000 --> 00:24:57,000
有沒有辦法讓一個數組的長度

339
00:24:57,000 --> 00:24:59,000
如果我給你的是一個數組。

340
00:24:59,000 --> 00:25:02,000
它的工作原理與字符串的原因，因為strlen的作品，

341
00:25:02,000 --> 00:25:06,000
是因為如果一個字符串格式是否正確，

342
00:25:06,000 --> 00:25:12,000
它會特別在最後的\ 0字符。

343
00:25:12,000 --> 00:25:16,000
>> 您也可以設想一下，如果你有一個格式不正確的字符串

344
00:25:16,000 --> 00:25:20,000
有沒有\ 0字符，那麼整個事情並沒有工作。

345
00:25:20,000 --> 00:25:22,000
[學生]：你可以添加\ 0？

346
00:25:22,000 --> 00:25:24,000
我們可以在這種情況下。

347
00:25:24,000 --> 00:25:29,000
我們可以添加某種\ 0

348
00:25:29,000 --> 00:25:33,000
或某種標誌著字符，然後使用它。

349
00:25:33,000 --> 00:25:36,000
但是，這不太去上班

350
00:25:36,000 --> 00:25:40,000
因為\ 0是一個char類型，

351
00:25:40,000 --> 00:25:43,000
在這裡，我們有整數。

352
00:25:43,000 --> 00:25:46,000
另一件事是，如果我們要使用一個特殊的值

353
00:25:46,000 --> 00:25:49,000
像-1，以紀念數組末尾

354
00:25:49,000 --> 00:25:54,000
然後，我們永遠無法在我們的整數數組存儲-1。

355
00:25:54,000 --> 00:25:56,000
我們希望被卡住了。

356
00:25:56,000 --> 00:26:00,000
事實證明，只有這樣，才能得到長度

357
00:26:00,000 --> 00:26:03,000
實際上是一個數組在C記得它

358
00:26:03,000 --> 00:26:08,000
當你設置它，然後把它傳遞的陣列

359
00:26:08,000 --> 00:26:14,000
所以，每當我有一個函數，會做一些工作

360
00:26:14,000 --> 00:26:18,000
數組的整數或浮點數或雙打，你有什麼，

361
00:26:18,000 --> 00:26:22,000
我還需要給函數的數組的長度，

362
00:26:22,000 --> 00:26:26,000
這正是我們在這裡所做的搜索功能。

363
00:26:26,000 --> 00:26:30,000
如果你看一下，我們做了什麼，當我們通過在我們的數組，

364
00:26:30,000 --> 00:26:36,000
我們還通過在長度，尺寸。

365
00:26:36,000 --> 00:26:41,000
這恰好是我們把這種現象稱之為變量，

366
00:26:41,000 --> 00:26:43,000
此參數或參數。

367
00:26:43,000 --> 00:26:46,000
這就是所謂的一個函數的參數列表或參數列表，

368
00:26:46,000 --> 00:26:51,000
這些也稱為參數或參數。

369
00:26:51,000 --> 00:26:53,000
人們在不同的時間使用不同的術語。

370
00:26:53,000 --> 00:26:55,000
我有時會交換他們自己。

371
00:26:55,000 --> 00:27:00,000
碰巧的是，這裡被命名為這個變量同樣

372
00:27:00,000 --> 00:27:03,000
這定義在這裡。

373
00:27:03,000 --> 00:27:06,000
但他們不一樣的東西。

374
00:27:06,000 --> 00:27:11,000
資本化也很重要。

375
00:27:11,000 --> 00:27:14,000
>> 如果你看看這裡發生的事情，我們聲明

376
00:27:14,000 --> 00:27:18,000
我們的int數組，這是我們所撥打的電話號碼。

377
00:27:18,000 --> 00:27:23,000
我們已經給我們的規模，這相當於我們的＃定義在最頂端。

378
00:27:23,000 --> 00:27:27,000
這將是8。

379
00:27:27,000 --> 00:27:35,000
然後當我們再調用我們的搜索功能，下面，

380
00:27:35,000 --> 00:27:40,000
我們通過我們要搜索的數量，我們已經提示，

381
00:27:40,000 --> 00:27:43,000
從用戶得到。

382
00:27:43,000 --> 00:27:46,000
我們通過在陣列中，這個號碼，

383
00:27:46,000 --> 00:27:51,000
然後我們還必須通過在數組的大小，

384
00:27:51,000 --> 00:27:57,000
，然後該值被存儲大小為8

385
00:27:57,000 --> 00:28:01,000
或傳遞給這個整數變量稱為大小。

386
00:28:01,000 --> 00:28:08,000
我們有陣列的大小。

387
00:28:08,000 --> 00:28:11,000
現在，如果我們回到我們在談論什麼較早，

388
00:28:11,000 --> 00:28:14,000
我覺得大小姐長大一點，我們需要做的是得到數組的長度

389
00:28:14,000 --> 00:28:20,000
除以2，這將使我們的中點。

390
00:28:20,000 --> 00:28:22,000
讓我們來看看。

391
00:28:22,000 --> 00:28:25,000
我有別人寫這篇文章，並將其保存在自己的空間呢？

392
00:28:25,000 --> 00:28:27,000
萊拉怎麼樣？

393
00:28:27,000 --> 00:28:31,000
我能有你寫這篇文章？

394
00:28:31,000 --> 00:28:35,000
寫的第一行，你把數組的長度，得到的中點

395
00:28:35,000 --> 00:28:41,000
並將其存儲在一個新的變量。

396
00:28:41,000 --> 00:28:44,000
我給你幾秒鐘。你準備好了麼？

397
00:28:44,000 --> 00:28:46,000
[學生聽不清]

398
00:28:46,000 --> 00:28:50,000
當然，我有你計算的中點

399
00:28:50,000 --> 00:28:55,000
幹草堆數組裡面的搜索功能

400
00:28:55,000 --> 00:29:03,000
用幹草堆陣列的長度，這是變量的大小？

401
00:29:03,000 --> 00:29:08,000
這裡沒有什麼棘手的。

402
00:29:08,000 --> 00:29:12,000
萊拉]大小/ 2和剛剛

403
00:29:12,000 --> 00:29:17,000
並保存它，並點擊“保存”按鈕，在頂部上升，

404
00:29:17,000 --> 00:29:19,000
我們會拉起來。

405
00:29:19,000 --> 00:29:22,000
完美的。

406
00:29:22,000 --> 00:29:28,000
我們走吧。真棒。

407
00:29:28,000 --> 00:29:30,000
>> 是，編譯？

408
00:29:30,000 --> 00:29:32,000
[萊拉]沒有，它需要的要高。

409
00:29:32,000 --> 00:29:34,000
[內特]是啊，所以我們需要做什麼？

410
00:29:34,000 --> 00:29:36,000
[萊拉，如int的中點或什麼的。

411
00:29:36,000 --> 00:29:41,000
真棒。是啊，讓我們做到這一點，中點=大小。

412
00:29:41,000 --> 00:29:44,000
編譯？

413
00:29:44,000 --> 00:29:47,000
讓我們刪除這條評論，並把它弄出來的方式。

414
00:29:47,000 --> 00:29:50,000
究竟會不會編譯這件事？

415
00:29:50,000 --> 00:29:52,000
我們不會做任何事情的整數，

416
00:29:52,000 --> 00:29:55,000
因此，我們需要打印或類似的東西。

417
00:29:55,000 --> 00:29:58,000
是的，沒錯。

418
00:29:58,000 --> 00:30:00,000
我們會得到一個未使用的變量。

419
00:30:00,000 --> 00:30:02,000
還有什麼工作呢？

420
00:30:02,000 --> 00:30:06,000
我想你說了些什麼，山姆。分號。

421
00:30:06,000 --> 00:30:08,000
是的，我缺少的分號。

422
00:30:08,000 --> 00:30:14,000
這將是一個常數事情的整個過程的術語。

423
00:30:14,000 --> 00:30:17,000
我會做的最後一件事是，我把一些白色的空間，任何一方

424
00:30:17,000 --> 00:30:23,000
運營商在這裡，因為這通常是如何做到這一點

425
00:30:23,000 --> 00:30:26,000
根據我們的風格指南。

426
00:30:26,000 --> 00:30:29,000
我們有我們的數組的中點。

427
00:30:29,000 --> 00:30:32,000
現在，如果我們還記得我們的算法，

428
00:30:32,000 --> 00:30:37,000
第二步，我們不得不這樣做，一旦我們有中點是什麼？

429
00:30:37,000 --> 00:30:42,000
[學生]：如果它是大於[聽不清]。

430
00:30:42,000 --> 00:30:48,000
是啊，所以我們必須做一些比較，我們比較什麼？

431
00:30:48,000 --> 00:30:53,000
你說，如果它是大於。這是什麼那句話指的是？

432
00:30:53,000 --> 00:30:57,000
的數量，來了，如果這是大於中點，然後去到數組？

433
00:30:57,000 --> 00:31:05,000
沒錯，這樣的數字出現時，我們

434
00:31:05,000 --> 00:31:10,000
針，所以我們比較針，

435
00:31:10,000 --> 00:31:12,000
什麼是我們比較針嗎？

436
00:31:12,000 --> 00:31:15,000
因為針是我們要尋找的是什麼。

437
00:31:15,000 --> 00:31:18,000
我們在比較得到的中點。

438
00:31:18,000 --> 00:31:21,000
>> 但它是有意義的檢查，看看

439
00:31:21,000 --> 00:31:27,000
如果針=的中點？

440
00:31:27,000 --> 00:31:32,000
這是否有意義嗎？

441
00:31:32,000 --> 00:31:35,000
是否有人不同意嗎？

442
00:31:35,000 --> 00:31:40,000
讓我們給它一個嘗試，如果（針==中點）。

443
00:31:40,000 --> 00:31:42,000
[學生]：printf的你發現了它。

444
00:31:42,000 --> 00:31:51,000
[內特的printf（“我們發現了！\ n”）;

445
00:31:51,000 --> 00:31:56,000
否則，我要開始做不同的東西在這裡。

446
00:31:56,000 --> 00:32:00,000
我要開始把周圍所有的時間if語句的大括號

447
00:32:00,000 --> 00:32:05,000
只是因為，如果我們添加更多的東西，然後

448
00:32:05,000 --> 00:32:07,000
我們沒有得到的編譯器。

449
00:32:07,000 --> 00:32:09,000
是啊，山姆。你已經有了一個點。

450
00:32:09,000 --> 00:32:12,000
的問題是，中點表示在數組中的位置，

451
00:32:12,000 --> 00:32:15,000
但你可以得到它代表的價值在這個位置上的數組。

452
00:32:15,000 --> 00:32:17,000
這是一個很好的點。

453
00:32:17,000 --> 00:32:19,000
大家聽到山姆說什麼？

454
00:32:19,000 --> 00:32:22,000
他說，中點是

455
00:32:22,000 --> 00:32:28,000
只是在數組中的位置，但它不是實際的數組中的元素。

456
00:32:28,000 --> 00:32:30,000
如果你寫的代碼現在想想，

457
00:32:30,000 --> 00:32:35,000
如果我們看一下這裡，在這個數組有8個元素在裡面，

458
00:32:35,000 --> 00:32:39,000
中點要在這個函數中的價值是什麼？

459
00:32:39,000 --> 00:32:41,000
[學生]：4。

460
00:32:41,000 --> 00:32:45,000
[內特] 4。

461
00:32:45,000 --> 00:32:51,000
如果我們看一下數4  - 

462
00:32:51,000 --> 00:32:54,000
，我們可以運行此代碼，在這裡放一點點悲傷的臉

463
00:32:54,000 --> 00:32:58,000
因為我們沒有找到它，如果我們運行這個代碼

464
00:32:58,000 --> 00:33:04,000
是現在，上傳，建築，讓我向下滾動，

465
00:33:04,000 --> 00:33:09,000
如果我們看看數4，

466
00:33:09,000 --> 00:33:18,000
我們發現了它，但我們沒有得到這個輸出是。

467
00:33:18,000 --> 00:33:23,000
其中一個原因是，我們並沒有返回true，

468
00:33:23,000 --> 00:33:26,000
但當時我們真的找到4？

469
00:33:26,000 --> 00:33:28,000
和Sam說“不”。

470
00:33:28,000 --> 00:33:31,000
我們發現了什麼？

471
00:33:31,000 --> 00:33:35,000
我們真的找到了中點，如果我們看一下在陣列在這裡，

472
00:33:35,000 --> 00:33:38,000
這將是指數4，我們正在尋找的元素，

473
00:33:38,000 --> 00:33:42,000
這是23。

474
00:33:42,000 --> 00:33:46,000
>> 我們如何真正得到該元素的中點

475
00:33:46,000 --> 00:33:48,000
不只是中點本身嗎？

476
00:33:48,000 --> 00:33:52,000
[學生]：我們將輸入字符或什麼的？

477
00:33:52,000 --> 00:33:55,000
那麼，具體怎麼做，只是出於好奇嗎？

478
00:33:55,000 --> 00:33:57,000
你能否解釋一下嗎？

479
00:33:57,000 --> 00:34:02,000
您的位置轉換成數，

480
00:34:02,000 --> 00:34:05,000
所以你不得不做出一定的聯繫，我認為這是char，但它可能不是。

481
00:34:05,000 --> 00:34:07,000
是的，這是一個很好的點。

482
00:34:07,000 --> 00:34:12,000
我們已經做了很多這種轉換位置的字符，這些字符，

483
00:34:12,000 --> 00:34:14,000
前兩個問題集。

484
00:34:14,000 --> 00:34:18,000
事實證明，在這裡，這幾乎是類似的

485
00:34:18,000 --> 00:34:24,000
訪問第i個字符在字符串中，如果是有道理的。

486
00:34:24,000 --> 00:34:30,000
在這裡，我們要訪問的中點元素。

487
00:34:30,000 --> 00:34:34,000
我們如何做到這一點？

488
00:34:34,000 --> 00:34:39,000
凱文，你有什麼建議，我們怎麼可能做到這一點？

489
00:34:39,000 --> 00:34:44,000
你可以做幹草堆，開括號，中，右括號。

490
00:34:44,000 --> 00:34:46,000
你可以寫我們嗎？

491
00:34:46,000 --> 00:34:51,000
將它保存在這裡，我們會拉，直至。

492
00:34:51,000 --> 00:34:56,000
我們正在尋找在該行9，

493
00:34:56,000 --> 00:34:59,000
我們意識到，我們不想比較針的中點，

494
00:34:59,000 --> 00:35:03,000
但相反，我們要比較的針

495
00:35:03,000 --> 00:35:07,000
位置中點我們的草垛陣列內的元素。

496
00:35:07,000 --> 00:35:10,000
酷。

497
00:35:10,000 --> 00:35:12,000
我們走吧。

498
00:35:12,000 --> 00:35:15,000
是的，這看起來很不錯，如果（針==草垛[中點]）。

499
00:35:15,000 --> 00:35:18,000
我們發現了它。

500
00:35:18,000 --> 00:35:22,000
現在，如果我們運行的代碼 - 我們將備份一點點，

501
00:35:22,000 --> 00:35:26,000
編譯，運行，現在如果我們看一下4，

502
00:35:26,000 --> 00:35:30,000
我們沒有找到它，因為現在我們實際上獲得的23號。

503
00:35:30,000 --> 00:35:33,000
我們現在要值23，這是我們比較我們的針。

504
00:35:33,000 --> 00:35:35,000
但是，這是很好的。這是朝著正確的方向邁出的一步。

505
00:35:35,000 --> 00:35:37,000
>> 這就是我們想要做的。

506
00:35:37,000 --> 00:35:40,000
我們並不試圖對數組中的位置比較針

507
00:35:40,000 --> 00:35:44,000
而是針對實際的數組中的元素。

508
00:35:44,000 --> 00:35:49,000
如果我們現在再回頭看我們的算法中的下一個步驟，

509
00:35:49,000 --> 00:35:51,000
下一步是什麼？

510
00:35:51,000 --> 00:35:57,000
萊拉已經提到了簡要介紹。

511
00:35:57,000 --> 00:36:00,000
[學生]：檢查，看它是否大於或小於，然後決定哪個方向移動。

512
00:36:00,000 --> 00:36:03,000
[內特]是啊，所以我們會做什麼？

513
00:36:03,000 --> 00:36:07,000
你可以把一些 - 我本次修訂，

514
00:36:07,000 --> 00:36:13,000
然後，如果你把在一些線路，將這樣做。

515
00:36:13,000 --> 00:36:15,000
是啊，夏洛特。>>我有一個問題。

516
00:36:15,000 --> 00:36:19,000
難道不應該的第一件事就是中點 -  1，因為

517
00:36:19,000 --> 00:36:26,000
它的0索引，因此，如果我們把4，其實這不是我們要找的字符？

518
00:36:26,000 --> 00:36:30,000
是的，和其他的問題，即-

519
00:36:30,000 --> 00:36:35,000
這是一個偉大的漁獲量，因為正在發生的事情可能發生

520
00:36:35,000 --> 00:36:42,000
如果我們繼續前進，我們永遠不調整初始嗎？

521
00:36:42,000 --> 00:36:46,000
我猜我們可能最終做的是試圖訪問

522
00:36:46,000 --> 00:36:49,000
在第8位的數組元素，

523
00:36:49,000 --> 00:36:53,000
在這種情況下不存在。

524
00:36:53,000 --> 00:36:56,000
我們會想要做某種會計的事實

525
00:36:56,000 --> 00:36:59,000
我們有一些零的索引。

526
00:36:59,000 --> 00:37:05,000
[夏洛特]對不起，我的意思是在方括號中的中點 -  1。

527
00:37:05,000 --> 00:37:08,000
我們可以做到這一點。

528
00:37:08,000 --> 00:37:10,000
我們會回來的這個問題，在短短位。

529
00:37:10,000 --> 00:37:13,000
一旦我們開始得到了實際的循環，

530
00:37:13,000 --> 00:37:16,000
那個時候，我們真的會看到這是發揮。

531
00:37:16,000 --> 00:37:21,000
就目前而言，我們可以做到這一點，但你是完全正確的。

532
00:37:21,000 --> 00:37:28,000
零索引將產生影響，我們需要考慮的。

533
00:37:28,000 --> 00:37:30,000
讓我們來看看。

534
00:37:30,000 --> 00:37:34,000
>> 如何大於和小於？

535
00:37:34,000 --> 00:37:36,000
[學生]：我要怎麼弄了大於和小於部分。

536
00:37:36,000 --> 00:37:41,000
我只是不知道，如果你發現這是不到的草垛中點或大於打印內容。

537
00:37:41,000 --> 00:37:43,000
在這裡，我可以節省難不倒我，

538
00:37:43,000 --> 00:37:47,000
[內特]是啊，如果你保存你有什麼，我們就會把它。

539
00:37:47,000 --> 00:37:49,000
我們走吧。

540
00:37:49,000 --> 00:37:51,000
[學生]：我把問號是什麼我不知道。

541
00:37:51,000 --> 00:37:54,000
內特 - 這看上去很不錯。

542
00:37:54,000 --> 00:37:58,000
在這裡，我們已經得到了問號，因為我們仍然不知道

543
00:37:58,000 --> 00:38:06,000
我們要完全做到。

544
00:38:06,000 --> 00:38:12,000
我們希望，做哎呀，我們已經得到了一些大括號對我們的所有時髦的。

545
00:38:12,000 --> 00:38:15,000
我們會糾正這些大括號。

546
00:38:15,000 --> 00:38:19,000
我們走吧。

547
00:38:19,000 --> 00:38:22,000
還等什麼，我們想要做的，按照我們的算法，

548
00:38:22,000 --> 00:38:27,000
如果我們沒有發現針？

549
00:38:27,000 --> 00:38:32,000
的情況下，說針是小於我們正在尋找。凱文。

550
00:38:32,000 --> 00:38:34,000
只有看的左半邊。

551
00:38:34,000 --> 00:38:40,000
對，所以我們會把在這裡評論說：“看在左半邊。”

552
00:38:40,000 --> 00:38:46,000
如果針是大於幹草堆的中點處，我們想要做的嗎？

553
00:38:46,000 --> 00:38:48,000
[學生]：那你看右半邊。

554
00:38:48,000 --> 00:38:53,000
看右半邊，“看右半邊。”

555
00:38:53,000 --> 00:38:58,000
不能太寒酸。

556
00:38:58,000 --> 00:39:05,000
好了，所以在這一點上，東西都看起來相當不錯。

557
00:39:05,000 --> 00:39:13,000
寫的代碼的問題是什麼？

558
00:39:13,000 --> 00:39:15,000
[學生]：您沒有終點的一半。

559
00:39:15,000 --> 00:39:18,000
是的，我們沒有端點的一半。

560
00:39:18,000 --> 00:39:20,000
此外，我們也只有通過這一次要去。

561
00:39:20,000 --> 00:39:23,000
我們只是要在一個中點。

562
00:39:23,000 --> 00:39:27,000
無論是元素是存在的，或者它不是。

563
00:39:27,000 --> 00:39:34,000
為了完成這一目標，我們需要做某種形式的重複。

564
00:39:34,000 --> 00:39:39,000
我們需要不斷重複，直到我們找到

565
00:39:39,000 --> 00:39:43,000
無論是元素，因為我們已經縮小，終於找到了，

566
00:39:43,000 --> 00:39:46,000
，或者它不是在那裡，因為我們已經看遍了所有的事情，

567
00:39:46,000 --> 00:39:52,000
在適當半的陣列，發現在那裡，沒有什麼是。

568
00:39:52,000 --> 00:39:56,000
>> 每當我們已經有了這樣的重複，那我們該怎麼使用？

569
00:39:56,000 --> 00:39:58,000
[學生]：一個循環。

570
00:39:58,000 --> 00:40:00,000
某種形式的循環。是。

571
00:40:00,000 --> 00:40:03,000
[學生]：我們可以做一個do-whil​​e循環，有它這樣做，然後，

572
00:40:03,000 --> 00:40:10,000
針不相等的，我不知道我要去哪裡與。

573
00:40:10,000 --> 00:40:18,000
但有點像做，只要它不等於的值，用戶輸入。

574
00:40:18,000 --> 00:40:21,000
是啊，所以讓我們來看看，這怎麼可能寫出來嗎？

575
00:40:21,000 --> 00:40:23,000
你說讓我們使用一個do-whil​​e循環。

576
00:40:23,000 --> 00:40:26,000
在什麼地方開始？

577
00:40:26,000 --> 00:40:33,000
[學生]右後大小/ 2。

578
00:40:33,000 --> 00:40:42,000
[內特]好吧，什麼是我們該怎麼辦？

579
00:40:42,000 --> 00:40:44,000
我們將填寫後的一段時間。

580
00:40:44,000 --> 00:40:46,000
什麼是我們該怎麼辦？

581
00:40:46,000 --> 00:40:49,000
[學生]：你不是我們想要做的所有的東西，我們如果部分嗎？

582
00:40:49,000 --> 00:40:52,000
[內特]做了這一切東西，太棒了。

583
00:40:52,000 --> 00:40:55,000
複製和粘貼。

584
00:40:55,000 --> 00:40:59,000
哦，男人。

585
00:40:59,000 --> 00:41:03,000
讓我們來看看，如果這個工程，如果我們能“選項卡這種過度。

586
00:41:03,000 --> 00:41:08,000
美麗的。

587
00:41:08,000 --> 00:41:16,000
好了，我們保存，這樣你們。

588
00:41:16,000 --> 00:41:21,000
所有權利，我們將做到這一點，而

589
00:41:21,000 --> 00:41:25,000
而條件後是什麼？

590
00:41:25,000 --> 00:41:31,000
[學生]：當針不相等的，所以像驚嘆號。

591
00:41:31,000 --> 00:41:37,000
但我不知道到底是什麼還。

592
00:41:37,000 --> 00:41:39,000
[內特]是啊，這是一個辦法做到這一點。

593
00:41:39,000 --> 00:41:41,000
山姆，你有意見嗎？

594
00:41:41,000 --> 00:41:43,000
[三]我記得當我看著影片，

595
00:41:43,000 --> 00:41:48,000
我的截圖之一，像我們做的偽代碼時，

596
00:41:48,000 --> 00:41:52,000
最大值和最小值之間有一定的關係。

597
00:41:52,000 --> 00:41:58,000
我認為這是類似的東西如果max是永遠小於min。

598
00:41:58,000 --> 00:42:00,000
明白了。

599
00:42:00,000 --> 00:42:04,000
[三]想，如果最大不小於分鐘或類似的東西，

600
00:42:04,000 --> 00:42:06,000
因為這將意味著，您搜索過的一切。

601
00:42:06,000 --> 00:42:13,000
>> 是啊，所以它聽起來像最大值和最小值是指？

602
00:42:13,000 --> 00:42:16,000
[三]，整數的值，要改變

603
00:42:16,000 --> 00:42:18,000
相對於我們把中點。

604
00:42:18,000 --> 00:42:20,000
沒錯。

605
00:42:20,000 --> 00:42:24,000
[三]在這一點上，它是怎麼回事[聽不清]計算的最大值和最小值。

606
00:42:24,000 --> 00:42:29,000
中點這是最大和最小的想法。

607
00:42:29,000 --> 00:42:35,000
這是否有意義人嗎？

608
00:42:35,000 --> 00:42:39,000
如果我們要開始找我們要如何做到這一點迭代，

609
00:42:39,000 --> 00:42:43,000
你是完全正確的，我們要使用某種do-whil​​e循環。

610
00:42:43,000 --> 00:42:49,000
但我想，如果我們還記得發生了什麼事在這個數組當場

611
00:42:49,000 --> 00:42:53,000
，什麼是實際發生的事情，我會寫在這裡

612
00:42:53,000 --> 00:42:58,000
在第一次迭代的二進制搜索，我們有

613
00:42:58,000 --> 00:43:05,000
我要使用b和e來表示開始。

614
00:43:05,000 --> 00:43:10,000
我們的陣列，然後結束。

615
00:43:10,000 --> 00:43:14,000
我們知道，開始的時候是在4對在這裡，

616
00:43:14,000 --> 00:43:18,000
我們知道，到底是在108。

617
00:43:18,000 --> 00:43:23,000
說，我們正在尋找的15號。

618
00:43:23,000 --> 00:43:27,000
當我們第一次這樣做，就像我們前面看到的，

619
00:43:27,000 --> 00:43:30,000
中點將是16或23

620
00:43:30,000 --> 00:43:34,000
這取決於我們如何計算的事情了。

621
00:43:34,000 --> 00:43:37,000
由於等分的中間，給我們這個空間

622
00:43:37,000 --> 00:43:42,000
在16和23之間，我們不能整除它

623
00:43:42,000 --> 00:43:47,000
或者將其與一個真正的中點。

624
00:43:47,000 --> 00:43:49,000
我們將在16歲。

625
00:43:49,000 --> 00:43:55,000
我們將實現“嘿，16> 15，我們正在尋找的。”

626
00:43:55,000 --> 00:43:59,000
然後看陣列的左半邊

627
00:43:59,000 --> 00:44:03,000
我們最終會做什麼是丟棄

628
00:44:03,000 --> 00:44:07,000
這整個上部

629
00:44:07,000 --> 00:44:16,000
並說：“好了，現在我們的終點會到這裡來。”

630
00:44:16,000 --> 00:44:22,000
我們的循環的下一個迭代的，我們現在看這個數組，

631
00:44:22,000 --> 00:44:25,000
有效地捨棄這部分，因為現在

632
00:44:25,000 --> 00:44:30,000
如果我們的中點的開始和結束之間的差異，

633
00:44:30,000 --> 00:44:34,000
我們發現我們的中點為8，

634
00:44:34,000 --> 00:44:40,000
然後，我們可以測試，看看它是關係到我們正在尋找數，

635
00:44:40,000 --> 00:44:44,000
15日，有15個是更大的，

636
00:44:44,000 --> 00:44:49,000
所以我們必須要移動到列表中的右邊部分，

637
00:44:49,000 --> 00:44:51,000
我們知道，因為我們是人類，我們可以看到它。

638
00:44:51,000 --> 00:44:54,000
我們知道，右側部分將是我們在那裡找到它，

639
00:44:54,000 --> 00:45:01,000
但電腦不知道這一點，所以我們要做的是，我們實際上

640
00:45:01,000 --> 00:45:04,000
已經上去了，現在開始和結束

641
00:45:04,000 --> 00:45:11,000
是相同的點的中點，所以成為在這一點上的列表中的唯一編號，

642
00:45:11,000 --> 00:45:16,000
這是15日，我們已經找到了。

643
00:45:16,000 --> 00:45:21,000
這是否透露​​了一些關於這整個的最大和最小的符號是怎麼回事，

644
00:45:21,000 --> 00:45:24,000
跟踪的端點的數組，以便找出

645
00:45:24,000 --> 00:45:35,000
如何縮小東西下來？

646
00:45:35,000 --> 00:45:42,000
>> 如果這是不等於15，會發生什麼？

647
00:45:42,000 --> 00:45:52,000
如果我們一直在尋找，這個數字是15，而不是16嗎？

648
00:45:52,000 --> 00:45:54,000
我們會說，“哦，這是更大的。

649
00:45:54,000 --> 00:45:57,000
我們要回去的左邊。“

650
00:45:57,000 --> 00:46:01,000
我們將我們的電子的權利，

651
00:46:01,000 --> 00:46:06,000
在這一點上，我們有一個端點，是相互矛盾的。

652
00:46:06,000 --> 00:46:09,000
這不會是能夠搜索到任何更多的元素

653
00:46:09,000 --> 00:46:13,000
因為現在我們有我們的端點和我們的起點，

654
00:46:13,000 --> 00:46:16,000
我們的最大和我們的分，現在翻轉。

655
00:46:16,000 --> 00:46:23,000
我們搜索整個陣列。我們無法找到任何東西。

656
00:46:23,000 --> 00:46:27,000
這一點上，我們會說，“好了，我們要制止這種算法。

657
00:46:27,000 --> 00:46:34,000
我們沒有發現任何東西。我們知道這是不是在這裡。“

658
00:46:34,000 --> 00:46:36,000
這是怎麼回事呢？

659
00:46:36,000 --> 00:46:40,000
[學生]：電腦的開關究竟是如何結束了嗎？

660
00:46:40,000 --> 00:46:45,000
如何結束前開始嗎？

661
00:46:45,000 --> 00:46:48,000
結束前開始

662
00:46:48,000 --> 00:46:54,000
因為，我們要做的每次我們這樣做的數學。

663
00:46:54,000 --> 00:47:00,000
我們交換的方式是，如果你的第一次，我們這樣做交換

664
00:47:00,000 --> 00:47:03,000
在那裡我們有在4的開頭和結尾

665
00:47:03,000 --> 00:47:13,000
所有的方式，在108和我們的中點，也就是說，在16  - 

666
00:47:13,000 --> 00:47:20,000
我要重置回15，如果我們正在尋找的15個，

667
00:47:20,000 --> 00:47:25,000
我們知道我們做了什麼，當我們檢查了16看到，這是更大的

668
00:47:25,000 --> 00:47:28,000
想放棄整個右半部分的列表，

669
00:47:28,000 --> 00:47:36,000
我們看到什麼，我們想要做的是將這個電子就在這裡。

670
00:47:36,000 --> 00:47:44,000
實際上，電子轉移到了之前的中點。

671
00:47:44,000 --> 00:47:48,000
同樣，當我們這樣做的算法迭代

672
00:47:48,000 --> 00:47:51,000
和中點是在8，

673
00:47:51,000 --> 00:47:55,000
我們發現，8 <15，所以我們希望移動的b

674
00:47:55,000 --> 00:48:00,000
過去的中點。

675
00:48:00,000 --> 00:48:07,000
現在，始端和末端都在這15一起。

676
00:48:07,000 --> 00:48:10,000
>> 如果我們已經發生的事情，尋找一些其他的價值，而不是15，

677
00:48:10,000 --> 00:48:14,000
如果這15而不是16，

678
00:48:14,000 --> 00:48:20,000
我們會發現，E，我們要移動前的中點。

679
00:48:20,000 --> 00:48:33,000
電子翻轉少於B。

680
00:48:33,000 --> 00:48:39,000
讓我們通過我們實際上如何結束這種編碼算法。

681
00:48:39,000 --> 00:48:44,000
我們知道，我們希望有這樣的中點計算。

682
00:48:44,000 --> 00:48:48,000
我們也知道，我們要跟踪的開頭和結尾的數組

683
00:48:48,000 --> 00:48:51,000
我們目前的陣列，所以我們可以計算出

684
00:48:51,000 --> 00:48:56,000
這個列表的左半和右半列表。

685
00:48:56,000 --> 00:49:03,000
我們做到這一點的開始和結束，

686
00:49:03,000 --> 00:49:07,000
或者我們可以給他們打電話的最小值和最大值。

687
00:49:07,000 --> 00:49:10,000
我將使用開始和結束時間。

688
00:49:10,000 --> 00:49:15,000
當我們開始之前，如果我們回頭看，我們的例子中，在這裡，

689
00:49:15,000 --> 00:49:20,000
我們一開始就被設定為一開始的數組，是自然的。

690
00:49:20,000 --> 00:49:25,000
什麼樣的指標是這樣的嗎？我們開始可以嗎？

691
00:49:25,000 --> 00:49:27,000
丹尼爾。

692
00:49:27,000 --> 00:49:30,000
[丹尼爾]的幹草堆[0]。

693
00:49:30,000 --> 00:49:37,000
[內特]是啊，所以我們可以設置它等於幹草堆[0]。

694
00:49:37,000 --> 00:49:40,000
，不過，問題是，這給我們的第一個元素的位置。

695
00:49:40,000 --> 00:49:45,000
它給我們的第一個元素或實際值，第一個位置的索引。

696
00:49:45,000 --> 00:49:47,000
[學生]：這將轉換為0.20？

697
00:49:47,000 --> 00:49:52,000
內特 - 這將是孔，它不會做任何的皈依。

698
00:49:52,000 --> 00:49:56,000
它會做的，是將存儲4開始，

699
00:49:56,000 --> 00:49:59,000
那麼這將是很難進行比較，對開始

700
00:49:59,000 --> 00:50:03,000
因為BEGIN將持有的價值4，

701
00:50:03,000 --> 00:50:06,000
這是我們的數組的開始，

702
00:50:06,000 --> 00:50:08,000
但我們要跟踪的指數數組中的

703
00:50:08,000 --> 00:50:11,000
相反的值。

704
00:50:11,000 --> 00:50:17,000
實際上，我們將使用0，這樣的。

705
00:50:17,000 --> 00:50:20,000
對於最終的陣列夏洛特帶來了這起得更早一點。

706
00:50:20,000 --> 00:50:23,000
這是我們會考慮到零的索引。

707
00:50:23,000 --> 00:50:25,000
>> 夏洛特，什麼是數組末尾的嗎？

708
00:50:25,000 --> 00:50:28,000
什麼是指數結束？

709
00:50:28,000 --> 00:50:30,000
[夏洛特]  -  1。

710
00:50:30,000 --> 00:50:32,000
是啊，它的大小，我們應該使用？

711
00:50:32,000 --> 00:50:35,000
我們應該使用資金規模或小寫的大小？

712
00:50:35,000 --> 00:50:37,000
資本的大小。

713
00:50:37,000 --> 00:50:42,000
在這種情況下，我們可以利用資金規模。

714
00:50:42,000 --> 00:50:45,000
如果我們希望這個函數是可移植的

715
00:50:45,000 --> 00:50:48,000
在其他程序中使用此功能，

716
00:50:48,000 --> 00:50:50,000
實際上，我們可以使用小寫字母的大小。

717
00:50:50,000 --> 00:50:52,000
這是一件好事。

718
00:50:52,000 --> 00:51:01,000
但夏洛特是完全正確的，我們希望有大小 -  1。

719
00:51:01,000 --> 00:51:03,000
在這點

720
00:51:03,000 --> 00:51:05,000
[學生]：它是如何，你可以使用大寫的大小嗎？

721
00:51:05,000 --> 00:51:07,000
它是如何，我們可以使用大寫的大小嗎？

722
00:51:07,000 --> 00:51:13,000
事實證明，這些＃定義是真的，

723
00:51:13,000 --> 00:51:19,000
引擎蓋下，一個文本，如查找和替換，如果是有道理的。

724
00:51:19,000 --> 00:51:24,000
當你編譯你的代碼，預處理階段

725
00:51:24,000 --> 00:51:27,000
編譯器通過文件，

726
00:51:27,000 --> 00:51:31,000
它看起來無處不在，你寫的資金規模，

727
00:51:31,000 --> 00:51:39,000
它取代這些文字的字面與8，就這樣。

728
00:51:39,000 --> 00:51:42,000
從這個意義上說，這是非常不同的變量。

729
00:51:42,000 --> 00:51:45,000
它不佔用任何內存空間。

730
00:51:45,000 --> 00:51:52,000
這是一個簡單的文本替換技巧。

731
00:51:52,000 --> 00:51:57,000
在這種情況下，我們將要使用的大小。

732
00:51:57,000 --> 00:52:01,000
在這裡，我們想這樣做某種形式的重複，

733
00:52:01,000 --> 00:52:03,000
我們在正確的軌道上，與我們的do-whil​​e循環。

734
00:52:03,000 --> 00:52:08,000
我們想要做的事，直到條件不成立了，

735
00:52:08,000 --> 00:52:12,000
正如我們前面所看到的，我們看到，該條件

736
00:52:12,000 --> 00:52:19,000
的確，我們不希望最終

737
00:52:19,000 --> 00:52:24,000
是小於的開始。

738
00:52:24,000 --> 00:52:26,000
>> 這是我們的停止條件。

739
00:52:26,000 --> 00:52:35,000
如果發生這種情況，我們要停止，並宣布，“嘿，我們沒有發現任何東西。”

740
00:52:35,000 --> 00:52:43,000
為了表達這一點，我們要使用某種形式的循環。

741
00:52:43,000 --> 00:52:49,000
在這種情況下，它是一個do-whil​​e循環，for循環，while循環？

742
00:52:49,000 --> 00:52:51,000
在這裡我們有一個do-whil​​e循環。

743
00:52:51,000 --> 00:52:53,000
你們這樣的方法嗎？

744
00:52:53,000 --> 00:52:59,000
你認為我們應該嘗試不同的方法嗎？

745
00:52:59,000 --> 00:53:01,000
凱文，有什麼想法嗎？

746
00:53:01,000 --> 00:53:06,000
我們可以有一個while循環，因為我們知道最大

747
00:53:06,000 --> 00:53:11,000
將比開始不管怎麼說分鐘。

748
00:53:11,000 --> 00:53:14,000
是啊，所以沒有初始化，需要做的。

749
00:53:14,000 --> 00:53:17,000
這些do-whil​​e循環是偉大的，當你要初始化的東西

750
00:53:17,000 --> 00:53:21,000
在此之前的測試，而在這裡

751
00:53:21,000 --> 00:53:26,000
我們知道，我們不打算再繼續重新初始化開始和結束

752
00:53:26,000 --> 00:53:28,000
每一輪的循環。

753
00:53:28,000 --> 00:53:32,000
我們知道，我們要對其進行初始化，然後檢查我們的條件。

754
00:53:32,000 --> 00:53:38,000
在這種情況下，實際上，我會用一個簡單的while循環中去。

755
00:53:38,000 --> 00:53:44,000
事實證明，do-whil​​e循環是相當不經常使用。

756
00:53:44,000 --> 00:53:49,000
很多地方甚至不教不while循環。

757
00:53:49,000 --> 00:53:53,000
他們是很好的處理用戶輸入，因此迄今為止我們已經看到了很多人。

758
00:53:53,000 --> 00:53:59,000
但正常的，while循環，也有很多比較常見的。

759
00:53:59,000 --> 00:54:03,000
事實證明，這種情況書面

760
00:54:03,000 --> 00:54:09,000
不會真的對我們很有好處，這是為什麼呢？

761
00:54:09,000 --> 00:54:11,000
對不起，我不知道你的名字。

762
00:54:11,000 --> 00:54:13,000
我傑里。>>對不起嗎？

763
00:54:13,000 --> 00:54:15,000
這是B-O-R-U-I。

764
00:54:15,000 --> 00:54:18,000
哦，好吧。

765
00:54:18,000 --> 00:54:23,000
我看不到你，我的名單上。

766
00:54:23,000 --> 00:54:26,000
哦，這是因為，哦，這是有道理的。

767
00:54:26,000 --> 00:54:31,000
你有一個想法，這個while循環的原因可能無法按預期，

768
00:54:31,000 --> 00:54:38,000
寫的條件嗎？

769
00:54:38,000 --> 00:54:43,000
[傑里，你的意思是你想要的所有東西後，它的？

770
00:54:43,000 --> 00:54:46,000
是啊，所以這是一個。

771
00:54:46,000 --> 00:54:49,000
我們可能需要把所有的這些東西進入while循環，這是完全正確的。

772
00:54:49,000 --> 00:54:55,000
其他的事情，不過，這是一個有點比較麻煩的是，這種情況不工作。

773
00:54:55,000 --> 00:54:57,000
[學生]：您需要翻轉。

774
00:54:57,000 --> 00:55:04,000
對，所以這種情況將不會是真實的最初因為我們談論的方式。

775
00:55:04,000 --> 00:55:08,000
我們想要做的事，直到結束<開始，

776
00:55:08,000 --> 00:55:13,000
但我們想要做的東西，而

777
00:55:13,000 --> 00:55:21,000
開始≤年底。

778
00:55:21,000 --> 00:55:24,000
>> 還有，反轉的邏輯。

779
00:55:24,000 --> 00:55:27,000
我犯了這些錯誤的時間。

780
00:55:27,000 --> 00:55:31,000
[學生]：為什麼必須小於或等於？

781
00:55:31,000 --> 00:55:33,000
因為你還記得的情況下，我們得到了

782
00:55:33,000 --> 00:55:36,000
那裡只有一個元素，我們比下降，

783
00:55:36,000 --> 00:55:43,000
我們正在尋找在數組中的15？

784
00:55:43,000 --> 00:55:47,000
我們的開始和結束都是一樣的元素。

785
00:55:47,000 --> 00:55:50,000
我們要確保我們處理這種情況。

786
00:55:50,000 --> 00:55:54,000
如果我們做了一個直不到，

787
00:55:54,000 --> 00:55:58,000
我們將只能得到2個元素的數組。

788
00:55:58,000 --> 00:56:06,000
一旦我們得到了下來，最後一個元素，如果這是我們的元素，我們永遠也找不到它。

789
00:56:06,000 --> 00:56:10,000
現在，在這裡，我們可以做的正是像你說的話。

790
00:56:10,000 --> 00:56:15,000
我們可以開始撲通東西，到我們的while循環中。

791
00:56:15,000 --> 00:56:20,000
我們可以撲通一聲在我們的中點。

792
00:56:20,000 --> 00:56:24,000
我們可以把所有這些if語句，

793
00:56:24,000 --> 00:56:30,000
將它們拉出來的這do-whil​​e循環，

794
00:56:30,000 --> 00:56:34,000
撲通一聲，

795
00:56:34,000 --> 00:56:39,000
乾淨的東西一點點，

796
00:56:39,000 --> 00:56:48,000
，我會繼續保存本次修訂。

797
00:56:48,000 --> 00:56:53,000
在這一點上，我們已經很接近了。

798
00:56:53,000 --> 00:56:55,000
山姆。

799
00:56:55,000 --> 00:56:58,000
我想你也必須有int中點，=大小 -  1/2。

800
00:56:58,000 --> 00:57:01,000
明白了，大小 -  1/2。

801
00:57:01,000 --> 00:57:05,000
我們需要改變該行的還有什麼呢？

802
00:57:05,000 --> 00:57:10,000
這是一個很好的漁獲物。

803
00:57:10,000 --> 00:57:14,000
>> 大小做什麼呢？我們不斷變化的大小嗎？

804
00:57:14,000 --> 00:57:17,000
為了保持這樣的線，我們要改變的大小。

805
00:57:17,000 --> 00:57:21,000
我們每次去周圍的循環，我們必須改變大小。

806
00:57:21,000 --> 00:57:25,000
但是，請記住，當我們將通過我們的例子只是一點點，

807
00:57:25,000 --> 00:57:30,000
我們開始在4

808
00:57:30,000 --> 00:57:33,000
結束在108一路過來嗎？

809
00:57:33,000 --> 00:57:35,000
我們是如何計算的中點？

810
00:57:35,000 --> 00:57:38,000
我們使用的大小？

811
00:57:38,000 --> 00:57:40,000
我們使用的開始和結束，而不是嗎？

812
00:57:40,000 --> 00:57:42,000
它的結束和開始之間的差異。

813
00:57:42,000 --> 00:57:50,000
沒錯，究竟如何，我應該寫，夏洛特？

814
00:57:50,000 --> 00:57:52,000
剛剛結束“ - ”開始“。

815
00:57:52,000 --> 00:57:55,000
你不會需要做的 -  1

816
00:57:55,000 --> 00:57:58,000
因為 -  1已包含在最終並已開始。

817
00:57:58,000 --> 00:58:00,000
[內特]太好了，你是完全正確的。

818
00:58:00,000 --> 00:58:03,000
我們沒有做 -  1  -  1已被列入

819
00:58:03,000 --> 00:58:08,000
並佔當我們初始化結束變量。

820
00:58:08,000 --> 00:58:11,000
>> 還有什麼我需要做的語法有這條線是有意義嗎？

821
00:58:11,000 --> 00:58:13,000
[學生]：加開始。加上開始的呢？

822
00:58:13,000 --> 00:58:15,000
[學生]：在最後。

823
00:58:15,000 --> 00:58:20,000
因為它只是計算一​​半的長度。

824
00:58:20,000 --> 00:58:26,000
您需要添加的開始。

825
00:58:26,000 --> 00:58:31,000
[內特]這算什麼我們？

826
00:58:31,000 --> 00:58:35,000
如果我們想結束這個循環迭代，

827
00:58:35,000 --> 00:58:40,000
到底是怎麼回事，是在第7的位置索引。

828
00:58:40,000 --> 00:58:43,000
開始的位置為0。

829
00:58:43,000 --> 00:58:47,000
請記住，我們正在尋找任何

830
00:58:47,000 --> 00:58:52,000
位置3或4的位置。

831
00:58:52,000 --> 00:58:56,000
如果我們看一下這道數學，只是為了使這一點更有形，

832
00:58:56,000 --> 00:59:02,000
在這裡把一些數字，我們有7，0，

833
00:59:02,000 --> 00:59:10,000
7  -  0，然後/ 2

834
00:59:10,000 --> 00:59:19,000
3整數除法，那是。

835
00:59:19,000 --> 00:59:26,000
那麼我們需要再添加回我們的開始嗎？

836
00:59:26,000 --> 00:59:28,000
在這種情況下，我們不。

837
00:59:28,000 --> 00:59:31,000
在第一次迭代中，這將是罰款，因為BEGIN為0。

838
00:59:31,000 --> 00:59:36,000
但是，我們的進步，我們真的只需要

839
00:59:36,000 --> 00:59:42,000
結束 - 開始/ 2。

840
00:59:42,000 --> 00:59:46,000
這裡還有另外一個絕招，那就是即一個優先級。

841
00:59:46,000 --> 00:59:49,000
[學生]：我們需要括號？

842
00:59:49,000 --> 00:59:53,000
[內特]沒錯，這是因為，如果我們不把這些括號，

843
00:59:53,000 --> 00:59:58,000
那麼這條線將被解釋，而不是

844
00:59:58,000 --> 01:00:09,000
（完） - （開始/ 2），這是我們絕對不希望。

845
01:00:09,000 --> 01:00:11,000
對於那些優先級規則。

846
01:00:11,000 --> 01:00:15,000
[學生]：為什麼不是結束+開始的呢？

847
01:00:15,000 --> 01:00:17,000
為什麼它沒有結束“+”開始“？

848
01:00:17,000 --> 01:00:19,000
[學生]：為什麼不說？

849
01:00:19,000 --> 01:00:24,000
為什麼會+？

850
01:00:24,000 --> 01:00:26,000
我想你是對的。

851
01:00:26,000 --> 01:00:28,000
[學生]：因為它的平均？

852
01:00:28,000 --> 01:00:31,000
[內特]末開始，你是完全正確的。

853
01:00:31,000 --> 01:00:34,000
哇，我完全弄錯了。你說得對。

854
01:00:34,000 --> 01:00:39,000
如果我們在做減，我們將要添加的開始。互動式

855
01:00:39,000 --> 01:00:43,000
在這種情況下，你是非常正確的，我們要採取平均兩個，

856
01:00:43,000 --> 01:00:45,000
所以我們要加入他們，而不是減去它們。

857
01:00:45,000 --> 01:00:49,000
[學生]：這也將工作，如果你真的結束 - 開始/ 2 +開始。

858
01:00:49,000 --> 01:00:55,000
如果我們這樣做，我相信。

859
01:00:55,000 --> 01:01:00,000
>> 例如，如果我們在開始時，

860
01:01:00,000 --> 01:01:04,000
而我們這裡轉移，

861
01:01:04,000 --> 01:01:08,000
15。

862
01:01:08,000 --> 01:01:12,000
現在開始在位置2。

863
01:01:12,000 --> 01:01:15,000
到底是在第7位。

864
01:01:15,000 --> 01:01:21,000
如果我們減去它們，我們可以得到5。

865
01:01:21,000 --> 01:01:24,000
除以2，得2。

866
01:01:24,000 --> 01:01:27,000
然後，我們加2，

867
01:01:27,000 --> 01:01:30,000
並因此獲得第4的位置，

868
01:01:30,000 --> 01:01:33,000
就在這裡，這是中點。

869
01:01:33,000 --> 01:01:36,000
[學生]：我們需要照顧的包裝嗎？

870
01:01:36,000 --> 01:01:39,000
在何種意義上，我們需要照顧的包裝嗎？

871
01:01:39,000 --> 01:01:43,000
如果總和或之間的區別

872
01:01:43,000 --> 01:01:45,000
這取決於我們如何做到這一點是不是偶數。

873
01:01:45,000 --> 01:01:49,000
然後，計算機會感到困惑是否當的2.5;

874
01:01:49,000 --> 01:01:52,000
你移動到左邊或有權決定的中點？

875
01:01:52,000 --> 01:01:54,000
明白了。

876
01:01:54,000 --> 01:01:56,000
事實證明，與整數除法，

877
01:01:56,000 --> 01:01:59,000
我們永遠不要讓這些浮點數。

878
01:01:59,000 --> 01:02:01,000
我們從來沒有得到小數。

879
01:02:01,000 --> 01:02:04,000
這是完全丟棄。

880
01:02:04,000 --> 01:02:08,000
如果你有一台電腦分兩個int變量，

881
01:02:08,000 --> 01:02:11,000
一個是7，和另一個是2，

882
01:02:11,000 --> 01:02:13,000
你不會得到3.5的結果。

883
01:02:13,000 --> 01:02:16,000
它會得到3。

884
01:02:16,000 --> 01:02:19,000
其餘部分將被丟棄，所以它是有效的舍入

885
01:02:19,000 --> 01:02:24,000
不是圓形，而是一個樓層，如果你們是熟悉的，在數學，

886
01:02:24,000 --> 01:02:27,000
你完全放棄小數，

887
01:02:27,000 --> 01:02:31,000
所以你基本上截斷它下調至最接近的

888
01:02:31,000 --> 01:02:33,000
整個位置，最接近的整數。

889
01:02:33,000 --> 01:02:38,000
[學生]：但是，這是有問題的，因為如果你有7個元素的數組

890
01:02:38,000 --> 01:02:43,000
然後，自動將第三個元素的中點，而不是第4。

891
01:02:43,000 --> 01:02:46,000
我們該如何處理呢？

892
01:02:46,000 --> 01:02:49,000
這是有問題的，因為如果我們有一個數組中的7，

893
01:02:49,000 --> 01:02:54,000
它會選擇，而不是第3第4。

894
01:02:54,000 --> 01:02:56,000
你能解釋一下嗎？

895
01:02:56,000 --> 01:02:59,000
[學生]：因為如果你有7個元素，那麼第4個元素

896
01:02:59,000 --> 01:03:04,000
的中點，對不對？

897
01:03:04,000 --> 01:03:07,000
零的索引，請記住您的評論。

898
01:03:07,000 --> 01:03:10,000
[學生]：是的，所以在位置3。這將是中點。

899
01:03:10,000 --> 01:03:12,000
是啊。

900
01:03:12,000 --> 01:03:16,000
哦，好吧。我明白你的意思。

901
01:03:16,000 --> 01:03:19,000
這是一種奇怪的，因為我們習慣了這整個概念

902
01:03:19,000 --> 01:03:22,000
擺脫小數。

903
01:03:22,000 --> 01:03:26,000
這是一個很好的點。

904
01:03:26,000 --> 01:03:30,000
讓我們來完成這件事。

905
01:03:30,000 --> 01:03:32,000
我們計算過我們的中點。

906
01:03:32,000 --> 01:03:37,000
>> 我們正在測試，看看我們的針是等於中間值。

907
01:03:37,000 --> 01:03:41,000
我們要打印，我們發現了它，但說真的，在這種情況下，我們想要做的是什麼呢？

908
01:03:41,000 --> 01:03:46,000
我們已經找到了，所以我們希望讓來電者知道，我們發現它。

909
01:03:46,000 --> 01:03:49,000
我們已經有了一個功能，是一個布爾類型的函數。

910
01:03:49,000 --> 01:03:54,000
WE信號的方式向我們的函數的調用者，我們已經準備好

911
01:03:54,000 --> 01:03:58,000
我們說：“嘿，這是真的。”

912
01:03:58,000 --> 01:04:00,000
我們將如何做到這一點，凱文？

913
01:04:00,000 --> 01:04:02,000
你點頭你的頭。>> [凱文]返回true。

914
01:04:02,000 --> 01:04:06,000
[內特]沒錯，返回true。

915
01:04:06,000 --> 01:04:12,000
現在，如果它是不相等的，怎麼會看的左半邊嗎？

916
01:04:12,000 --> 01:04:16,000
有什麼想法？

917
01:04:16,000 --> 01:04:18,000
斯特拉，任何想法？

918
01:04:18,000 --> 01:04:21,000
您需要設置一個新的位置結束。

919
01:04:21,000 --> 01:04:23,000
是啊。

920
01:04:23,000 --> 01:04:29,000
所以，我們要做的中點位置 - 結束。

921
01:04:29,000 --> 01:04:33,000
大。

922
01:04:33,000 --> 01:04:36,000
我們需要建立一個新的位置結束

923
01:04:36,000 --> 01:04:38,000
看的左半邊。

924
01:04:38,000 --> 01:04:41,000
這就是我們談到了之前在那裡

925
01:04:41,000 --> 01:04:44,000
我要回這個例子。

926
01:04:44,000 --> 01:04:50,000
我已經在這裡開始，然後我結束所有來這裡的路上。

927
01:04:50,000 --> 01:04:53,000
>> 同樣，如果我們要找的15，我們的中點是在16，

928
01:04:53,000 --> 01:04:56,000
我們認識到，“哎呀，16。

929
01:04:56,000 --> 01:04:59,000
我們要移動到左邊的一半。“

930
01:04:59,000 --> 01:05:02,000
然後，我們將移動到15月底，

931
01:05:02,000 --> 01:05:06,000
我們這樣做的一個距離的中點

932
01:05:06,000 --> 01:05:09,000
並設置作為我們新的結束。

933
01:05:09,000 --> 01:05:12,000
同樣，如果我們想看看在適當的一半，如何將我們做到這一點呢？

934
01:05:12,000 --> 01:05:14,000
你有一個想法？

935
01:05:14,000 --> 01:05:22,000
[學生]：您剛才設置開始的中點+ 1。

936
01:05:22,000 --> 01:05:24,000
[內特大。

937
01:05:24,000 --> 01:05:29,000
現在的情況，我們沒有發現任何東西，

938
01:05:29,000 --> 01:05:32,000
得到悉心照顧我們嗎？

939
01:05:32,000 --> 01:05:36,000
丹尼爾，這是否得到照顧我們嗎？

940
01:05:36,000 --> 01:05:38,000
[丹尼爾]第

941
01:05:38,000 --> 01:05:40,000
[內特]如果我們把整個數組，我們沒有發現任何東西，

942
01:05:40,000 --> 01:05:42,000
，照顧，我們還是應該照顧？

943
01:05:42,000 --> 01:05:44,000
[丹尼爾]，而條件。

944
01:05:44,000 --> 01:05:48,000
[內特]是啊，while條件，準確。

945
01:05:48,000 --> 01:05:51,000
如果我們沒有發現任何東西，它會照顧整個數組。

946
01:05:51,000 --> 01:05:53,000
這個while循環將結束。

947
01:05:53,000 --> 01:05:56,000
我們從來沒有遇到過這種狀況，

948
01:05:56,000 --> 01:06:03,000
我們可以返回false。

949
01:06:03,000 --> 01:06:10,000
我們也可以離開這一點，如果這樣的在這裡

950
01:06:10,000 --> 01:06:14,000
因為如果這個說法是正確的，

951
01:06:14,000 --> 01:06:16,000
和我們函數將返回，

952
01:06:16,000 --> 01:06:21,000
因此，我們將基本上取消該功能，在這一點上

953
01:06:21,000 --> 01:06:24,000
當我們返回true。

954
01:06:24,000 --> 01:06:28,000
但這種結構會發生什麼呢？

955
01:06:28,000 --> 01:06:34,000
這項工作完全，或者是有一些邏輯上的缺陷在那裡？

956
01:06:34,000 --> 01:06:37,000
>> 在那裡有一些邏輯上的缺陷，它的設立的方式。

957
01:06:37,000 --> 01:06:40,000
它可能是什麼？

958
01:06:40,000 --> 01:06:43,000
[學生]：為什麼你需要 - 和+ 1秒？

959
01:06:43,000 --> 01:06:47,000
我們的陣列設置，是我們新的左半部和右半。

960
01:06:47,000 --> 01:06:51,000
[學生]：但是，為什麼你不能做到這一點不 -  1和+ 1秒？

961
01:06:51,000 --> 01:06:53,000
[內特]我們可以設置它等於中點？

962
01:06:53,000 --> 01:07:04,000
有關，可能是什麼問題？

963
01:07:04,000 --> 01:07:08,000
[學生]：我想這是低效的，因為你正在檢查已檢查的值的。

964
01:07:08,000 --> 01:07:11,000
[內特]沒錯，所以山姆是完全正確的。

965
01:07:11,000 --> 01:07:15,000
如果您設置的結束和開始的中點

966
01:07:15,000 --> 01:07:18,000
 -  1 + 1沉思，

967
01:07:18,000 --> 01:07:22,000
在一些點在未來，我們將最終再次檢查的中點。

968
01:07:22,000 --> 01:07:26,000
[學生]：我開始在pset，然後我有類似的東西

969
01:07:26,000 --> 01:07:30,000
我忘了+ 1，它被卡在一個無限循環。

970
01:07:30,000 --> 01:07:34,000
是的，因為在某些時候，你永遠不會得到的開始和結束

971
01:07:34,000 --> 01:07:39,000
實際上是重疊的。

972
01:07:39,000 --> 01:07:41,000
酷。

973
01:07:41,000 --> 01:07:44,000
還有一個更合乎邏輯的缺陷，那就是，這絕對是

974
01:07:44,000 --> 01:07:48,000
一個else if。

975
01:07:48,000 --> 01:07:55,000
為什麼會這樣呢？

976
01:07:55,000 --> 01:07:59,000
>> 原因是如果它不是別的，如果你看到它，凱文？

977
01:07:59,000 --> 01:08:02,000
[凱文]是啊，因為你改變的終點。

978
01:08:02,000 --> 01:08:05,000
[內特]沒錯。

979
01:08:05,000 --> 01:08:07,000
我們正在改變端點，

980
01:08:07,000 --> 01:08:12,000
，如果它寫這樣我們就會使空間之間的

981
01:08:12,000 --> 01:08:14,000
它會檢查這種情況。

982
01:08:14,000 --> 01:08:18,000
這種情況下，如果成功，將中止的功能。

983
01:08:18,000 --> 01:08:21,000
然後，它會檢查這個情況下，

984
01:08:21,000 --> 01:08:24,000
如果成功，將調整的終結點，

985
01:08:24,000 --> 01:08:28,000
，然後它會繼續檢查這種情況。

986
01:08:28,000 --> 01:08:31,000
但在這一點上，我們不希望它繼續檢查。

987
01:08:31,000 --> 01:08:35,000
幸運的是，我們還沒有復位的中點，

988
01:08:35,000 --> 01:08:39,000
我們知道，這種情況下是不會得逞的。

989
01:08:39,000 --> 01:08:44,000
但是，我們一定要在那裡把其他

990
01:08:44,000 --> 01:08:48,000
即使可能在這種情況下，

991
01:08:48,000 --> 01:08:52,000
因為我們沒有調整的中點，這區別嗎？

992
01:08:52,000 --> 01:08:54,000
沒有，因為這些情況都是排斥的。

993
01:08:54,000 --> 01:08:58,000
再次，是我不好。

994
01:08:58,000 --> 01:09:01,000
我們不這樣做，我想，否則，如果需要這個。

995
01:09:01,000 --> 01:09:05,000
我們可以給它一個嘗試，並運行它，並看看會發生什麼。

996
01:09:05,000 --> 01:09:08,000
大廈發生了錯誤。

997
01:09:08,000 --> 01:09:12,000
這可能是因為我在這裡這些B和E的。

998
01:09:12,000 --> 01:09:14,000
我還有更多的人高達頂部？

999
01:09:14,000 --> 01:09:16,000
它看起來並不像它。

1000
01:09:16,000 --> 01:09:20,000
我們要放大，建造，

1001
01:09:20,000 --> 01:09:24,000
就這樣吧，所以現在如果我們搜索15，

1002
01:09:24,000 --> 01:09:28,000
是。

1003
01:09:28,000 --> 01:09:30,000
讓我放大。

1004
01:09:30,000 --> 01:09:33,000
15，是的。我們可以再次運行它。

1005
01:09:33,000 --> 01:09:36,000
上載的源代碼，構建，運行。

1006
01:09:36,000 --> 01:09:41,000
這樣的事情，我們可以搜索13，

1007
01:09:41,000 --> 01:09:45,000
和我們沒有得到任何打印出來的，所以它不是發現了這一點。

1008
01:09:45,000 --> 01:09:51,000
這是偉大的，因為它不是在我們的名單。

1009
01:09:51,000 --> 01:09:53,000
>> 我們現在沒有時間了。

1010
01:09:53,000 --> 01:09:55,000
這將是這個星期。

1011
01:09:55,000 --> 01:10:00,000
感謝您的加盟，看你以後。

1012
01:10:00,000 --> 01:10:02,000
>> [CS50.TV]