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]