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

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

3
00:00:08,150 --> 00:00:11,650
我们有一个忙碌的，但令人兴奋的
摆在我们面前的一节。

4
00:00:11,650 --> 00:00:17,010
因此，首先，因为我们已经做了一些
进展的过程，但我们仍然

5
00:00:17,010 --> 00:00:20,570
有一个很大的学问剩下要做的，我
要告诉你们一些资源

6
00:00:20,570 --> 00:00:24,160
这应该被证明是令人难以置信
有用你不仅接近你

7
00:00:24,160 --> 00:00:28,130
习题集，而且还消化所有的
我们给你们的材料

8
00:00:28,130 --> 00:00:30,800
讲座和短裤和一节。

9
00:00:30,800 --> 00:00:34,790
>> 然后，我们将先花20
节会超过25分钟

10
00:00:34,790 --> 00:00:38,630
GDB，您可能会或可能不会有
用在这点上，但它是一个

11
00:00:38,630 --> 00:00:42,570
令人难以置信的有用工具，将
帮助你调试你的程序。

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

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

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

15
00:00:52,060 --> 00:00:53,320
对可执行文件运行它。

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

17
00:00:56,500 --> 00:01:00,540
要继续练习在一起，
在问题设定了三个超越，你

18
00:01:00,540 --> 00:01:03,320
可以用GDB来帮助调试
您的程序。

19
00:01:03,320 --> 00:01:06,420
最后，我们将介绍一些
排序和查找算法

20
00:01:06,420 --> 00:01:10,590
您在演讲看见了，我们是
将实际的代码，而不只是

21
00:01:10,590 --> 00:01:17,360
伪代码，但代码的二进制搜索，
冒泡排序和选择排序。

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

23
00:01:20,090 --> 00:01:23,530
这是一个广泛的名单，它的
较小的字体，因为我有很多东西要

24
00:01:23,530 --> 00:01:24,390
适合在这里。

25
00:01:24,390 --> 00:01:26,950
但这些不仅会帮助你，
再次，与习题集和

26
00:01:26,950 --> 00:01:30,760
你学到了消化信息，但
肯定，来测验时间，这些都会

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

28
00:01:32,130 --> 00:01:34,700
因此，首先，演讲笔记。

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

30
00:01:39,480 --> 00:01:43,120
你会看到，有注释为每个
讲课，这不是一个简单的

31
00:01:43,120 --> 00:01:47,250
成绩单，而是一个编辑的版本
什么是覆盖在讲座与代码

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

33
00:01:49,610 --> 00:01:52,220
我强烈建议你对这些。

34
00:01:52,220 --> 00:01:55,340
然后还有，还有源代码
可从每个讲座。

35
00:01:55,340 --> 00:02:00,050
再次，这些幻灯片也将是
可在网上cs50.net/sections

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

37
00:02:01,480 --> 00:02:06,860
>> 因此，每个星期第二是短裤的
封面专题，一般为5〜15

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

39
00:02:08,090 --> 00:02:12,310
而那些希望会给你一个
伟大的底漆上不同的主题。

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

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

42
00:02:16,370 --> 00:02:20,110
如果你还没有检查出来，我
强烈建议您这样做。

43
00:02:20,110 --> 00:02:21,100
你来挑一个话题。

44
00:02:21,100 --> 00:02:23,040
我们对有几十个主题。

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

46
00:02:24,770 --> 00:02:27,270
它给你一些幻灯片
并注意到功能。

47
00:02:27,270 --> 00:02:31,190
这些都是实际的幻灯片，转录因子
鼓励在使用我们的

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

49
00:02:32,710 --> 00:02:35,040
还有处理的技巧和窍门
与功能，并有

50
00:02:35,040 --> 00:02:37,290
实践中的问题，帮助
您使用的功能。

51
00:02:37,290 --> 00:02:41,500
我们也给你链接到的短
函数和时间，其功能

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

53
00:02:42,750 --> 00:02:46,550
所以study.cs50.net，全新的这种
今年，一个奇妙的资源。

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

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

56
00:02:52,770 --> 00:02:57,880
所以，如果您对任何问题
命令，例如，兰特，这是我们

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

58
00:03:00,900 --> 00:03:05,380
通过去当你的设置的问题
生成的代码，但如果你输入man

59
00:03:05,380 --> 00:03:09,980
兰特，你会得到的页面
告诉你所有关于兰特。

60
00:03:09,980 --> 00:03:14,040
它给你什么需要时，
它需要的参数，以及返回

61
00:03:14,040 --> 00:03:16,530
类型和简要说明
那功能。

62
00:03:16,530 --> 00:03:17,500
>> 因此，请检查兰特。

63
00:03:17,500 --> 00:03:22,270
它可以是一个有点罗嗦和混乱，
所以有时我觉得

64
00:03:22,270 --> 00:03:26,150
简单的谷歌搜索什么我想知道的是
找到答案的最佳途径。

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

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

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

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

69
00:03:34,300 --> 00:03:35,550
讨论论坛。

70
00:03:35,550 --> 00:03:39,390
机会是，如果你有一个问题，一是
你的700 +的同龄人也有

71
00:03:39,390 --> 00:03:42,110
问题可能问
它已经在讨论

72
00:03:42,110 --> 00:03:43,540
论坛上，并让它回答。

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

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

75
00:03:52,300 --> 00:03:55,450
>> 最后，最后两个，如果你想要
跟一个真正的人，办公室

76
00:03:55,450 --> 00:03:57,770
时间周一至周五。

77
00:03:57,770 --> 00:04:00,850
还有网上办公时间
延期的学生。

78
00:04:00,850 --> 00:04:04,370
最后但并非最不重要的，
我的惊叹号。

79
00:04:04,370 --> 00:04:05,960
你们都有我的联系方式。

80
00:04:05,960 --> 00:04:11,940
如果你需要什么，请千万不要
随时与我联系。

81
00:04:11,940 --> 00:04:14,020
总觉得自由地这样做。

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

83
00:04:17,490 --> 00:04:20,410
但我希望那会改变之间
这一点，下一节。

84
00:04:20,410 --> 00:04:22,105
到目前为止，对资源的任何问题吗？

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

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

87
00:04:27,450 --> 00:04:34,280
>> 最后，另一个插头
反馈，sayat.me/cs50。

88
00:04:34,280 --> 00:04:37,050
你可以给我匿名反馈
关于我是如何做。

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

90
00:04:38,320 --> 00:04:41,890
我有一对夫妇的评论从你们
右后部分，再加上从

91
00:04:41,890 --> 00:04:44,750
谁看了其他学生
在一周内，并且它

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

93
00:04:46,830 --> 00:04:50,250
我要尝试限制我使用
单词“甜”，但我会告诉我的

94
00:04:50,250 --> 00:04:52,410
热情和兴奋
在其他方面。

95
00:04:52,410 --> 00:04:56,550
但也有其他附加
实质性的反馈，

96
00:04:56,550 --> 00:04:57,600
双方的长处和三角洲。

97
00:04:57,600 --> 00:05:00,480
所以，请我给你们反馈
关于您的问题集。

98
00:05:00,480 --> 00:05:01,790
随时给我反馈
在我的教学。

99
00:05:01,790 --> 00:05:04,010
我在这里给你们。

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

101
00:05:05,270 --> 00:05:07,020
这就是我对
首节。

102
00:05:07,020 --> 00:05:08,565
没有任何人有任何
问题这么远吗？

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

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

105
00:05:14,640 --> 00:05:21,200
扩展学生短信给我
说他们没有得到任何音讯，

106
00:05:21,200 --> 00:05:23,870
但是这是我的力量来解决的。

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

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

109
00:05:28,850 --> 00:05:33,860
>> 因此，首先，我们要
要经过GDB。

110
00:05:33,860 --> 00:05:37,100
GDB，因为我暗示较早，
是一个调试工具

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

112
00:05:39,040 --> 00:05:44,700
因此开始使用GDB，你们这些家伙，如果
你要打开你的设备

113
00:05:44,700 --> 00:05:49,070
走，我通过电子邮件发送给您的文件
前面 - 这个文件也将是

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

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

116
00:05:55,700 --> 00:05:58,580
首先，当然，你必须编译
文件因为GDB只适用于

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

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

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

120
00:06:04,550 --> 00:06:08,340
所以这是我们的程序的名称
去，现在用它去。

121
00:06:08,340 --> 00:06:12,810
所以我打算写使凯撒，这
会给我一个可执行文件

122
00:06:12,810 --> 00:06:14,100
在这里绿色突出。

123
00:06:14,100 --> 00:06:19,250
然后我要去运行GDB /塞萨尔。

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

125
00:06:19,810 --> 00:06:24,540
你看我们有一些文字告诉我
关于广发行的版本，给我

126
00:06:24,540 --> 00:06:27,570
一些保修信息，然后我们
有国内生产总值提示，这看起来有点

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

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

129
00:06:32,510 --> 00:06:36,520
在我们继续之前和调试这个文件
那我给你的一切，让我们来看看

130
00:06:36,520 --> 00:06:40,220
一些有用的命令，所以我们有一种感觉，
什么我们要覆盖。

131
00:06:40,220 --> 00:06:45,060
>> 这些命令列在这里的
顺序我一般使用它们。

132
00:06:45,060 --> 00:06:50,230
所以我通过运行启动我的程序
该方案的GBD。/名称，

133
00:06:50,230 --> 00:06:51,360
在这种情况下，恺撒。

134
00:06:51,360 --> 00:06:57,430
然后我首先要做99.9％
的时间类型休息的意思。

135
00:06:57,430 --> 00:06:59,070
，在主设置一个断点。

136
00:06:59,070 --> 00:07:03,260
从本质上讲，你在做什么有
是该程序将停止在

137
00:07:03,260 --> 00:07:06,100
主这样你就可以开始研究它线
按行，而不是运行的所有

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

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

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

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

142
00:07:14,840 --> 00:07:17,400
启动该程序运行，并
如果你需要输入的命令行

143
00:07:17,400 --> 00:07:19,090
的论点，你运行它的命令。

144
00:07:19,090 --> 00:07:20,500
与参数运行。

145
00:07:20,500 --> 00:07:25,000
这样以来，我们去那边的一个版本
C，这是该计划你们的

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

147
00:07:26,160 --> 00:07:29,880
这其中，当然，有一些错误
在它那希望我们会发现 - 

148
00:07:29,880 --> 00:07:32,810
我们将用一些命令来运行运行
行参数，因为恺撒，

149
00:07:32,810 --> 00:07:34,860
按问题你们知道
设置规范，需要一些

150
00:07:34,860 --> 00:07:36,380
命令行参数。

151
00:07:36,380 --> 00:07:40,000
>> 在接下来的几个命令，下一个
一个是实际调用下一个。

152
00:07:40,000 --> 00:07:42,470
那一个你需要一行一行
通过你们的节目。

153
00:07:42,470 --> 00:07:45,800
所以打n，则输入带你
行到下一行，执行

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

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

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

157
00:07:51,070 --> 00:07:54,310
所以，如果你写一个函数
你的代码或者如果您想探索

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

159
00:07:57,820 --> 00:08:02,390
你正在经历右边的文件
现在，你将真正步入

160
00:08:02,390 --> 00:08:04,670
这个函数然后看看它的代码。

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

162
00:08:12,300 --> 00:08:14,940
您当前所在的代码
所以实际上你可以看到文件

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

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

165
00:08:21,890 --> 00:08:24,020
这表明你是什么一个变量等于。

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

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

168
00:08:27,740 --> 00:08:31,770
信息当地人告诉你所有的地方的
变量，它们打印全力为您

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

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

171
00:08:36,360 --> 00:08:39,929
好奇，如果我在一个for循环中，为
举例来说，我只是写信息本地人，

172
00:08:39,929 --> 00:08:43,470
它会告诉我什么我的计数器i
等于，以及我是阵列

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

174
00:08:45,130 --> 00:08:47,530
>> 最后，继续。

175
00:08:47,530 --> 00:08:49,300
键入中断停止你
在破发点。

176
00:08:49,300 --> 00:08:51,380
你可以通过走线
旁边和步线。

177
00:08:51,380 --> 00:08:55,640
继续运行程序到下一个
突破点，或直至完成，如果

178
00:08:55,640 --> 00:08:57,180
有没有更多的破发点。

179
00:08:57,180 --> 00:09:00,060
禁用删除断点，如果你
决定在主要的突破是

180
00:09:00,060 --> 00:09:01,890
不当之处，你要
设置在别的地方。

181
00:09:01,890 --> 00:09:05,090
最后Q，退出，得到了广发行。

182
00:09:05,090 --> 00:09:10,784
>> 所以这个程序，/撒，我们将
仔细看看，现在，我们

183
00:09:10,784 --> 00:09:13,490
要使用GDB找
臭虫此计划。

184
00:09:13,490 --> 00:09:18,110
我跑这个程序与前面
检查50，我得到了一个皱眉。

185
00:09:18,110 --> 00:09:22,310
一切它的存在，它编译的，它
通过大量的试验，但对于

186
00:09:22,310 --> 00:09:27,950
由于某些原因，它没有通过第五
测试中，转向BARFOO，全部大写，成

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

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

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

190
00:09:35,410 --> 00:09:37,340
因此，有一些小的失误在这里。

191
00:09:37,340 --> 00:09:38,070
我已经通过我的代码看起来。

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

193
00:09:38,850 --> 00:09:41,740
希望你们能帮助我
找出这个bug是。

194
00:09:41,740 --> 00:09:44,610
>> 所以这是我们的错误
寻找。

195
00:09:44,610 --> 00:09:46,090
让我们继续前进到GDB。

196
00:09:46,090 --> 00:09:51,100
再次，我已经运行GDB /凯撒，
所以现在我们在广发行。

197
00:09:51,100 --> 00:09:54,290
什么是第一
我应该做的事情吗？

198
00:09:54,290 --> 00:09:56,680
我刚刚进入GDB。

199
00:09:56,680 --> 00:10:00,316
有人给我一个很好的
命令进入。

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

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

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

203
00:10:02,900 --> 00:10:03,560
让我们键入英寸

204
00:10:03,560 --> 00:10:06,390
你们可以在这里观看或跟随
沿着你的电脑上。

205
00:10:06,390 --> 00:10:09,410
打破主，你会看到一个
断点设定在 - 

206
00:10:09,410 --> 00:10:12,340
它给了我一些奇怪的内存地址，
而这也给我的行号。

207
00:10:12,340 --> 00:10:15,310
如果我回头看这个文件，
我想知道，主

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

209
00:10:17,700 --> 00:10:18,950
我应该怎么跑下一个？

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

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

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

213
00:10:25,650 --> 00:10:27,175
所以，我应该怎么跑下一个？

214
00:10:27,175 --> 00:10:27,520
>> 学生：运行。

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

216
00:10:28,050 --> 00:10:30,760
如果我只是跑跑步，还是应该
我在添加一些其他的东西？

217
00:10:30,760 --> 00:10:31,960
>> 学生：使用参数运行。

218
00:10:31,960 --> 00:10:33,320
>> JASON HIRSCHHORN：与运行
命令参数。

219
00:10:33,320 --> 00:10:36,420
而且因为我调试一个非常具体的
情况下，我应该输入

220
00:10:36,420 --> 00:10:37,120
命令行参数。

221
00:10:37,120 --> 00:10:42,290
所以我会做运行三个，这是，再次，
我从50检查了输出。

222
00:10:42,290 --> 00:10:44,240
启动程序。

223
00:10:44,240 --> 00:10:45,420
我们通过几行。

224
00:10:45,420 --> 00:10:47,700
现在你会看到，我们是在第21行。

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

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

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

228
00:10:53,120 --> 00:10:57,010
这给了我，其实，
代码是在第21行。

229
00:10:57,010 --> 00:10:58,440
所以我刚才讲错。

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

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

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

233
00:11:04,300 --> 00:11:06,280
这行代码有
尚未执行。

234
00:11:06,280 --> 00:11:06,890
这一点很重要。

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

236
00:11:09,120 --> 00:11:12,650
这就是下一行代码
你即将执行。

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

238
00:11:15,860 --> 00:11:20,070
状态检查，看看我是否有
输入的命令行参数。

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

240
00:11:22,140 --> 00:11:23,457
什么是对我？

241
00:11:23,457 --> 00:11:24,950
>> 学生：它更改为一个整数。

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

243
00:11:25,450 --> 00:11:27,400
>> 学生：它改变了
参数的整数。

244
00:11:27,400 --> 00:11:30,890
>> JASON HIRSCHHORN：所以一到我的变化ARG
卷从一个字符串为整数。

245
00:11:30,890 --> 00:11:32,140
然后它是什么检查？

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

247
00:11:35,414 --> 00:11:37,112
>> 学生：如果有一个第二
命令行参数，除了

248
00:11:37,112 --> 00:11:38,100
运行该程序。

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

250
00:11:39,460 --> 00:11:41,220
布尔表达式检查？

251
00:11:41,220 --> 00:11:42,540
这部分在这里，一来我？

252
00:11:42,540 --> 00:11:44,080
>> 学生：如果是负数。

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

254
00:11:45,380 --> 00:11:47,120
>> 学生：确保它
是，实际上正。

255
00:11:47,120 --> 00:11:47,650
>> JASON HIRSCHHORN：没错。

256
00:11:47,650 --> 00:11:50,600
这被检查，看它是否
负的，而如果它是负的，我

257
00:11:50,600 --> 00:11:53,220
有一种感觉，下一行可能
被我骂的用户。

258
00:11:53,220 --> 00:11:55,930
因此，让我们打结束时执行这条线。

259
00:11:55,930 --> 00:11:59,925
我们没有看到该行的你们
也许期望看到大喊大叫的

260
00:11:59,925 --> 00:12:03,030
用户再回来，因为
这一行没有执行。

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

262
00:12:03,840 --> 00:12:06,860
所以，我没有，事实上，输入两个命令
行参数，和3

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

264
00:12:07,610 --> 00:12:09,950
所以，我们看到那行，我们执行，
但我们没踩

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

266
00:12:11,300 --> 00:12:17,060
>> 所以，现在，未来，我看到我设置
整型键等于给我精氨酸卷。

267
00:12:17,060 --> 00:12:18,840
所以这是我创建一个可变密钥。

268
00:12:18,840 --> 00:12:22,450
所以，如果我打印出来的关键，现在，因为
这可以让你看到的

269
00:12:22,450 --> 00:12:26,040
值里面的变量，
关键等于47。

270
00:12:26,040 --> 00:12:28,810
这是奇怪的，但当然，
那是因为我没有

271
00:12:28,810 --> 00:12:30,490
执行该行呢。

272
00:12:30,490 --> 00:12:35,880
所以，现在如果我打了N，执行该行，
并做打印键，键将等于3，

273
00:12:35,880 --> 00:12:37,740
这是我们期望它等于。

274
00:12:37,740 --> 00:12:41,170
>> 如此反复，在广发行，行啦
看你有没有执行。

275
00:12:41,170 --> 00:12:44,850
你必须打N或S或数字
其他命令来实际的

276
00:12:44,850 --> 00:12:46,610
执行该行。

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

278
00:12:47,380 --> 00:12:48,280
关键的第3。

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

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

281
00:12:51,000 --> 00:12:52,270
让我们来执行该行。

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

283
00:12:53,970 --> 00:12:58,690
>> 让我们在我入住50看，我
进入BARFOO全部大写，所以

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

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

286
00:13:07,300 --> 00:13:08,610
你会看到它等于一个字符串。

287
00:13:08,610 --> 00:13:11,100
它给了我一些其他怪异的十六进制
数，但它在

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

289
00:13:13,620 --> 00:13:19,308
如果我想看看什么键相当于在
这点，我怎么可以检查关键？

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

291
00:13:20,710 --> 00:13:22,010
>> JASON HIRSCHHORN：Print键，没错。

292
00:13:22,010 --> 00:13:23,260
而实际上，有一个快捷方式。

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

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

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

296
00:13:29,730 --> 00:13:34,760
>> 如果我想找出什么两大关键
和BARFOO相当于在同一时间

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

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

299
00:13:38,590 --> 00:13:41,170
这给了我钥匙等于3。

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

301
00:13:42,500 --> 00:13:45,265
这也给了我这两个奇怪的事情
在顶部，该变量i和

302
00:13:45,265 --> 00:13:46,590
这个变量n。

303
00:13:46,590 --> 00:13:48,460
>> 这些都是实际存在的
在我的主程序。

304
00:13:48,460 --> 00:13:51,280
我们还没有遇到过他们呢，
但作为预览，那些

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

306
00:13:52,880 --> 00:13:55,360
所以现在，他们平等有些怪异
数字，因为他们没有被

307
00:13:55,360 --> 00:13:58,300
初始化还没有，但它们仍然存在
在内存中，所以他们只是设置

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

309
00:14:00,220 --> 00:14:02,890
但是我们看到在关键平原
文字在那里。

310
00:14:02,890 --> 00:14:06,390
>> 所以，我要执行这条线，
第34行，for循环。

311
00:14:06,390 --> 00:14:08,220
我们要跳进
for循环击中ñ。

312
00:14:08,220 --> 00:14:10,050
而且我们内部的for循环。

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

314
00:14:11,360 --> 00:14:14,300
再次，这些都应该有点期待
你熟悉的，因为这是一个

315
00:14:14,300 --> 00:14:18,080
写凯撒程序，但
再次，有一些类型的错误。

316
00:14:18,080 --> 00:14:21,940
>> 现在如果我做信息本地人，因为我
里面的那个for循环，你会看到

317
00:14:21,940 --> 00:14:23,900
我等于零，正如我们期望的那样。

318
00:14:23,900 --> 00:14:26,820
这就是我们将其设置为和初始化
它在for循环。

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

320
00:14:27,560 --> 00:14:30,700
这也有道理，因为我们设置
它以纯文本的strlen的。

321
00:14:30,700 --> 00:14:34,270
所以我喜欢做信息本地人或打印
到变量经常以确保

322
00:14:34,270 --> 00:14:36,370
一切总是什么
我希望它等于。

323
00:14:36,370 --> 00:14:39,800
在这种情况下，一切都
我希望它等于。

324
00:14:39,800 --> 00:14:41,850
>> 因此，让我们开始通过移动
这个for循环。

325
00:14:41,850 --> 00:14:45,715
我上线是36行，如果纯
文字i大于一个朴素

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

327
00:14:48,540 --> 00:14:51,880
我知道我的问题是不是与我的第一次
信中，它与第二个字母。

328
00:14:51,880 --> 00:14:56,290
如果我们回头看检查
50，B进入到E的罚款。

329
00:14:56,290 --> 00:14:59,010
我要带A和把它当作
一个A，而不是将其更改为D。所以，

330
00:14:59,010 --> 00:15:00,200
什么是错的
第二个字母。

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

332
00:15:01,640 --> 00:15:06,030
>> 但是，如果我没有想检查什么纯
文字我等于在这个特殊的

333
00:15:06,030 --> 00:15:07,760
情况下，我觉得应该是什么？

334
00:15:07,760 --> 00:15:10,980
我应该明文等于我在这
通过第一轮的循环？

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

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

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

338
00:15:16,510 --> 00:15:21,180
所以它应该是资本B的我，当然，
为零，但纯文本

339
00:15:21,180 --> 00:15:25,600
支架零闭合支架等于乙
因为字符串，如我们上周看到的，

340
00:15:25,600 --> 00:15:28,650
是数组，所以我们得到的
第一个字符从。

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

342
00:15:34,960 --> 00:15:36,560
B.这就是整齐的，对不对？

343
00:15:36,560 --> 00:15:40,380
我实际上并没有明文一
这不是我设置的变量之一

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

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

346
00:15:45,640 --> 00:15:47,340
>> 但是，让我们移动。

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

348
00:15:50,050 --> 00:15:53,290
Z，这显然是正确的，因为我们有
资本B.我要去跑

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

350
00:15:54,230 --> 00:15:58,530
我们看到，数学最后一周，所以我们将
想当然，它的工作原理

351
00:15:58,530 --> 00:16:00,900
根据权利检查50。

352
00:16:00,900 --> 00:16:03,720
>> 这些大括号，第一个
结果显示，我是退出，如果

353
00:16:03,720 --> 00:16:07,030
条件，第二个显示
那我退出for循环。

354
00:16:07,030 --> 00:16:10,400
所以现在当我打接下来，我们将看到
我们回来在for循环一次。

355
00:16:10,400 --> 00:16:11,970
我们正在经历的
再次循环。

356
00:16:11,970 --> 00:16:18,110
让我们真正步入第二
迭代的for循环和类型

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

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

359
00:16:22,190 --> 00:16:24,530
我等于1，这是我们期望的。

360
00:16:24,530 --> 00:16:26,650
N等于6，而我们预期。

361
00:16:26,650 --> 00:16:28,810
关键等于3，这是我们期望的。

362
00:16:28,810 --> 00:16:32,625
和纯文本，你会看到，等于
EARFOO现在，没有BARFOO了，因为

363
00:16:32,625 --> 00:16:37,930
在我们先前的迭代中，B为
改为大写E。所以我们即将

364
00:16:37,930 --> 00:16:40,040
遇到的问题，所以这
在这里我们要

365
00:16:40,040 --> 00:16:41,130
潜入调试。

366
00:16:41,130 --> 00:16:43,365
但是，没有任何人有任何问题
关于我们到目前为止已经做了什么？

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

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

369
00:16:47,910 --> 00:16:52,710
>> 所以我们一下，如果执行此
条件下，纯文本支架我关闭

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

371
00:16:57,500 --> 00:17:00,450
我进入了，因为这是
我知道我的错误，我想点

372
00:17:00,450 --> 00:17:06,859
出一的纯文本，以便
让我们把打印出来。

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

374
00:17:12,020 --> 00:17:14,740
>> 所以我希望我的每逻辑这条线，
这条线应该是真实的。

375
00:17:14,740 --> 00:17:16,099
这是一个大写字母。

376
00:17:16,099 --> 00:17:20,599
但如果我打了N，我们要明白，这个
行，其实并没有执行。

377
00:17:20,599 --> 00:17:22,609
我跳进来的东西，如果。

378
00:17:22,609 --> 00:17:25,460
为什么会这样？

379
00:17:25,460 --> 00:17:27,480
>> 学生：因为你有你的条件
纯文本的大

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

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

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

383
00:17:32,850 --> 00:17:38,130
所以很明显，资本A没有
如果条件触发这一点，我们做

384
00:17:38,130 --> 00:17:40,520
没有踏进去，和我们做
没有做必要的转变。

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

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

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

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

389
00:17:47,855 --> 00:17:52,590
>> 但我们会看到，只是为了教学的
的缘故，如果我坚持去做。

390
00:17:52,590 --> 00:17:59,580
本否则，如果不执行下去，但
什么，而不是等于就是命令

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

392
00:18:00,500 --> 00:18:04,840
所以它没有改变，如果我
这里打印纯文本，我们会看到去

393
00:18:04,840 --> 00:18:08,250
通过for循环没有，事实上，
改变第二个字符的。

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

395
00:18:09,600 --> 00:18:12,690
>> 所以，再一次，我们调试我们的错误。

396
00:18:12,690 --> 00:18:17,380
我们意识到有
一些逻辑缺失。

397
00:18:17,380 --> 00:18:20,590
和我们之前调试它的时间提前
实际执行这条线，

398
00:18:20,590 --> 00:18:24,320
但你会注意到有我们只是
点击Next，并跳转到否则，如果，

399
00:18:24,320 --> 00:18:26,710
这意味着，如果条件
是不正确的。

400
00:18:26,710 --> 00:18:29,550
我们没有，事实上，获得
结果我们的预期。

401
00:18:29,550 --> 00:18:33,240
这样的话，我们可能已经提示，有
我们没有这么精明，看

402
00:18:33,240 --> 00:18:38,510
如果条件和检查的话，其实，
我们的条件应计算为

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

404
00:18:41,150 --> 00:18:42,880
>> 这是所有用于调试这个程序。

405
00:18:42,880 --> 00:18:45,340
没有任何人有任何问题吗？

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

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

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

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

410
00:18:58,440 --> 00:19:00,860
>> 所以这是一个快速入门到GDB。

411
00:19:00,860 --> 00:19:03,430
实际上，在实际情况下，
我这样做是在办公时间。

412
00:19:03,430 --> 00:19:06,710
我GDBed在这个确切的程序
办公时间与学生。

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

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

415
00:19:13,190 --> 00:19:16,060
我们使用命令行参数运行，
第二件事情，我们做到了。

416
00:19:16,060 --> 00:19:18,520
接下来，我们用了很多移动
我们通过线。

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

418
00:19:20,310 --> 00:19:22,920
这是在括号
在灰色的幻灯片。

419
00:19:22,920 --> 00:19:28,590
>> 我们没有使用的步骤，但是我们并没有
一定需要这种情况。

420
00:19:28,590 --> 00:19:32,150
但是，我们可能会在稍后使用它
今天，如果我们正在调试，为

421
00:19:32,150 --> 00:19:36,500
例如，二进制搜索二进制时
搜索被称为在一个单独的

422
00:19:36,500 --> 00:19:38,200
的功能，但有
与它的一些错误。

423
00:19:38,200 --> 00:19:40,440
我们将要步入
调用二进制搜索和

424
00:19:40,440 --> 00:19:41,840
实际调试它。

425
00:19:41,840 --> 00:19:45,130
列表中，我们没有使用或者是因为我们有
我们的代码感好，但如果我

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

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

428
00:19:50,310 --> 00:19:53,260
继续我们并不需要在此使用
情况下，我们也没有需要使用

429
00:19:53,260 --> 00:19:55,060
禁用的，但我们确实使用了退出。

430
00:19:55,060 --> 00:19:57,850
同样，这些10的命令，
实践它们。

431
00:19:57,850 --> 00:20:00,770
如果你了解这10个命令，
你应该调试任何设置

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

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

434
00:20:05,230 --> 00:20:08,420
>> 所以我们马上就要去上，再次向
部分的症结今天，去了

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

436
00:20:09,720 --> 00:20:14,075
在这样做之前，再次，有任何疑问，
意见，关注的广发行？

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

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

439
00:20:20,960 --> 00:20:24,550
所以每个人都为永久的缘故，
大家都点头他们的头向右

440
00:20:24,550 --> 00:20:27,400
现在，我会看到你在办公时间
和所有的转录因子会看到你和

441
00:20:27,400 --> 00:20:29,460
他们会说，告诉我怎么用
GDB，你就可以

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

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

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

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

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

447
00:20:35,790 --> 00:20:40,710
你会看到我已经排序的列表
对我们来说，但不会

448
00:20:40,710 --> 00:20:42,220
是这种情况总是如此。

449
00:20:42,220 --> 00:20:49,170
所以在问题设置规范
问题设定了三个，你有短裤

450
00:20:49,170 --> 00:20:51,410
你可以看，它实际上
请你看看那些短裤。

451
00:20:51,410 --> 00:20:55,090
此外，在演讲最后一周，我们走过去
很多这样的算法，所以我

452
00:20:55,090 --> 00:20:59,150
不会花时间在课堂上会
一遍这些算法或图纸

453
00:20:59,150 --> 00:21:01,130
图片，如何将这些
算法工作。

454
00:21:01,130 --> 00:21:04,030
同样，这些信息您可以重新手表
讲座中，或者该信息

455
00:21:04,030 --> 00:21:08,570
被捕获出色的短裤
对于这些搜索所有的，

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

457
00:21:10,920 --> 00:21:14,200
>> 所以，我们要去什么
要做的就是编写这些程序。

458
00:21:14,200 --> 00:21:18,190
我们有一个感觉，一个心智模式如何，
他们的工作，还等什么，我们要去

459
00:21:18,190 --> 00:21:20,210
要做的就是对它们进行编码真实的。

460
00:21:20,210 --> 00:21:23,430
我们打​​算把这一心智模式，
那张照片，如果你愿意，进

461
00:21:23,430 --> 00:21:24,960
实际代码。

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

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

464
00:21:28,770 --> 00:21:30,540
>> 我们不会实际去
跳转到代码通俗易懂。

465
00:21:30,540 --> 00:21:36,030
因此，尽管这个提示在这张幻灯片问
你的代码的二进制搜索，并

466
00:21:36,030 --> 00:21:39,470
实际上，一个迭代版本
二进制搜索，第一件事我

467
00:21:39,470 --> 00:21:42,370
真的希望你做的是
写一些伪代码。

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

469
00:21:47,020 --> 00:21:50,060
拿出一张纸，如果你有
1一应俱全，或者打开一个

470
00:21:50,060 --> 00:21:52,520
文本编辑器，我想
大家都来写。

471
00:21:52,520 --> 00:21:57,470
连拿4分写
伪代码二进制搜索。

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

473
00:21:58,990 --> 00:22:01,980
我会回来的，如果你有任何问题
我们可以得出的图片出来。

474
00:22:01,980 --> 00:22:06,220
但首先，我们开始编程之前，
我想要写

475
00:22:06,220 --> 00:22:09,920
伪代码的二进制搜索，所以当我们
潜水，我们有一些方向

476
00:22:09,920 --> 00:22:12,110
的地方，我们应该前往。

477
00:22:12,110 --> 00:22:15,330
>> 学生：我们是否可以假设数组
我们得到的值已经排序？

478
00:22:15,330 --> 00:22:17,960
>> JASON HIRSCHHORN：所以对于二进制搜索
工作 - 优秀的问题 - 你

479
00:22:17,960 --> 00:22:20,970
必须采取以排序
数组值。

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

481
00:22:22,290 --> 00:22:23,480
我们将回到这个幻灯片。

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

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

484
00:22:29,230 --> 00:22:32,910
这应该看起来很熟悉，如果你已经
已经接近或得到你

485
00:22:32,910 --> 00:22:34,580
手脏与习题集。

486
00:22:34,580 --> 00:22:35,910
>> 但是，这是你的函数声明。

487
00:22:35,910 --> 00:22:39,080
再次，应该不需要担心
这么多在这一刻。

488
00:22:39,080 --> 00:22:43,660
我真的希望你做的是采取
四分钟的伪代码的二进制

489
00:22:43,660 --> 00:22:46,380
搜索，然后我们就去
以上，作为一个组。

490
00:22:46,380 --> 00:22:47,500
我会来到我身边。

491
00:22:47,500 --> 00:22:49,590
如果您有任何疑问，请随时
自由地举起你的手。

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

493
00:25:07,110 --> 00:25:09,680
>> 你为什么不走两分钟
完成了伪码？

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

495
00:25:13,690 --> 00:25:15,820
我知道这可能看起来荒谬的，
我们花那么多时间

496
00:25:15,820 --> 00:25:20,350
东西甚至不是真正的
C，但尤其是对于这些更

497
00:25:20,350 --> 00:25:24,030
具有挑战性的算法和问题
集，我们要搞清楚，

498
00:25:24,030 --> 00:25:27,210
开始在伪不担心
有关语法，只是担心

499
00:25:27,210 --> 00:25:29,150
逻辑，是难以置信的帮助。

500
00:25:29,150 --> 00:25:32,720
而这样一来，你不求解两个
令人难以置信的困难问题一次。

501
00:25:32,720 --> 00:25:35,390
你只是专注于逻辑，
然后你进入的语法。

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

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

504
00:26:01,385 --> 00:26:03,680
让我们开始经历
伪代码。

505
00:26:03,680 --> 00:26:05,380
我已经写在这里，二进制
搜索伪代码。

506
00:26:05,380 --> 00:26:07,360
我们会写这篇文章的上
登上在一起。

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

508
00:26:10,040 --> 00:26:15,010
所以，有谁能够给我的第一个
伪代码的行，你

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

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

511
00:26:20,258 --> 00:26:22,698
>> 学生：虽然的长度
列表是大于零。

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

513
00:26:26,114 --> 00:26:34,880
>> JASON HIRSCHHORN：虽然长度
的商大于零。

514
00:26:34,880 --> 00:26:38,810
又一次，我们看到一些C的前瞻性
在这里语法的东西。

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

516
00:26:41,550 --> 00:26:43,980
有没有人有他们提出的任何行
在此之前他们的伪代码？

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

518
00:26:47,280 --> 00:26:50,210
>> 学生：获得一个数组
的分类数字。

519
00:26:50,210 --> 00:26:53,600
>> JASON HIRSCHHORN：你写了“得到一个
数组排序的数字。“每

520
00:26:53,600 --> 00:26:56,140
函数的声明，我们将通过
排序的数字的阵列。

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

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

523
00:26:59,030 --> 00:27:01,820
但是，是的，如果我们没有，我们
就需要我们对数组进行排序

524
00:27:01,820 --> 00:27:04,850
数字，因为二进制搜索
仅适用于排序数组。

525
00:27:04,850 --> 00:27:11,300
因此，尽管列表的长度为零，我
打算把一些大括号

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

527
00:27:15,420 --> 00:27:19,550
while循环，所以这里面，而
循环什么，我们需要

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

529
00:27:22,000 --> 00:27:25,530
>> 别人谁没有给我一个
但回答却是谁写的呢？

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

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

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

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

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

535
00:27:43,290 --> 00:27:45,530
和后续的问题，什么
我们做一次，我们在

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

537
00:27:46,870 --> 00:27:49,310
>> 学生：做一个检查这是否是
你要找的数量。

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

539
00:27:50,120 --> 00:28:05,500
走在列表的中间，并检查
如果我们的价值在那里 - 

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

541
00:28:06,515 --> 00:28:10,460
没有任何人有任何东西
这是比这有什么不同？

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

543
00:28:11,210 --> 00:28:13,800
>> 我们在做二进制搜索的第一件事
被转到列表的中间，

544
00:28:13,800 --> 00:28:15,870
检查，看看是否我们的价值是存在的。

545
00:28:15,870 --> 00:28:19,682
所以我想，如果我们的价值
在那里，我们该怎么做？

546
00:28:19,682 --> 00:28:21,610
>> 学生：我们回到零[听不清]。

547
00:28:21,610 --> 00:28:23,400
>> JASON HIRSCHHORN：是啊，如果我们的
价值是存在的，我们发现它。

548
00:28:23,400 --> 00:28:27,950
因此，我们可以不过告诉某种程度上，这
函数的定义，我们告诉用户

549
00:28:27,950 --> 00:28:28,520
我们发现它。

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

551
00:28:30,950 --> 00:28:35,120
所以，如果它不存在，别人谁
正在对二进制搜索或

552
00:28:35,120 --> 00:28:36,830
有一个想法，现在，我们该怎么做？

553
00:28:36,830 --> 00:28:37,830
>> 学生：问题。

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

555
00:28:38,100 --> 00:28:39,920
>> 学生：是的数组已经排序？

556
00:28:39,920 --> 00:28:42,200
>> JASON HIRSCHHORN：是的，我们假设
该数组已经排序。

557
00:28:42,200 --> 00:28:46,480
>> 学生：所以，你必须检查
你看到的值大于

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

559
00:28:51,745 --> 00:28:54,110
>> JASON HIRSCHHORN：所以，如果中间
清单大于我们在做什么

560
00:28:54,110 --> 00:28:57,440
寻找，然后我们做什么？

561
00:28:57,440 --> 00:28:58,320
我们谨在哪里？

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

563
00:29:01,400 --> 00:29:02,780
数字低于。

564
00:29:02,780 --> 00:29:04,460
>> JASON HIRSCHHORN：所以我们会
调用的左侧。

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

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

567
00:29:20,620 --> 00:29:22,980
然后通过搜索什么
我的意思是搜索？

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

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

570
00:29:24,410 --> 00:29:25,740
事实上，我们重复这件事情。

571
00:29:25,740 --> 00:29:29,210
我们回去通过我们的while循环。

572
00:29:29,210 --> 00:29:31,480
我给你最后一个 - 

573
00:29:31,480 --> 00:29:39,047
否则，如果中间是少了什么
我们做什么，我们该怎么做吗？

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

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

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

577
00:29:47,440 --> 00:29:51,710
这看起来不错，但没有任何人有
任何事情，我们可能会丢失或

578
00:29:51,710 --> 00:29:53,200
别的，你把
在你的伪代码？

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

580
00:29:57,080 --> 00:29:58,410
所以，这就是我们有这么远。

581
00:29:58,410 --> 00:30:00,960
而该列表的长度大
大于零，我们打算去

582
00:30:00,960 --> 00:30:03,220
到列表中的中间和
检查我们的价值是存在的。

583
00:30:03,220 --> 00:30:06,970
>> 如果中间大，我们要
搜索离开，否则，如果中间是

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

585
00:30:09,230 --> 00:30:14,430
所以，我们都不得不与一些熟悉
我们在计算机科学使用条款

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

587
00:30:15,550 --> 00:30:18,300
但你已经注意到我们
讲英文，但我们发现了一个

588
00:30:18,300 --> 00:30:24,790
很多事情，似乎在映射到
我们已经在我们的编码工具包工具。

589
00:30:24,790 --> 00:30:27,210
于是马上蝙蝠，我们不是
将实际的代码呢。

590
00:30:27,210 --> 00:30:33,300
>> 我们看到了什么英文在这里，图
上的东西，我们可以用C写的？

591
00:30:33,300 --> 00:30:34,560
>> 学生：虽然。

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

593
00:30:35,320 --> 00:30:40,610
因此，这同时就在这里
地图上的是什么？

594
00:30:40,610 --> 00:30:42,630
>> 学生：一个while循环。

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

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

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

598
00:30:46,260 --> 00:30:49,050
所以我们要编写一个循环。

599
00:30:49,050 --> 00:30:51,640
而我们已经知道了，因为我们已经做了
这几次我们

600
00:30:51,640 --> 00:30:54,180
有大量的例子摆在那里，
其实怎么写

601
00:30:54,180 --> 00:30:55,310
该指数为一个循环。

602
00:30:55,310 --> 00:30:56,160
所以这应该是相当容易的。

603
00:30:56,160 --> 00:30:58,070
我们应该能够得到
启动很快。

604
00:30:58,070 --> 00:31:01,830
>> 还有什么我们在这里看到了什么？

605
00:31:01,830 --> 00:31:06,820
还有什么其他的结构语法，事情
我们熟悉C语言，我们做

606
00:31:06,820 --> 00:31:09,790
已经有一个基于感
关闭我们所用的字眼？

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

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

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

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

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

612
00:31:14,530 --> 00:31:16,260
>> JASON HIRSCHHORN：如果和
否则 - 就在这里。

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

614
00:31:18,840 --> 00:31:20,420
>> 学生：一个if else语句。

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

616
00:31:21,560 --> 00:31:24,650
因此，我们可能会需要
写一些条件。

617
00:31:24,650 --> 00:31:31,185
再次，虽然也许在混乱
首先，我们一般有一种感觉，现在

618
00:31:31,185 --> 00:31:34,010
如何写条件和
语法条件。

619
00:31:34,010 --> 00:31:36,850
如果我们不这样做，我们只是查查
语法条件下，剪切和粘贴

620
00:31:36,850 --> 00:31:39,950
如此，因为我们知道我们
在这里需要一个条件。

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

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

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

624
00:31:48,960 --> 00:31:50,370
>> 学生：这可能是显而易见的，
通过只检查，如果一个

625
00:31:50,370 --> 00:31:51,990
值等于什么。

626
00:31:51,990 --> 00:31:54,578
>> JASON HIRSCHHORN：那么我们该如何检查
和 - 所以去到列表的中间

627
00:31:54,578 --> 00:31:55,610
并检查我们的价值在那里？

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

629
00:31:56,570 --> 00:31:58,450
什么是语法是什么？

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

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

632
00:32:00,650 --> 00:32:03,540
所以，这个检查很可能会
是一种平等的，平等的。

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

634
00:32:04,510 --> 00:32:07,510
而实际上，只是在写它，
我们看到其他的事情。

635
00:32:07,510 --> 00:32:11,400
我们将不得不做一些
比较操作符在那里 - 

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

637
00:32:12,010 --> 00:32:14,980
因此，它实际上看起来像，并通过
大，我们还没有写一个

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

639
00:32:16,390 --> 00:32:20,610
但我们得到的心智模式下来
通过讲座和那些短裤。

640
00:32:20,610 --> 00:32:22,350
>> 我们写的伪代码为一组。

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

642
00:32:27,110 --> 00:32:28,550
现在，我们只需要编写
它，这又是一个

643
00:32:28,550 --> 00:32:30,110
非平凡的问题要解决。

644
00:32:30,110 --> 00:32:31,890
但至少我们坚持的逻辑。

645
00:32:31,890 --> 00:32:38,040
至少现在，当我们去到上班时间，
我可以说，我知道我需要什么

646
00:32:38,040 --> 00:32:40,160
这样做，但你可以提醒
语法我吗？

647
00:32:40,160 --> 00:32:42,940
或者即使上班时间都挤，你
可以为谷歌的语法，而

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

649
00:32:45,040 --> 00:32:48,570
>> 再次，而不是试图解决
逻辑和语法问题都

650
00:32:48,570 --> 00:32:51,900
一次，它往往是要好得多
破解这两个难题扎进

651
00:32:51,900 --> 00:32:58,280
2更易于管理的和做的
伪代码在C中，然后再代码

652
00:32:58,280 --> 00:33:00,620
因此，让我们看看我做的
伪代码的时间提前。

653
00:33:00,620 --> 00:33:04,060
>> 而该列表的长度大
大于零，看中间

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

655
00:33:05,090 --> 00:33:09,610
如果发现号返回true，否则
如果数值越高，搜索左。

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

657
00:33:13,200 --> 00:33:18,710
这样，看起来几乎一模一样，如果不
几乎相同，我们写了。

658
00:33:18,710 --> 00:33:23,030
事实上，汤姆，你先说什么，
断，如果在列表中，中间

659
00:33:23,030 --> 00:33:24,880
发现成两个语句数
其实是我做了什么。

660
00:33:24,880 --> 00:33:25,507
>> 我结合他们那里。

661
00:33:25,507 --> 00:33:27,100
我应该听
你的第一次。

662
00:33:27,100 --> 00:33:30,640
所以这是伪代码，我们有。

663
00:33:30,640 --> 00:33:35,060
如果你想现在，对不起，请
回到我们最初的问题。

664
00:33:35,060 --> 00:33:37,780
让我们的代码binary.c。

665
00:33:37,780 --> 00:33:40,870
因此，实现一个迭代版本的
使用下面的二进制搜索

666
00:33:40,870 --> 00:33:42,420
函数声明。

667
00:33:42,420 --> 00:33:44,550
>> 而且你也不需要复制
下来，只是还没有。

668
00:33:44,550 --> 00:33:49,470
实际上，我要去开
右上这里binary.c。

669
00:33:49,470 --> 00:33:52,880
因此，有函数声明
在屏幕的中间。

670
00:33:52,880 --> 00:33:57,570
你会看到我拿着伪代码
从我的两侧，但几乎是相同的

671
00:33:57,570 --> 00:33:59,740
什么，我们写的，
把在为你。

672
00:33:59,740 --> 00:34:06,010
所以，现在，让我们花五分钟
编写这个函数。

673
00:34:06,010 --> 00:34:08,199
>> 再次，如果您有任何疑问，
举起你的手，让我知道，我会

674
00:34:08,199 --> 00:34:08,710
来到我身边。

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

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

677
00:34:12,380 --> 00:34:14,429
顶，上线12。

678
00:34:14,429 --> 00:34:16,429
这就是我为我的幻灯片。

679
00:34:16,429 --> 00:34:20,940
然后这一切的伪代码，我只是
复制并从滑动粘贴

680
00:34:20,940 --> 00:34:22,190
伪代码的幻灯片。

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

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

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

684
00:37:13,010 --> 00:37:15,820
>> 所以，如果你已经完成了你的
实现，我要检查它。

685
00:37:15,820 --> 00:37:19,410
我发邮件给你的helpers.h文件
在前面这个类。

686
00:37:19,410 --> 00:37:22,360
这将是在网上以及
下载的人看

687
00:37:22,360 --> 00:37:24,750
本节的时间延迟。

688
00:37:24,750 --> 00:37:29,350
而我只是用一般的分布
从pset3代码。

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

690
00:37:34,590 --> 00:37:36,280
这是由于在分配码。

691
00:37:36,280 --> 00:37:39,310
>> 我不得不做出一个其他变动
find.C而不是调用只是简单地

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

693
00:37:42,770 --> 00:37:49,080
所以，如果你想测试你的代码，
知道这是如何做到这一点。

694
00:37:49,080 --> 00:37:52,530
事实上，当我们将执行这个代码
现在，我只是做副本

695
00:37:52,530 --> 00:37:59,820
我pset3目录，再次换出
佣工文件，然后作出

696
00:37:59,820 --> 00:38:04,695
在find.C改变binary_search的调用
而不是简单的搜索。

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

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

699
00:40:09,120 --> 00:40:11,258
你有问题吗？

700
00:40:11,258 --> 00:40:12,150
>> 学生：没关系。

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

702
00:40:12,600 --> 00:40:13,370
好吧，让我们开始吧。

703
00:40:13,370 --> 00:40:15,090
我们将编写此为一组。

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

705
00:40:16,050 --> 00:40:20,600
再次，这是，可以很容易地进行交换
在对习题集三。

706
00:40:20,600 --> 00:40:25,530
我有我的helpers.h文件，该文件，而
比helpers.h我们给出，

707
00:40:25,530 --> 00:40:28,560
声明二进制搜索，泡
排序和选择排序。

708
00:40:28,560 --> 00:40:37,400
而在find.c你会发现就行，
那是什么，第68行，我们称之为二进制

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

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

711
00:40:42,930 --> 00:40:46,590
创建现在可以很容易地交换
在对p设置3进行检查。

712
00:40:46,590 --> 00:40:50,620
>> 但首先，让我们来编码二进制搜索。

713
00:40:50,620 --> 00:40:53,690
我们的函数声明，
我们返回一个布尔值。

714
00:40:53,690 --> 00:40:55,810
我们采取所谓的整数。

715
00:40:55,810 --> 00:40:59,285
我们以一个整数数组称为
价值观，我们取n是

716
00:40:59,285 --> 00:41:00,850
该数组的大小。

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

718
00:41:05,640 --> 00:41:07,360
有谁知道为什么会在那里？

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

720
00:41:12,180 --> 00:41:16,600
那么，这行代码呢？

721
00:41:16,600 --> 00:41:19,880
>> 学生：它可以让​​你
使用一个bool返回类型。

722
00:41:19,880 --> 00:41:20,350
>> JASON HIRSCHHORN：没错。

723
00:41:20,350 --> 00:41:22,300
>> 学生：或者它是一个库，它允许
使用一个bool返回类型。

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

725
00:41:27,590 --> 00:41:31,340
定义和声明的东西
那我可以使用

726
00:41:31,340 --> 00:41:32,400
这个库。

727
00:41:32,400 --> 00:41:36,570
因此，在那些被说有
这种类型被称为布尔，并且它可以是

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

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

730
00:41:39,010 --> 00:41:41,680
如果我没有那行，我会
惹上麻烦写这

731
00:41:41,680 --> 00:41:43,520
字就在这里，布尔，在那里。

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

733
00:41:44,140 --> 00:41:46,430
所以我需要在这个代码。

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

735
00:41:47,690 --> 00:41:51,860
所以这再一次是一个迭代
版本，而不是递归1。

736
00:41:51,860 --> 00:41:53,820
因此，让我们开始吧。

737
00:41:53,820 --> 00:41:56,200
>> 让我们开始这第一
线的伪代码。

738
00:41:56,200 --> 00:41:58,770
并希望，我们会 - 
或没有希望。

739
00:41:58,770 --> 00:42:00,530
我们要绕过去了房间。

740
00:42:00,530 --> 00:42:05,110
我们会去一行一行的，我会帮助
你弄清楚，我们需要的行

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

742
00:42:06,310 --> 00:42:10,550
因此，尽管名单的长度
大于零。

743
00:42:10,550 --> 00:42:12,680
让我们开始在前面。

744
00:42:12,680 --> 00:42:15,190
我应该写什么线
在这里，在代码中？

745
00:42:15,190 --> 00:42:19,470
>> 学生：虽然括号
n为大于0。

746
00:42:19,470 --> 00:42:21,900
>> JASON HIRSCHHORN：虽然
n是伟大大于0。

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

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

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

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

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

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

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

754
00:42:36,230 --> 00:42:37,710
我忘了解释这一点。

755
00:42:37,710 --> 00:42:41,310
但肯定的。 n为的大小
的列表中，在这种情况下。

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

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

758
00:42:45,580 --> 00:42:50,090
这可能证明是有点问题
不过，如果事情继续下去。

759
00:42:50,090 --> 00:42:54,510
因为我们将继续了解
列表的大小在整个

760
00:42:54,510 --> 00:43:06,640
功能，但说我们开始
与由5个整数的数组。

761
00:43:06,640 --> 00:43:08,950
我们通过和我们已经
现在把范围缩小到

762
00:43:08,950 --> 00:43:10,310
2个整数的数组。

763
00:43:10,310 --> 00:43:12,160
这2个整数是什么？

764
00:43:12,160 --> 00:43:15,895
大小为2，现在我们要
看，但2是什么？

765
00:43:15,895 --> 00:43:17,720
这是否有意义，这问题吗？

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

767
00:43:18,020 --> 00:43:19,120
我会再问吧。

768
00:43:19,120 --> 00:43:26,640
因此，我们用5这个数组开始
整数，n等于5，对不对？

769
00:43:26,640 --> 00:43:28,050
我们将通过这里运行。

770
00:43:28,050 --> 00:43:31,560
我们可能会改变大小，
权利，继续发展下去。

771
00:43:31,560 --> 00:43:32,700
这就是我们说我们想做的事情。

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

773
00:43:34,150 --> 00:43:35,480
所以说，我们将其更改为2。

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

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

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

777
00:43:40,590 --> 00:43:42,780
我为穷人道歉
干擦标记。

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

779
00:43:43,080 --> 00:43:45,670
我们正在寻找通过列表
再次用大小为2的列表。

780
00:43:45,670 --> 00:43:48,580
那么，我们的数组的大小是5还是。

781
00:43:48,580 --> 00:43:51,920
我们说，我们只是想
搜索2点在里面。

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

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

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

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

786
00:44:00,290 --> 00:44:01,940
他们是正确的2点？

787
00:44:01,940 --> 00:44:03,540
是他们中间的2点？

788
00:44:03,540 --> 00:44:06,350
我们已经分手了问题了，我们却
居然不知道其中的一部分

789
00:44:06,350 --> 00:44:11,600
我们仍然在寻找这个问题，
只是通过让这些2变量。

790
00:44:11,600 --> 00:44:16,450
因此，我们需要多一点的话，
而n为大于0。

791
00:44:16,450 --> 00:44:21,410
我们需要知道在哪里
n是在我们实际的数组。

792
00:44:21,410 --> 00:44:26,660
>> 所以，没有任何人有一个
改变这条直线？

793
00:44:26,660 --> 00:44:27,970
大多数这条线是
完全正确的。

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

795
00:44:29,170 --> 00:44:32,510
我们可以交换的东西出来n到
使这条线好一点？

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

797
00:44:32,865 --> 00:44:38,040
>> 学生：你能初始化变量
像长度为n的会被用来

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

799
00:44:39,600 --> 00:44:42,060
>> JASON HIRSCHHORN：所以初始化
可变长度为n，

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

801
00:44:42,900 --> 00:44:47,070
但是，我们刚刚更新的长度和我们
仍然会碰到这个问题，我们

802
00:44:47,070 --> 00:44:51,180
减少我们的问题的长度，
但我们永远不知道，其实，

803
00:44:51,180 --> 00:44:52,510
该长度映射到。

804
00:44:52,510 --> 00:44:54,790
>> 学生：是不是要发生
以后当你说，搜索左，

805
00:44:54,790 --> 00:44:55,746
搜索吧？

806
00:44:55,746 --> 00:44:57,640
你会去一个不同的
您的区域 - 

807
00:44:57,640 --> 00:44:59,110
>> JASON HIRSCHHORN：我们打算去
一个地区，但我们怎么知道

808
00:44:59,110 --> 00:45:01,150
这是去？

809
00:45:01,150 --> 00:45:03,800
如果我们只有数组，这
N，我们怎么知道在哪里

810
00:45:03,800 --> 00:45:05,050
到阵列中。

811
00:45:05,050 --> 00:45:05,900
在后面，是吗？

812
00:45:05,900 --> 00:45:07,507
>> 学生：你有一样，较低的
界和上界变量或

813
00:45:07,507 --> 00:45:08,586
类似的东西？

814
00:45:08,586 --> 00:45:09,060
>> JASON HIRSCHHORN：确定。

815
00:45:09,060 --> 00:45:10,780
所以这是另一种思路。

816
00:45:10,780 --> 00:45:13,490
而不是仅仅跟踪的
大小，我们保持了较低的轨道，

817
00:45:13,490 --> 00:45:14,770
上界变量。

818
00:45:14,770 --> 00:45:17,840
那么，我们如何计算从大小
下限和上限？

819
00:45:17,840 --> 00:45:18,520
>> [插VOICES]

820
00:45:18,520 --> 00:45:19,710
>> JASON HIRSCHHORN：减法。

821
00:45:19,710 --> 00:45:23,650
并且还保持跟踪的下
绑定和上界，让我们知道，

822
00:45:23,650 --> 00:45:26,215
我们正在寻找这两个？

823
00:45:26,215 --> 00:45:28,220
难道我们寻找这两个在这里？

824
00:45:28,220 --> 00:45:29,540
我们正在寻找中间的两个？

825
00:45:29,540 --> 00:45:32,810
也许不是中间的两个，因为
这一点，其实是二进制搜索。

826
00:45:32,810 --> 00:45:37,320
但是，现在我们就可以得到大小，
而且该阵列的界限。

827
00:45:37,320 --> 00:45:40,020
从本质上讲，如果我们有我们的巨人
电话簿，我们撕成两半。

828
00:45:40,020 --> 00:45:42,990
我们现在知道，较小的
电话簿。

829
00:45:42,990 --> 00:45:45,260
但我们实际上并不翻录
电话簿的一半。

830
00:45:45,260 --> 00:45:48,570
我们还需要知道在哪里
我们的问题的新范围是。

831
00:45:48,570 --> 00:45:51,645
没有任何人有任何疑问，
有关？

832
00:45:51,645 --> 00:45:52,440
是吗？

833
00:45:52,440 --> 00:45:56,020
>> 学生：它会通过创建工作
变量i，你然后就转移

834
00:45:56,020 --> 00:46:00,770
我相对于它的位置
当前位置，并且长度中，n？

835
00:46:00,770 --> 00:46:01,710
>> JASON HIRSCHHORN：什么是我？

836
00:46:01,710 --> 00:46:04,110
>> 学生：就像我是喜欢那种 - 

837
00:46:04,110 --> 00:46:08,040
就像你会初始化我是
阵列的中间位置。

838
00:46:08,040 --> 00:46:12,540
然后，如果在位置i的值在
在阵列的发现中间

839
00:46:12,540 --> 00:46:17,870
低于您所需要的价值，我现在
成为该阵列的长度，加上

840
00:46:17,870 --> 00:46:19,215
i的值除以2。

841
00:46:19,215 --> 00:46:20,270
像，看，你转向我 - 

842
00:46:20,270 --> 00:46:20,770
>> JASON HIRSCHHORN：对。

843
00:46:20,770 --> 00:46:21,165
>> 学生： - 到 - 

844
00:46:21,165 --> 00:46:24,010
>> JASON HIRSCHHORN：所以我几乎
正面，将工作。

845
00:46:24,010 --> 00:46:26,800
但问题是，你需要两个
件的信息在这里。

846
00:46:26,800 --> 00:46:30,050
您可以用开头和结尾做，
或者你可以用大小做，然后

847
00:46:30,050 --> 00:46:31,060
一些标记。

848
00:46:31,060 --> 00:46:32,630
但你需要两件
此处的信息。

849
00:46:32,630 --> 00:46:34,160
你不能用只有一个。

850
00:46:34,160 --> 00:46:35,830
这是否有道理？

851
00:46:35,830 --> 00:46:39,560
>> 所以，我们要通过，并
我们要做的[听不清]

852
00:46:39,560 --> 00:46:41,330
并创建一些标记。

853
00:46:41,330 --> 00:46:42,690
所以，你在你的代码写的什么了？

854
00:46:42,690 --> 00:46:46,190
>> 学生：我刚才说的整型界
1等于0。

855
00:46:46,190 --> 00:46:47,790
>> JASON HIRSCHHORN：让我们把
这个int，开始。

856
00:46:47,790 --> 00:46:49,140
>> 学生：确定。

857
00:46:49,140 --> 00:46:50,590
>> JASON HIRSCHHORN：这使得
更有意义对我来说。

858
00:46:50,590 --> 00:46:51,670
和？

859
00:46:51,670 --> 00:46:54,340
>> 学生：我说，我猜，廉政结束。

860
00:46:54,340 --> 00:46:55,870
>> JASON HIRSCHHORN：INT结束。

861
00:46:55,870 --> 00:46:57,640
>> 学生：我猜，N减1，
或者类似的东西。

862
00:46:57,640 --> 00:46:59,100
像，最后一个元素。

863
00:46:59,100 --> 00:47:02,310
>> JASON HIRSCHHORN：所以你写，诠释
开始等于0，分号和INT

864
00:47:02,310 --> 00:47:04,320
结局等于n，减去1，分号。

865
00:47:04,320 --> 00:47:06,850
所以基本上，我们在做什么
这里，0的第一个位置。

866
00:47:06,850 --> 00:47:09,570
正如我们所知道的阵列，他们不走
最多n，它们上升到n减去1。

867
00:47:09,570 --> 00:47:11,110
因此，我们有我们的数组的一些界限。

868
00:47:11,110 --> 00:47:15,730
而这些初始范围恰好是
我们的问题的初始边界。

869
00:47:15,730 --> 00:47:16,640
确定。

870
00:47:16,640 --> 00:47:19,200
所以这听起来不错。

871
00:47:19,200 --> 00:47:22,380
然后，如果我们再回到这一行，而
列表的长度是大于0，

872
00:47:22,380 --> 00:47:24,752
什么，而不是n，应
我们摆在这里？

873
00:47:24,752 --> 00:47:28,820
>> 学生：写结束减去开始。

874
00:47:28,820 --> 00:47:34,780
>> JASON HIRSCHHORN：虽然结束负
开始是大于0？

875
00:47:34,780 --> 00:47:35,480
确定。

876
00:47:35,480 --> 00:47:37,730
我们可以，如果我们想
做一个更好一点，有什么

877
00:47:37,730 --> 00:47:38,980
我们还能做什么？

878
00:47:38,980 --> 00:47:41,650

879
00:47:41,650 --> 00:47:43,412
如果我们想要清理
这段代码了一点？

880
00:47:43,412 --> 00:47:46,716

881
00:47:46,716 --> 00:47:48,180
我们怎样才能摆脱0？

882
00:47:48,180 --> 00:47:51,560

883
00:47:51,560 --> 00:47:52,690
这仅仅是一个风格问题。

884
00:47:52,690 --> 00:47:53,690
这是正确的现在。

885
00:47:53,690 --> 00:47:54,870
>> 学生：期末不
等于开始？

886
00:47:54,870 --> 00:47:55,740
>> JASON HIRSCHHORN：我们可以做什么呢？

887
00:47:55,740 --> 00:47:56,730
>> [插VOICES]

888
00:47:56,730 --> 00:47:57,330
>> 学生：期末更大？

889
00:47:57,330 --> 00:47:57,720
>> JASON HIRSCHHORN：是啊。

890
00:47:57,720 --> 00:48:01,110
我们可以在刚刚结束的做
大于开始。

891
00:48:01,110 --> 00:48:03,580
右。

892
00:48:03,580 --> 00:48:06,240
我们增加了开始的另一边
那，我们摆脱了0。

893
00:48:06,240 --> 00:48:08,000
因此，这只是看起来
点点清洁剂。

894
00:48:08,000 --> 00:48:08,990
确定。

895
00:48:08,990 --> 00:48:11,460
因此，尽管名单的长度为0，我们写
，虽然结局是更大

896
00:48:11,460 --> 00:48:12,240
比开始。

897
00:48:12,240 --> 00:48:19,840
我们打​​算把我们的需要
大括号，然后第一件事

898
00:48:19,840 --> 00:48:22,090
我们想要做的是看
他们在一个小列表。

899
00:48:22,090 --> 00:48:22,510
你呢？

900
00:48:22,510 --> 00:48:23,320
你可以给我 - 

901
00:48:23,320 --> 00:48:26,460
>> 学生：如果括号
价值括号 - 

902
00:48:26,460 --> 00:48:30,450
>> JASON HIRSCHHORN：如果括号
值的方括号。

903
00:48:30,450 --> 00:48:33,210
>> 学生：结束除以2。

904
00:48:33,210 --> 00:48:33,952
>> JASON HIRSCHHORN：结束？

905
00:48:33,952 --> 00:48:35,280
>> 学生：我看到你的一个问题 - 

906
00:48:35,280 --> 00:48:35,750
>> JASON HIRSCHHORN：确定。

907
00:48:35,750 --> 00:48:39,150
好吧，看在中间。

908
00:48:39,150 --> 00:48:41,226
我们怎么知道中间是什么？

909
00:48:41,226 --> 00:48:42,450
是啊。

910
00:48:42,450 --> 00:48:43,070
因此，让我删除那些代码。

911
00:48:43,070 --> 00:48:46,360
我们怎么知道中间是什么？

912
00:48:46,360 --> 00:48:48,003
在任何事情，当你有初
而最终，你怎么找到

913
00:48:48,003 --> 00:48:48,876
中间？

914
00:48:48,876 --> 00:48:49,590
>> 学生：你平均。

915
00:48:49,590 --> 00:48:51,820
>> 学生：你将它们添加
在一起，然后 - 

916
00:48:51,820 --> 00:48:53,150
>> JASON HIRSCHHORN：加入他们
在一起，然后？

917
00:48:53,150 --> 00:48:54,090
>> 学生：你平均。

918
00:48:54,090 --> 00:48:55,050
除以2。

919
00:48:55,050 --> 00:48:56,500
>> JASON HIRSCHHORN：加入他们
在一起，除以2。

920
00:48:56,500 --> 00:48:59,400
所以整型中间等于？

921
00:48:59,400 --> 00:49:01,120
汤姆，你可以把它送给我吗？

922
00:49:01,120 --> 00:49:03,550
>> 学生：期初加期末 - 

923
00:49:03,550 --> 00:49:04,950
>> JASON HIRSCHHORN：开始
加上结束。

924
00:49:04,950 --> 00:49:06,880
>> 学生：全部，支架，除以2。

925
00:49:06,880 --> 00:49:10,940
>> JASON HIRSCHHORN：所有在括号，
除以2。

926
00:49:10,940 --> 00:49:16,300
所以，让我中间
任何事物，正确吗？

927
00:49:16,300 --> 00:49:18,980
>> 学生：你还需要它向上舍入。

928
00:49:18,980 --> 00:49:19,990
>> JASON HIRSCHHORN：你这是什么
意思是，我需要它向上舍入？

929
00:49:19,990 --> 00:49:20,400
>> [插VOICES]

930
00:49:20,400 --> 00:49:24,520
>> 学生：因为，如果这是一个奇怪的
号码，然后它就像 - 

931
00:49:24,520 --> 00:49:25,440
>> JASON HIRSCHHORN：嗯，好吧。

932
00:49:25,440 --> 00:49:26,360
这样我就可以把它向上舍。

933
00:49:26,360 --> 00:49:33,350
但如果它是奇数，5，我可以
服用1远离中间。

934
00:49:33,350 --> 00:49:35,665
或者，如果它是偶数，相反，
这是一个更好的情况。

935
00:49:35,665 --> 00:49:39,600
如果是4，我们只有4，我可以带
第一个“中间”，报价，引文或

936
00:49:39,600 --> 00:49:41,760
第二个“中间”之一。

937
00:49:41,760 --> 00:49:46,390
要么将工作二进制搜索，
所以我实际上并不需要圆形的。

938
00:49:46,390 --> 00:49:48,640
但有一件事我
需要看看这条线。

939
00:49:48,640 --> 00:49:50,530
我们可能没有意识到这一点，
但我们会回来的。

940
00:49:50,530 --> 00:49:53,200
因为这条线实际上仍然
需要一件事。

941
00:49:53,200 --> 00:49:55,990
>> 但到目前为止，我们已经写了
四行代码。

942
00:49:55,990 --> 00:49:58,120
我们已经得到了我们的开始
和结束标记。

943
00:49:58,120 --> 00:50:01,320
我们有我们的while循环，它映射
对直接向我们的伪代码。

944
00:50:01,320 --> 00:50:05,790
我们正在寻找一个映射中间
直接到我们的伪代码。

945
00:50:05,790 --> 00:50:09,070
我会说这正好到中间
名单，这行代码。

946
00:50:09,070 --> 00:50:11,560
然后，一旦我们去的中间
在列表中，我们需要做的下一件事

947
00:50:11,560 --> 00:50:14,880
被检查，如果我们的价值如何，
伪代码，我们之前写的。

948
00:50:14,880 --> 00:50:17,100
>> 那么我们该如何检查，如果我们的价值
在列表的中间？

949
00:50:17,100 --> 00:50:17,300
您。

950
00:50:17,300 --> 00:50:18,511
你为什么不这样做呢？

951
00:50:18,511 --> 00:50:23,070
>> 学生：如果我们的价值的是
在中间是等于

952
00:50:23,070 --> 00:50:24,592
无论我们设定 - 

953
00:50:24,592 --> 00:50:26,190
我的意思是等于等于 - 

954
00:50:26,190 --> 00:50:26,690
>> JASON HIRSCHHORN：它 - 

955
00:50:26,690 --> 00:50:27,940
确定。

956
00:50:27,940 --> 00:50:30,080

957
00:50:30,080 --> 00:50:32,170
>> 学生：我不知道是什么
变量，我们正在寻找

958
00:50:32,170 --> 00:50:32,850
因为虽然，是因为 - 

959
00:50:32,850 --> 00:50:33,330
>> [插VOICES]

960
00:50:33,330 --> 00:50:34,520
>> 学生：[听不清]。

961
00:50:34,520 --> 00:50:35,060
>> JASON HIRSCHHORN：没错。

962
00:50:35,060 --> 00:50:37,260
每个函数的声明，
我们正在寻找一个值。

963
00:50:37,260 --> 00:50:39,760
所以，我们正在寻找一个值
在值的数组。

964
00:50:39,760 --> 00:50:41,080
所以你完全正确。

965
00:50:41,080 --> 00:50:45,040
你会做，如果开放的括号值支架
中间闭合支架等号

966
00:50:45,040 --> 00:50:49,930
等于价值，里面有
什么我们需要做什么？

967
00:50:49,930 --> 00:50:51,230
如果我们的价值的存在，是什么
我们需要做什么？

968
00:50:51,230 --> 00:50:51,420
>> [插VOICES]

969
00:50:51,420 --> 00:50:52,160
>> 学生：返回零。

970
00:50:52,160 --> 00:50:53,070
>> JASON HIRSCHHORN：返回true。

971
00:50:53,070 --> 00:50:54,790
>> 学生：返回true。

972
00:50:54,790 --> 00:50:57,856
>> JASON HIRSCHHORN：迈克尔，
这是什么线路呢？

973
00:50:57,856 --> 00:51:01,105
>> 学生：[听不清]程序已经运行
它的路线，那就是结束了，

974
00:51:01,105 --> 00:51:01,920
你已经什么你需要做什么？

975
00:51:01,920 --> 00:51:03,030
>> JASON HIRSCHHORN：程序还是什么？

976
00:51:03,030 --> 00:51:03,700
在这种情况下？

977
00:51:03,700 --> 00:51:04,210
>> 学生：该功能。

978
00:51:04,210 --> 00:51:05,170
>> JASON HIRSCHHORN：该功能。

979
00:51:05,170 --> 00:51:08,420
因此，要返回到任何所谓的
它并给它的价值，真正的。

980
00:51:08,420 --> 00:51:09,890
完全正确。

981
00:51:09,890 --> 00:51:10,170
主。

982
00:51:10,170 --> 00:51:12,035
什么是返回类型
主，迈克尔？

983
00:51:12,035 --> 00:51:16,480

984
00:51:16,480 --> 00:51:17,150
>> 学生：整型，整型？

985
00:51:17,150 --> 00:51:18,080
>> JASON HIRSCHHORN：整型，没错。

986
00:51:18,080 --> 00:51:18,680
一个整数。

987
00:51:18,680 --> 00:51:20,980
这仅仅是一个问题，以确保
你们已经在它的上面。

988
00:51:20,980 --> 00:51:24,250
这是什么通常会返回，如果
所有的东西都运作良好？

989
00:51:24,250 --> 00:51:24,520
>> 学生：零。

990
00:51:24,520 --> 00:51:24,820
>> JASON HIRSCHHORN：零。

991
00:51:24,820 --> 00:51:25,430
完全正确。

992
00:51:25,430 --> 00:51:28,790
>> 学生：如果这只是返回true，
没有信息报错

993
00:51:28,790 --> 00:51:30,675
关于什么的 - 

994
00:51:30,675 --> 00:51:34,040
呵呵，这只是说了
值的数组里面。

995
00:51:34,040 --> 00:51:35,350
>> JASON HIRSCHHORN：没错。

996
00:51:35,350 --> 00:51:38,080
这个程序没有提供资料
的确切位置值。

997
00:51:38,080 --> 00:51:41,850
它只是说，是的，我们发现
它，或者没有，我们没有发现它。

998
00:51:41,850 --> 00:51:42,990
所以，如果发现号，返回true。

999
00:51:42,990 --> 00:51:45,500
嗯，其实我们只是做了真正
迅速与一行代码。

1000
00:51:45,500 --> 00:51:47,500
因此，我将动议该行伪代码的。

1001
00:51:47,500 --> 00:51:50,045
>> 学生：不，我们需要
改变数组？

1002
00:51:50,045 --> 00:51:52,830
它应该是值，而不是价值，对不对？

1003
00:51:52,830 --> 00:51:53,430
>> JASON HIRSCHHORN：对不起。

1004
00:51:53,430 --> 00:51:54,010
谢谢。

1005
00:51:54,010 --> 00:51:54,800
>> 学生：是啊。

1006
00:51:54,800 --> 00:51:55,850
>> JASON HIRSCHHORN：此行
应该是价值观。

1007
00:51:55,850 --> 00:51:57,150
完全正确。

1008
00:51:57,150 --> 00:51:57,920
确定。

1009
00:51:57,920 --> 00:51:59,170
因此，我们已经看了看中间列表。

1010
00:51:59,170 --> 00:52:00,790
如果发现号返回true。

1011
00:52:00,790 --> 00:52:04,470
我们的伪代码继续，如果
中间是更大的，搜索就走了。

1012
00:52:04,470 --> 00:52:09,640
所以，我在这里，如果数
更高，搜索就走了。

1013
00:52:09,640 --> 00:52:12,700

1014
00:52:12,700 --> 00:52:14,462
康斯坦丁，你可以给
我这行代码？

1015
00:52:14,462 --> 00:52:17,240

1016
00:52:17,240 --> 00:52:23,520
>> 学生：如果中间值 - 

1017
00:52:23,520 --> 00:52:24,890
>> JASON HIRSCHHORN：所以，如果值 - 

1018
00:52:24,890 --> 00:52:28,890
如果开括号值支架
中间靠近支架 - 

1019
00:52:28,890 --> 00:52:31,500
>> 学生：是不是值小？

1020
00:52:31,500 --> 00:52:32,760
>> JASON HIRSCHHORN：是小于。

1021
00:52:32,760 --> 00:52:33,800
>> 学生：比价值减。

1022
00:52:33,800 --> 00:52:34,060
>> JASON HIRSCHHORN：值。

1023
00:52:34,060 --> 00:52:35,310
嗯，其实，你要
检查数量 - 

1024
00:52:35,310 --> 00:52:38,310

1025
00:52:38,310 --> 00:52:38,490
抱歉。

1026
00:52:38,490 --> 00:52:39,140
这是一个有点混乱。

1027
00:52:39,140 --> 00:52:43,920
但如果其他的数
名单的中间是更大的。

1028
00:52:43,920 --> 00:52:45,170
>> 学生：哦，好吧。

1029
00:52:45,170 --> 00:52:49,800

1030
00:52:49,800 --> 00:52:50,410
>> JASON HIRSCHHORN：我会改变这种状况。

1031
00:52:50,410 --> 00:52:55,060
否则，如果中间是较高的，我们
要搜索左，好不好？

1032
00:52:55,060 --> 00:52:57,310
而我们该怎么做内部
这一点，如果条件？

1033
00:52:57,310 --> 00:53:03,660

1034
00:53:03,660 --> 00:53:07,510
>> 学生：我可以做一个小改动
的情况下，如果将其更改为别的吗？

1035
00:53:07,510 --> 00:53:08,380
>> JASON HIRSCHHORN：否则，如果？

1036
00:53:08,380 --> 00:53:09,270
确定。

1037
00:53:09,270 --> 00:53:12,840
所以这段代码将执行
大致相同。

1038
00:53:12,840 --> 00:53:18,620
但是如果左右，其他使用好处
如果，否则，如果还是如果，否则，如果，否则

1039
00:53:18,620 --> 00:53:22,320
也就是说，只有其中的一个是要
进行检查，而不是他们三个，

1040
00:53:22,320 --> 00:53:23,290
可能。

1041
00:53:23,290 --> 00:53:25,530
这使得它一点点
电脑这是上更好

1042
00:53:25,530 --> 00:53:26,670
运行你的程序。

1043
00:53:26,670 --> 00:53:27,620
>> 所以，[？康斯坦丁？]

1044
00:53:27,620 --> 00:53:31,330
我们这一行里面，否则，如果值，
支架中间右方括号

1045
00:53:31,330 --> 00:53:32,260
大于价值。

1046
00:53:32,260 --> 00:53:33,150
什么是我们需要做什么？

1047
00:53:33,150 --> 00:53:33,970
我们需要搜索的左侧。

1048
00:53:33,970 --> 00:53:35,220
我们该怎么做呢？

1049
00:53:35,220 --> 00:53:46,960

1050
00:53:46,960 --> 00:53:48,720
我想给你一个开始。

1051
00:53:48,720 --> 00:53:52,210
>> 我们有这两样东西叫
开始和结束。

1052
00:53:52,210 --> 00:53:57,340
因此，需要做些什么
要开始？

1053
00:53:57,340 --> 00:53:59,640
如果您要搜索的左边
列表中，我们得到我们当前开始的。

1054
00:53:59,640 --> 00:54:01,080
我们需要什么做的呢？

1055
00:54:01,080 --> 00:54:04,220
>> 学生：我们设置开始
到中间加1。

1056
00:54:04,220 --> 00:54:05,120
>> JASON HIRSCHHORN：所以，如果我们
寻找左侧？

1057
00:54:05,120 --> 00:54:06,250
>> 学生：对不起，中间减去 - 

1058
00:54:06,250 --> 00:54:11,310
这样的结局会是中间
减1和开始 - 

1059
00:54:11,310 --> 00:54:12,450
>> JASON HIRSCHHORN：什么
碰巧的开始？

1060
00:54:12,450 --> 00:54:13,210
>> 学生：它保持不变。

1061
00:54:13,210 --> 00:54:14,120
>> JASON HIRSCHHORN：所以
含义保持不变。

1062
00:54:14,120 --> 00:54:16,040
如果我们在搜索的左边，我们
使用相同的开头 - 

1063
00:54:16,040 --> 00:54:16,860
完全正确。

1064
00:54:16,860 --> 00:54:17,870
而故事的结局？

1065
00:54:17,870 --> 00:54:19,390
对不起，什么是
再次结束平等的吗？

1066
00:54:19,390 --> 00:54:20,750
>> 学生：中减去1。

1067
00:54:20,750 --> 00:54:21,620
>> JASON HIRSCHHORN：中减去1。

1068
00:54:21,620 --> 00:54:23,470
现在，为什么减1，不只是中间？

1069
00:54:23,470 --> 00:54:32,870

1070
00:54:32,870 --> 00:54:35,570
>> 学生：中间是出
图片已经，因为我们有

1071
00:54:35,570 --> 00:54:36,700
检查它的呢？

1072
00:54:36,700 --> 00:54:37,630
>> JASON HIRSCHHORN：这是
完全正确。

1073
00:54:37,630 --> 00:54:38,580
中间是出来的图片。

1074
00:54:38,580 --> 00:54:39,800
我们已经检查了中间。

1075
00:54:39,800 --> 00:54:44,730
所以，我们不希望“中间，”报价
引文结束后，继续在该

1076
00:54:44,730 --> 00:54:46,110
数组，我们正在寻找。

1077
00:54:46,110 --> 00:54:47,670
因此，这是梦幻般的。

1078
00:54:47,670 --> 00:54:50,670
>> 否则，如果值支架中间是更大
比值等于结束

1079
00:54:50,670 --> 00:54:51,920
中间减1。

1080
00:54:51,920 --> 00:54:55,060

1081
00:54:55,060 --> 00:54:57,340
杰夫，你看这个最后一行？

1082
00:54:57,340 --> 00:54:58,590
>> 学生：否则。

1083
00:54:58,590 --> 00:55:02,486

1084
00:55:02,486 --> 00:55:06,000
中间值小于值？

1085
00:55:06,000 --> 00:55:07,570
>> JASON HIRSCHHORN：我们会
你给我的东西。

1086
00:55:07,570 --> 00:55:09,310
所以，如果你不给我 - 

1087
00:55:09,310 --> 00:55:12,270
>> 学生：所以后来开始
将中间加1。

1088
00:55:12,270 --> 00:55:16,100

1089
00:55:16,100 --> 00:55:19,070
>> JASON HIRSCHHORN：平等开始
中间加1，再一次，对于相同的

1090
00:55:19,070 --> 00:55:20,820
原因是君士坦丁
给了我们前面。

1091
00:55:20,820 --> 00:55:24,280
并在最后，谁没有给
我的代码行了吗？

1092
00:55:24,280 --> 00:55:26,600
返回false，Aleha什么
我们写在这里？

1093
00:55:26,600 --> 00:55:28,590
>> 学生：返回false。

1094
00:55:28,590 --> 00:55:29,320
>> JASON HIRSCHHORN：返回false。

1095
00:55:29,320 --> 00:55:33,340
而我们需要做的，因为如果我们
并不觉得，我们需要说我们

1096
00:55:33,340 --> 00:55:34,080
没有发现它。

1097
00:55:34,080 --> 00:55:36,270
和我们说我们要返回一个
布尔，所以我们肯定是要返回

1098
00:55:36,270 --> 00:55:38,150
一个bool地方。

1099
00:55:38,150 --> 00:55:42,590
>> 因此，让我们运行此代码。

1100
00:55:42,590 --> 00:55:44,520
实际上，我要 - 

1101
00:55:44,520 --> 00:55:45,930
所以我们在终端。

1102
00:55:45,930 --> 00:55:47,230
我们将清除我们的窗口。

1103
00:55:47,230 --> 00:55:49,270
让我们把所有的。

1104
00:55:49,270 --> 00:55:50,340
我们发现有一个错误。

1105
00:55:50,340 --> 00:55:54,280
还有第15行错误，预期
分号的结束

1106
00:55:54,280 --> 00:55:54,890
声明。

1107
00:55:54,890 --> 00:55:56,454
所以，我怎么忘了？

1108
00:55:56,454 --> 00:55:57,230
>> 学生：分号。

1109
00:55:57,230 --> 00:56:00,200
>> JASON HIRSCHHORN：分号
直到这里。

1110
00:56:00,200 --> 00:56:00,950
我认为这是汤姆的代码。

1111
00:56:00,950 --> 00:56:01,870
因此，汤姆，[听不清]。

1112
00:56:01,870 --> 00:56:03,120
只是在开玩笑。

1113
00:56:03,120 --> 00:56:05,010

1114
00:56:05,010 --> 00:56:07,310
让我们做所有的再制作。

1115
00:56:07,310 --> 00:56:10,180
>> 学生：什么Dropbox的目录
我们应该在这？

1116
00:56:10,180 --> 00:56:11,345
>> JASON HIRSCHHORN：所以，你可以
只是看这一点。

1117
00:56:11,345 --> 00:56:16,380
但同样，如果你想提出这个
代码到您的pset3目录试试

1118
00:56:16,380 --> 00:56:17,050
出来，这就是我所做的。

1119
00:56:17,050 --> 00:56:18,600
如果你会发现在这里 - 
对不起，很好的问题。

1120
00:56:18,600 --> 00:56:19,460
>> [？ LS，？]

1121
00:56:19,460 --> 00:56:24,700
我在这里find.c代码
从本周的发行版的代码。

1122
00:56:24,700 --> 00:56:26,300
我有helpers.h。

1123
00:56:26,300 --> 00:56:30,010
我有一个Make文件我实际上是
编辑了一下，包括这些新

1124
00:56:30,010 --> 00:56:30,710
我们正在编写的文件。

1125
00:56:30,710 --> 00:56:34,120
所有这些代码将是可用的，不
分配的代码，但新

1126
00:56:34,120 --> 00:56:39,510
制作文件，新helpers.h文件将
是下载在网上提供。

1127
00:56:39,510 --> 00:56:41,800
同样地，所以这些都是在
额外的代码，我们有。

1128
00:56:41,800 --> 00:56:46,130
>> 因此，请所有，每本线，使得查找，
二，泡选择 - 品牌

1129
00:56:46,130 --> 00:56:50,930
他们三个都和编译成
这个可执行文件代码中找到。

1130
00:56:50,930 --> 00:56:54,090
所以一般情况下，我们不希望
直到check50。

1131
00:56:54,090 --> 00:56:57,580
我们要对我们自己运行一些测试。

1132
00:56:57,580 --> 00:57:11,750
但是，仅仅如此可加快我们这一点，
check50 2013 pset3.find将通过

1133
00:57:11,750 --> 00:57:14,630
在helpers.c- - 我的坏。

1134
00:57:14,630 --> 00:57:16,050
>> 我没有说现在。

1135
00:57:16,050 --> 00:57:20,670
因此，我们实际上是要
运行实际的代码。

1136
00:57:20,670 --> 00:57:23,570
Usage.find /，你知道这意味着什么？

1137
00:57:23,570 --> 00:57:25,970
>> 学生：你需要第二个
在它的命令行。

1138
00:57:25,970 --> 00:57:26,980
>> JASON HIRSCHHORN：我需要
第二个命令行。

1139
00:57:26,980 --> 00:57:30,640
并根据规范要求，我需要
进入我们正在寻找的东西。

1140
00:57:30,640 --> 00:57:33,750
因此，让我们来看看42。

1141
00:57:33,750 --> 00:57:37,030
我们将保持它在排序的，因为我们
没有写一个排序功能，但 - 

1142
00:57:37,030 --> 00:57:41,830
42，43，44。

1143
00:57:41,830 --> 00:57:46,240
>> 和控制D没找到
大海捞针。

1144
00:57:46,240 --> 00:57:46,505
这是不好的。

1145
00:57:46,505 --> 00:57:47,200
这是肯定有的。

1146
00:57:47,200 --> 00:57:48,090
让我们试试别的。

1147
00:57:48,090 --> 00:57:49,860
也许这是因为我把
它在开始。

1148
00:57:49,860 --> 00:57:54,490
>> 让我们做41，42，43。

1149
00:57:54,490 --> 00:57:55,012
我们走吧。

1150
00:57:55,012 --> 00:57:56,400
它发现了它。

1151
00:57:56,400 --> 00:58:00,040
让我们把它在结束现在，只
所以我们可以彻底的 - 

1152
00:58:00,040 --> 00:58:03,580
40，41，42。

1153
00:58:03,580 --> 00:58:05,760
没有找到针头。

1154
00:58:05,760 --> 00:58:07,550
所以我提到这点。

1155
00:58:07,550 --> 00:58:08,980
不幸的是，我知道这
将要发生。

1156
00:58:08,980 --> 00:58:11,490
>> 但用于教学目的，
这是很好的探索它。

1157
00:58:11,490 --> 00:58:12,990
这是行不通的。

1158
00:58:12,990 --> 00:58:16,020
出于某种原因，它无法找到它。

1159
00:58:16,020 --> 00:58:18,970
我们知道什么是在那里，但
我们目前还没有找到它。

1160
00:58:18,970 --> 00:58:24,140
所以，有一件事我们可以做的是通过
GDB找到它，但确实有人，

1161
00:58:24,140 --> 00:58:27,850
无需通过GDB，有
在哪里，我们搞砸了有意义吗？

1162
00:58:27,850 --> 00:58:28,480
[？摩杜？ ？]

1163
00:58:28,480 --> 00:58:30,960
>> 学生：我想可能是结束的时候
等于开头，它的

1164
00:58:30,960 --> 00:58:33,090
只是一个元素的列表。

1165
00:58:33,090 --> 00:58:35,560
然后，它会忽略它，而不是
实际检查它。

1166
00:58:35,560 --> 00:58:36,940
>> JASON HIRSCHHORN：这是
完全正确。

1167
00:58:36,940 --> 00:58:41,110
当结束等于开始，我们做
还有在我们的列表中的元素？

1168
00:58:41,110 --> 00:58:42,480
>> 学生：是的。

1169
00:58:42,480 --> 00:58:45,450
>> JASON HIRSCHHORN：是的，事实上，我们
有一个且仅有一个元件。

1170
00:58:45,450 --> 00:58:50,500
而这将极有可能发生时，
每次我们测试过的代码，我们在

1171
00:58:50,500 --> 00:58:54,640
干草堆或柜台
干草堆的结束。

1172
00:58:54,640 --> 00:58:56,000
这就是开始和
结局是要等于

1173
00:58:56,000 --> 00:58:57,820
之一，二分查找。

1174
00:58:57,820 --> 00:59:01,440
因此，在这两个情况下，没有工作，
因为结束等于开始。

1175
00:59:01,440 --> 00:59:06,030
>> 但是，如果结束等于开始，
这是否while循环执行？

1176
00:59:06,030 --> 00:59:06,390
它没有。

1177
00:59:06,390 --> 00:59:08,660
而且我们也可以检查
这再通过GDB。

1178
00:59:08,660 --> 00:59:14,000
那么，如何才能解决这个问题的代码，因为
当结束时等于

1179
00:59:14,000 --> 00:59:16,070
开始，我们也希望这
while循环运行。

1180
00:59:16,070 --> 00:59:18,620
>> 因此，我们可以做什么修复到第18行？

1181
00:59:18,620 --> 00:59:21,060
>> 学生：[听不清]大
小于或等于。

1182
00:59:21,060 --> 00:59:21,700
>> JASON HIRSCHHORN：完全正确。

1183
00:59:21,700 --> 00:59:24,600
虽然结局是大于
或等于开始。

1184
00:59:24,600 --> 00:59:27,300
所以，现在，我们一定要得到那
角落的情况在年底。

1185
00:59:27,300 --> 00:59:27,870
让我们来看看。

1186
00:59:27,870 --> 00:59:29,560
让我们运行此一次。

1187
00:59:29,560 --> 00:59:31,266
>> 让我们所有。

1188
00:59:31,266 --> 00:59:33,910
同样，你必须只
跟着在这里。

1189
00:59:33,910 --> 00:59:36,280
找到41这个时间。

1190
00:59:36,280 --> 00:59:37,360
只要保持一致。

1191
00:59:37,360 --> 00:59:38,210
>> 找到42。

1192
00:59:38,210 --> 00:59:38,930
让我们把它在开始 - 

1193
00:59:38,930 --> 00:59:41,630
42，43，44。

1194
00:59:41,630 --> 00:59:42,860
我们发现了它。

1195
00:59:42,860 --> 00:59:47,710
所以这的确是变化
我们需要做。

1196
00:59:47,710 --> 00:59:51,090
>> 这是一个很大的编码，我们的
只是做了，二进制搜索。

1197
00:59:51,090 --> 00:59:55,760
没有任何人有之前的任何问题
我谨对为我们写了线

1198
00:59:55,760 --> 00:59:58,750
二进制搜索或者我们怎么想通
什么我们没有搞清楚？

1199
00:59:58,750 --> 01:00:01,900

1200
01:00:01,900 --> 01:00:06,270
在我们继续之前，我也想点
指出，总的来说，我们映射

1201
01:00:06,270 --> 01:00:09,300
我们的伪代码之一
1到我们的代码。

1202
01:00:09,300 --> 01:00:11,550
>> 我们确实有一个棘手的事情
找出与

1203
01:00:11,550 --> 01:00:12,890
开始和结束。

1204
01:00:12,890 --> 01:00:17,380
但你有没有计算过了，你
会写相当多的

1205
01:00:17,380 --> 01:00:20,740
相同的代码，保存为
那些最上面两行。

1206
01:00:20,740 --> 01:00:23,380
然后你会意识到，当
您在检查和案件有否规定

1207
01:00:23,380 --> 01:00:24,840
你需要别的东西。

1208
01:00:24,840 --> 01:00:28,510
所以，即使你曾跟随我们
伪代码行来行，你就已经

1209
01:00:28,510 --> 01:00:31,130
得到了所有，但两行
你需要编写代码。

1210
01:00:31,130 --> 01:00:33,900
>> 而我愿意打赌，你们
本来都想通了这一点

1211
01:00:33,900 --> 01:00:37,940
很快，你需要把
某种标志物在有图

1212
01:00:37,940 --> 01:00:39,190
出你在哪里。

1213
01:00:39,190 --> 01:00:41,540

1214
01:00:41,540 --> 01:00:44,550
这又是干什么的力量
伪代码的时间提前。

1215
01:00:44,550 --> 01:00:47,310
所以我们可以做的逻辑，然后再
大家可以放心使用的语法。

1216
01:00:47,310 --> 01:00:51,470
>> 如果我们一直感到困惑的逻辑
而试图写这段代码在C中，

1217
01:00:51,470 --> 01:00:53,110
我们会得到全乱了。

1218
01:00:53,110 --> 01:00:56,340
然后我们就可以问的问题
逻辑和语法和网格

1219
01:00:56,340 --> 01:00:57,320
它们放在一起。

1220
01:00:57,320 --> 01:01:02,170
我们会得到丢失
在哪可以迅速成为一个

1221
01:01:02,170 --> 01:01:04,000
非常棘手的问题。

1222
01:01:04,000 --> 01:01:08,680
现在让我们继续前进
要选择排序。

1223
01:01:08,680 --> 01:01:10,760
>> 我们还剩下20分钟。

1224
01:01:10,760 --> 01:01:14,130
所以，我有，我们将不能够感觉
通过所有选择排序的获得

1225
01:01:14,130 --> 01:01:15,940
和冒泡排序。

1226
01:01:15,940 --> 01:01:20,670
但是，让我们至少尝试
完成选择排序。

1227
01:01:20,670 --> 01:01:23,540
因此，实现选择排序使用
下面的函数声明。

1228
01:01:23,540 --> 01:01:27,530
>> 再次，这是从
问题设置规范。

1229
01:01:27,530 --> 01:01:31,560
int值是括号，是
整数数组。

1230
01:01:31,560 --> 01:01:33,490
和int.n是该数组的大小。

1231
01:01:33,490 --> 01:01:36,840
选择排序是怎么回事
这个数组进行排序。

1232
01:01:36,840 --> 01:01:43,580
>> 因此，根据我们的心智选择的模型
排序，我们拉 - 

1233
01:01:43,580 --> 01:01:47,720
首先，我们通过列表中的第一
时间，找到最小的数字，

1234
01:01:47,720 --> 01:01:52,860
把它放在开头，找到第二
最小的数字，把它放在

1235
01:01:52,860 --> 01:01:56,380
如果我们要第二位置
排序按升序排序。

1236
01:01:56,380 --> 01:01:58,440
我不会强迫你写
伪代码现在。

1237
01:01:58,440 --> 01:02:01,350
>> 但在此之前我们做的代码作为一个阶级的
五分钟，我们将写

1238
01:02:01,350 --> 01:02:03,550
伪代码，所以我们有一些感
的我们要去的地方。

1239
01:02:03,550 --> 01:02:05,630
因此，尝试写伪代码
在你自己的。

1240
01:02:05,630 --> 01:02:08,610
然后再尝试打开该
伪代码转换成代码。

1241
01:02:08,610 --> 01:02:10,740
我们将做到这一点作为一个群体
在五分钟内。

1242
01:02:10,740 --> 01:02:32,560

1243
01:02:32,560 --> 01:02:33,895
>> 当然，让我知道，如果
您有任何问题。

1244
01:02:33,895 --> 01:03:56,738

1245
01:03:56,738 --> 01:03:58,230
>> 学生：那呢？

1246
01:03:58,230 --> 01:04:00,280
>> JASON HIRSCHHORN：看看有多少你
可以在两分钟搞定。

1247
01:04:00,280 --> 01:04:01,790
我知道你不会
能够完成。

1248
01:04:01,790 --> 01:04:03,050
但我们将在此为一组。

1249
01:04:03,050 --> 01:04:57,830

1250
01:04:57,830 --> 01:05:00,630
>> 你所有的编码等等[听不清]，所以我
对不起暂停自己在做什么。

1251
01:05:00,630 --> 01:05:02,530
但是，让我们通过这作为一个群体。

1252
01:05:02,530 --> 01:05:07,590
再次，二分查找，大家给
我一个，如果没有更多行的代码。

1253
01:05:07,590 --> 01:05:08,530
谢谢你的。

1254
01:05:08,530 --> 01:05:11,730
我们打​​算做同样的事情
这里，作为一组一起码。

1255
01:05:11,730 --> 01:05:15,170
>> 所以，选择排序 - 让我们写
一些快速的伪代码。

1256
01:05:15,170 --> 01:05:20,380
每心智模式，可以有人给我
第一线的伪代码，好吗？

1257
01:05:20,380 --> 01:05:23,000

1258
01:05:23,000 --> 01:05:24,270
我想要什么做的？

1259
01:05:24,270 --> 01:05:27,070
>> 学生：虽然名单
出了毛病。

1260
01:05:27,070 --> 01:05:30,630
>> JASON HIRSCHHORN：OK，而
该列表是不合乎规程。

1261
01:05:30,630 --> 01:05:33,540
和你是什么意思“坏了？”

1262
01:05:33,540 --> 01:05:34,960
>> 学生：在[听不清]

1263
01:05:34,960 --> 01:05:36,210
没有被排序。

1264
01:05:36,210 --> 01:05:38,460

1265
01:05:38,460 --> 01:05:40,290
>> JASON HIRSCHHORN：虽然名单
出了毛病，我们该怎么办？

1266
01:05:40,290 --> 01:05:44,200
给我的第二行，
请，马库斯。

1267
01:05:44,200 --> 01:05:47,186
>> 学生：所以找到下一个
最小的数字。

1268
01:05:47,186 --> 01:05:49,000
这将缩进。

1269
01:05:49,000 --> 01:05:55,140
>> JASON HIRSCHHORN：所以找到
下一个最小的数。

1270
01:05:55,140 --> 01:05:56,460
然后别人？

1271
01:05:56,460 --> 01:06:01,030
一旦我们找到下一个最小的
数，我们该怎么做？

1272
01:06:01,030 --> 01:06:03,010
我要说找
的最小数量。

1273
01:06:03,010 --> 01:06:04,820
这就是我们想要做的。

1274
01:06:04,820 --> 01:06:06,210
>> 因此，找到最小的数字。

1275
01:06:06,210 --> 01:06:08,061
那么我们该怎么做？

1276
01:06:08,061 --> 01:06:09,480
>> 学生：[听不清]为开端。

1277
01:06:09,480 --> 01:06:10,680
>> JASON HIRSCHHORN：对不起？

1278
01:06:10,680 --> 01:06:12,700
>> 学生：在将其放置
开始列表。

1279
01:06:12,700 --> 01:06:18,540
>> JASON HIRSCHHORN：所以把它放在
在列表的开头。

1280
01:06:18,540 --> 01:06:20,140
而我们做的事情是什么
这是在开始

1281
01:06:20,140 --> 01:06:20,830
列表中的，对不对？

1282
01:06:20,830 --> 01:06:21,910
我们覆盖的东西。

1283
01:06:21,910 --> 01:06:23,130
那么，我们把那？

1284
01:06:23,130 --> 01:06:24,120
是啊，安娜？

1285
01:06:24,120 --> 01:06:25,520
>> 学生：其中最小
数字是？

1286
01:06:25,520 --> 01:06:32,530
>> JASON赫希洪：所以把开始
列表中的其中

1287
01:06:32,530 --> 01:06:35,180
最小的数字了。

1288
01:06:35,180 --> 01:06:38,510
因此，尽管名单已经出来的顺序，找到
最小的数字，将其放置在

1289
01:06:38,510 --> 01:06:40,630
该列表的开头，把
开始列表的其中

1290
01:06:40,630 --> 01:06:42,900
最小的数字了。

1291
01:06:42,900 --> 01:06:45,780
马库斯，你可以整理这条线
而名单已经出来了的秩序？

1292
01:06:45,780 --> 01:06:51,160

1293
01:06:51,160 --> 01:06:53,900
>> 学生：虽然数字
未分类的？

1294
01:06:53,900 --> 01:06:55,920
>> JASON赫希洪：OK，所以为了
知道这些数字都没有

1295
01:06:55,920 --> 01:06:58,670
排序的，什么是我们需要做什么？

1296
01:06:58,670 --> 01:07:00,640
有多少，我们需要
通过这个名单？

1297
01:07:00,640 --> 01:07:09,650
>> 学生：所以我想一个for循环，或
同时，在检查数量较少

1298
01:07:09,650 --> 01:07:11,900
比列表的长度是多少？

1299
01:07:11,900 --> 01:07:13,160
>> JASON赫希洪：好，这是很好的。

1300
01:07:13,160 --> 01:07:15,000
我想我misphrased
我的问题知之甚少。

1301
01:07:15,000 --> 01:07:15,990
我只是试图让在
我们将不得不去

1302
01:07:15,990 --> 01:07:17,580
在整个列表。

1303
01:07:17,580 --> 01:07:20,490
因此，尽管名单已经出来的顺序，
对我来说，是很难地图。

1304
01:07:20,490 --> 01:07:24,940
但基本上，这就是如何
我想这个问题。

1305
01:07:24,940 --> 01:07:28,880
通过整个列表中，找到
最小数，将其放置在

1306
01:07:28,880 --> 01:07:30,130
开始 - 其实，你说得对。

1307
01:07:30,130 --> 01:07:31,380
让我们把他们两个。

1308
01:07:31,380 --> 01:07:33,470

1309
01:07:33,470 --> 01:07:39,050
>> 因此，尽管名单已经出来了的订单，我们
需要经过整个列表

1310
01:07:39,050 --> 01:07:42,250
一次，找到最小的数字，地点
它在列表的开头，把

1311
01:07:42,250 --> 01:07:45,430
在列表的开头，其中
最小数目是，然后，如果

1312
01:07:45,430 --> 01:07:47,460
列表仍然失灵，我们已经
得去通过这个

1313
01:07:47,460 --> 01:07:48,620
进程再次，对不对？

1314
01:07:48,620 --> 01:07:51,610
这就是为什么选择排序，大O运行
选择排序的，任何人吗？

1315
01:07:51,610 --> 01:07:52,830
>> 学生：无平方。

1316
01:07:52,830 --> 01:07:53,590
>> JASON赫希洪：无平方。

1317
01:07:53,590 --> 01:07:57,040
因为像马库斯，我才意识到
在这里，我们将不得不

1318
01:07:57,040 --> 01:08:00,310
通过列表名单
的次数。

1319
01:08:00,310 --> 01:08:03,420
所以，经历的事
长度为n的n次号

1320
01:08:03,420 --> 01:08:04,990
其实是在Ñ平方。

1321
01:08:04,990 --> 01:08:08,100
>> 所以这是我们的伪代码。

1322
01:08:08,100 --> 01:08:09,360
这看起来很不错。

1323
01:08:09,360 --> 01:08:11,870
没有任何人有任何疑问，
关于伪？

1324
01:08:11,870 --> 01:08:14,440
因为实际上选择排序应该
大概要一对一，代码

1325
01:08:14,440 --> 01:08:14,980
伪代码。

1326
01:08:14,980 --> 01:08:17,569
因此，任何有关问题
伪代码的逻辑是什么？

1327
01:08:17,569 --> 01:08:18,819
现在请提问。

1328
01:08:18,819 --> 01:08:22,609

1329
01:08:22,609 --> 01:08:25,379
>> 选择排序 - 而名单已经出来了
的顺序，我们将通过它

1330
01:08:25,379 --> 01:08:27,529
并找出最小的每次
并把它放在前面。

1331
01:08:27,529 --> 01:08:33,470
因此，尽管名单已经出来了，可以顺序
有人给我说行代码谁

1332
01:08:33,470 --> 01:08:39,689
还没有给我行
然而，代码好吗？

1333
01:08:39,689 --> 01:08:40,939
这听起来像一个什么？

1334
01:08:40,939 --> 01:08:43,669

1335
01:08:43,669 --> 01:08:44,649
>> 学生：这是一个for循环。

1336
01:08:44,649 --> 01:08:45,830
>> JASON赫希洪：听起来
喜欢一个for循环。

1337
01:08:45,830 --> 01:08:47,653
OK，你可以给我的for循环？

1338
01:08:47,653 --> 01:08:48,925
对于 - 

1339
01:08:48,925 --> 01:08:50,219
>> 学生：我等于0。

1340
01:08:50,219 --> 01:08:52,705
>> JASON赫希洪：我还是 - 

1341
01:08:52,705 --> 01:08:55,111
什么是我们缺少什么？

1342
01:08:55,111 --> 01:08:56,819
善有善报就在这里？

1343
01:08:56,819 --> 01:08:57,550
>> 学生：诠释。

1344
01:08:57,550 --> 01:08:59,270
>> JASON赫希洪：没错。

1345
01:08:59,270 --> 01:09:02,590
（INT I = 0;  - 

1346
01:09:02,590 --> 01:09:07,843
>> 学生：我<N; i + +）。

1347
01:09:07,843 --> 01:09:09,319
>> JASON赫希洪：钉它，杰夫。

1348
01:09:09,319 --> 01:09:10,660
我们正在经历的列表中，右键？

1349
01:09:10,660 --> 01:09:11,880
我们以前见过的代码。

1350
01:09:11,880 --> 01:09:12,850
完美的。

1351
01:09:12,850 --> 01:09:14,790
所以，让我们把我们的大括号在这里。

1352
01:09:14,790 --> 01:09:17,859
我打算把一些
大括号在这里。

1353
01:09:17,859 --> 01:09:21,660
>> 因此，尽管它是0，我们需要去
整个列表。

1354
01:09:21,660 --> 01:09:26,612
所以每次我们去通过列表，
什么我们想跟踪的？

1355
01:09:26,612 --> 01:09:28,260
>> 学生：如果有任何掉期进行。

1356
01:09:28,260 --> 01:09:29,069
>> JASON赫希洪：查找
的最小数量。

1357
01:09:29,069 --> 01:09:31,479
因此，我们或许应该跟踪
最小的数字各一次。

1358
01:09:31,479 --> 01:09:34,590
所以，行，我可以做些什么来保持跟踪
最小是多少？

1359
01:09:34,590 --> 01:09:37,720
Aleha，我怎么能保持
轨道的东西？

1360
01:09:37,720 --> 01:09:38,460
>> 学生：开始一个新的变量。

1361
01:09:38,460 --> 01:09:39,390
>> JASON赫希洪：开始一个新的变量。

1362
01:09:39,390 --> 01:09:40,069
因此，让我们创建一个变量。

1363
01:09:40,069 --> 01:09:41,830
什么类型的？

1364
01:09:41,830 --> 01:09:42,930
>> 学生：诠释。

1365
01:09:42,930 --> 01:09:43,710
>> JASON赫希洪：诠释。

1366
01:09:43,710 --> 01:09:44,939
让我们把它称为最小的。

1367
01:09:44,939 --> 01:09:47,600
以及它等于什么时候
我们刚刚起步的？

1368
01:09:47,600 --> 01:09:48,910
我们并没有在列表中消失了呢。

1369
01:09:48,910 --> 01:09:50,540
我们在的第一部分
通过列出我们的第一次。

1370
01:09:50,540 --> 01:09:51,930
什么是平等的，
最小的数字？

1371
01:09:51,930 --> 01:09:54,140
>> 学生：我的值。

1372
01:09:54,140 --> 01:09:54,900
>> JASON赫希洪：值I。

1373
01:09:54,900 --> 01:09:56,980
这听起来完全正确的，对不对？

1374
01:09:56,980 --> 01:09:59,590
最小数目的开头
就是我们在哪里。

1375
01:09:59,590 --> 01:10:01,960
所以现在我们有我们最小的，我们需要
要经过整个列表和

1376
01:10:01,960 --> 01:10:05,080
比较这最小的
到一切。

1377
01:10:05,080 --> 01:10:08,150
那么，我们通过清单了吗？

1378
01:10:08,150 --> 01:10:08,630
迈克尔？

1379
01:10:08,630 --> 01:10:10,000
>> 学生：你需要做
另一个循环。

1380
01:10:10,000 --> 01:10:10,383
>> JASON赫希洪：另一个for循环。

1381
01:10:10,383 --> 01:10:11,276
让我们开始吧。

1382
01:10:11,276 --> 01:10:12,540
给我一些代码。

1383
01:10:12,540 --> 01:10:13,790
>> 学生：For循环 - 

1384
01:10:13,790 --> 01:10:16,750

1385
01:10:16,750 --> 01:10:19,470
为最小 - 

1386
01:10:19,470 --> 01:10:23,040

1387
01:10:23,040 --> 01:10:25,770
只是诠释J，你可以说？

1388
01:10:25,770 --> 01:10:31,150
= 0;使得 - 

1389
01:10:31,150 --> 01:10:34,014

1390
01:10:34,014 --> 01:10:35,710
>> JASON赫希洪：嗯，如果我们想
要经过整个列表 - 

1391
01:10:35,710 --> 01:10:37,847
>> 学生：百灵<N，J + +）。

1392
01:10:37,847 --> 01:10:42,140

1393
01:10:42,140 --> 01:10:42,405
>> JASON赫希洪：神奇。

1394
01:10:42,405 --> 01:10:46,100
我们将通过
for循环一次。

1395
01:10:46,100 --> 01:10:51,380
我们如何找到
最小的数字？

1396
01:10:51,380 --> 01:10:52,630
汤姆？

1397
01:10:52,630 --> 01:10:54,570

1398
01:10:54,570 --> 01:11:00,520
我们目前最小的数字，
那么如何才能找到新的最小？

1399
01:11:00,520 --> 01:11:07,200
>> 学生：我们可以检查最小
我们也数大于

1400
01:11:07,200 --> 01:11:09,040
重视支架Ĵ。

1401
01:11:09,040 --> 01:11:14,740
>> JASON赫希洪：所以，如果最小的是
比数值支架Ĵ更大。

1402
01:11:14,740 --> 01:11:19,350
因此，如果我们目前最小的
大于 - 

1403
01:11:19,350 --> 01:11:21,770
我要在这两个线
对于第二个在那里的代码。

1404
01:11:21,770 --> 01:11:26,010
因为之前我们做任何交换，我们
需要经过整个列表。

1405
01:11:26,010 --> 01:11:28,880
所以这个伪代码实际上应该
在外面的内循环。

1406
01:11:28,880 --> 01:11:30,390
这样下去整个列表。

1407
01:11:30,390 --> 01:11:34,520
如果最小的大于
值Ĵ然后呢？

1408
01:11:34,520 --> 01:11:37,830
>> 学生：那最小的
等于值Ĵ。

1409
01:11:37,830 --> 01:11:41,190

1410
01:11:41,190 --> 01:11:42,600
>> JASON赫希洪：神奇。

1411
01:11:42,600 --> 01:11:44,580
一个简单的问题 - 

1412
01:11:44,580 --> 01:11:47,236
我们第一次去通过这个循环，
我是怎么回事等于0，J是怎么回事

1413
01:11:47,236 --> 01:11:50,710
等于0，一旦我们在这里得到的。

1414
01:11:50,710 --> 01:11:52,410
所以，我们要进行比较
一个数字本身。

1415
01:11:52,410 --> 01:11:53,660
是有效的？

1416
01:11:53,660 --> 01:11:57,260

1417
01:11:57,260 --> 01:11:58,390
不，这不是真的有效。

1418
01:11:58,390 --> 01:12:02,915
因此，没有我们的Ĵ需要去
从0到n每次？

1419
01:12:02,915 --> 01:12:06,310
我们总是需要检查
整个列表？

1420
01:12:06,310 --> 01:12:06,520
[听不清]？

1421
01:12:06,520 --> 01:12:07,564
>> 学生：开始我代替。

1422
01:12:07,564 --> 01:12:09,405
>> JASON赫希洪：j的
先从什么？

1423
01:12:09,405 --> 01:12:09,990
>> 学生：我。

1424
01:12:09,990 --> 01:12:13,040
>> JASON赫希洪：j的与我开始。

1425
01:12:13,040 --> 01:12:18,840
所以，现在我们开始比较
有一个我们的。

1426
01:12:18,840 --> 01:12:21,020
但即便如此，是因为
尽可能高效？

1427
01:12:21,020 --> 01:12:22,320
>> 学生：我+ 1。

1428
01:12:22,320 --> 01:12:25,420
>> JASON赫希洪：I + 1似乎是
最有效的，因为我们

1429
01:12:25,420 --> 01:12:26,120
已经有我。

1430
01:12:26,120 --> 01:12:28,100
我们指出，由于
最小的线15。

1431
01:12:28,100 --> 01:12:29,350
我们将开始与
自动下单。

1432
01:12:29,350 --> 01:12:34,470

1433
01:12:34,470 --> 01:12:38,540
所以，我们通过for循环。

1434
01:12:38,540 --> 01:12:39,620
我们将通过各一次。

1435
01:12:39,620 --> 01:12:40,860
我们将通过数次。

1436
01:12:40,860 --> 01:12:42,860
现在，我们通过已经得到了
这种内在的for循环。

1437
01:12:42,860 --> 01:12:44,350
我们有最小的值保存。

1438
01:12:44,350 --> 01:12:46,045
我们需要将其放置在
开始列表。

1439
01:12:46,045 --> 01:12:48,390
所以，我怎么把它放置在
开始清单？

1440
01:12:48,390 --> 01:12:51,290

1441
01:12:51,290 --> 01:12:55,926
这是指该变量
到列表的开始？

1442
01:12:55,926 --> 01:13:00,500
我们在此为外循环，
还等什么指

1443
01:13:00,500 --> 01:13:01,280
开始清单？

1444
01:13:01,280 --> 01:13:02,880
>> 学生：我的值。

1445
01:13:02,880 --> 01:13:03,510
>> JASON赫希洪：完全正确。

1446
01:13:03,510 --> 01:13:04,650
值i是的开始 - 

1447
01:13:04,650 --> 01:13:06,320
或不好意思，不是开始。

1448
01:13:06,320 --> 01:13:07,090
这是令人困惑的。

1449
01:13:07,090 --> 01:13:11,620
这也正是我们在年初
列表中的未排序的部分。

1450
01:13:11,620 --> 01:13:12,800
因此，重视我。

1451
01:13:12,800 --> 01:13:14,050
而这是什么平等？

1452
01:13:14,050 --> 01:13:15,925

1453
01:13:15,925 --> 01:13:17,326
>> 学生：最小。

1454
01:13:17,326 --> 01:13:18,862
>> JASON赫希洪：值i等于什么？

1455
01:13:18,862 --> 01:13:19,310
>> 学生：最小。

1456
01:13:19,310 --> 01:13:20,030
>> JASON赫希洪：最小。

1457
01:13:20,030 --> 01:13:20,980
完全正确。

1458
01:13:20,980 --> 01:13:23,510
所以我们将它放在开头
名单的，现在我们需要把

1459
01:13:23,510 --> 01:13:25,710
该列表的开始的地方
最小的数字了。

1460
01:13:25,710 --> 01:13:29,700
所以，我怎么写的地方
最小的数是？

1461
01:13:29,700 --> 01:13:31,670
什么价值观？

1462
01:13:31,670 --> 01:13:33,170
>> 学生：0。

1463
01:13:33,170 --> 01:13:34,090
>> JASON赫希洪：小
数字是0？

1464
01:13:34,090 --> 01:13:35,340
>> 学生：是啊。

1465
01:13:35,340 --> 01:13:38,680

1466
01:13:38,680 --> 01:13:39,910
>> JASON赫希洪：那如果最小
人数在年底

1467
01:13:39,910 --> 01:13:40,860
这个无序列表？

1468
01:13:40,860 --> 01:13:42,460
>> 学生：对不起，究竟是什么问题？

1469
01:13:42,460 --> 01:13:44,020
>> JASON赫希洪：哪里是
最小的数字？

1470
01:13:44,020 --> 01:13:46,940
我们采取了最小，并把它在
开始，这条线就在这里。

1471
01:13:46,940 --> 01:13:48,987
>> 学生：它应该有
被存储在某种 - 

1472
01:13:48,987 --> 01:13:50,510
>> 学生：值Ĵ。

1473
01:13:50,510 --> 01:13:51,520
>> JASON赫希洪：嗯，这是
不一定值Ĵ。

1474
01:13:51,520 --> 01:13:54,100
它甚至没有在这一点上存在。

1475
01:13:54,100 --> 01:13:55,960
>> 学生：你要申报
一个变量更早，

1476
01:13:55,960 --> 01:13:58,230
然后将其分配到 - 

1477
01:13:58,230 --> 01:14:01,150
当你发现的最小的数字，
该号码的索引分配给

1478
01:14:01,150 --> 01:14:02,480
一些变量或类似的东西。

1479
01:14:02,480 --> 01:14:04,790
>> JASON赫希洪：所以可以
你再说一遍吗？

1480
01:14:04,790 --> 01:14:08,390
>> 学生：那么，您声明整型
最小的，你也应该申报诠释

1481
01:14:08,390 --> 01:14:10,750
最小的index = i或
类似的东西。

1482
01:14:10,750 --> 01:14:13,280
>> JASON赫希洪：那么，我INT
最小的，我不应该只跟踪

1483
01:14:13,280 --> 01:14:16,150
的价值，但位置。

1484
01:14:16,150 --> 01:14:20,850
整型smallest_location =在这
情况下，我们就做我。

1485
01:14:20,850 --> 01:14:22,390
我们需要知道它在哪里。

1486
01:14:22,390 --> 01:14:26,820
我们到了代码的末尾，我们
意识到我们根本不知道在哪里。

1487
01:14:26,820 --> 01:14:29,810
于是再次，我们的映射
这在一一对应的。

1488
01:14:29,810 --> 01:14:32,890
你们在自己的意志编码这种
可能得到了同样的问题。

1489
01:14:32,890 --> 01:14:34,130
如何赫克我找到它？

1490
01:14:34,130 --> 01:14:36,720
然后你意识到，等待，我
需要跟踪的那个。

1491
01:14:36,720 --> 01:14:38,500
>> 所以，如果最小的是更大
比的值Ĵ。

1492
01:14:38,500 --> 01:14:39,740
我们设定最小等于值Ĵ。

1493
01:14:39,740 --> 01:14:42,090
我们需要改变什么？

1494
01:14:42,090 --> 01:14:43,710
康斯坦丁，还有什么
我们需要改变？

1495
01:14:43,710 --> 01:14:44,560
>> 学生：位置。

1496
01:14:44,560 --> 01:14:45,270
>> JASON赫希洪：没错。

1497
01:14:45,270 --> 01:14:46,925
所以给我的代码行。

1498
01:14:46,925 --> 01:14:53,310
>> 学生：smallest_location = j的。

1499
01:14:53,310 --> 01:14:54,790
>> JASON赫希洪：没错。

1500
01:14:54,790 --> 01:14:58,210
然后降底，如果我们想
放在列表的开头，其中

1501
01:14:58,210 --> 01:15:00,790
最小的数字是，如何
我们指该

1502
01:15:00,790 --> 01:15:02,200
最小的数是？

1503
01:15:02,200 --> 01:15:03,580
马库斯？

1504
01:15:03,580 --> 01:15:08,530
>> 学生：最小数为
位于最小位置。

1505
01:15:08,530 --> 01:15:12,230
>> JASON赫希洪：所以在价值观
smallest_location。

1506
01:15:12,230 --> 01:15:14,700
而我们放什么呢？

1507
01:15:14,700 --> 01:15:17,600
的初
列表中，那是什么？

1508
01:15:17,600 --> 01:15:19,710
>> 学生：嗯，我们真的不知道
了，因为我们改写。

1509
01:15:19,710 --> 01:15:23,250
所以这是一个交换位置
在这两行？

1510
01:15:23,250 --> 01:15:26,110
如果你周围的切换这两行。

1511
01:15:26,110 --> 01:15:30,740
>> JASON赫希洪：好了，我们不
了，因为我们已经复位线

1512
01:15:30,740 --> 01:15:31,960
前值i到最小。

1513
01:15:31,960 --> 01:15:33,810
所以我们失去了初始值。

1514
01:15:33,810 --> 01:15:37,350
所以你说的交换这两行。

1515
01:15:37,350 --> 01:15:41,780
所以现在把列表的开头
其中最小的数是。

1516
01:15:41,780 --> 01:15:47,060
所以smallest_location等于值I。

1517
01:15:47,060 --> 01:15:51,310
这是移动今年年初
的列表中的未排序的部分

1518
01:15:51,310 --> 01:15:52,090
最小的位置。

1519
01:15:52,090 --> 01:15:54,860
然后进入我的值我们正在
即最小数。

1520
01:15:54,860 --> 01:15:57,450
>> 这是否有意义，为什么我们
不得不作出这样的交换？

1521
01:15:57,450 --> 01:15:59,650
我们会覆盖该值 - 
另一件事，你可能会有

1522
01:15:59,650 --> 01:16:02,740
想通了，并在国内生产总值中找到。

1523
01:16:02,740 --> 01:16:05,310
因此，我们已经照顾
所有的伪代码。

1524
01:16:05,310 --> 01:16:10,935
还有什么我们
需要在这里写？

1525
01:16:10,935 --> 01:16:14,911
有谁能够想到什么？

1526
01:16:14,911 --> 01:16:16,180
>> 学生：你怎么知道
当你做了什么？

1527
01:16:16,180 --> 01:16:17,680
>> JASON赫希洪：我们如何
知道什么时候我们做了什么？

1528
01:16:17,680 --> 01:16:18,890
大的问题。

1529
01:16:18,890 --> 01:16:21,684
那么，我们如何知道什么时候，我们就大功告成了。

1530
01:16:21,684 --> 01:16:24,720
>> 学生：创建一个变量来计数
如果有做了一个交换与否

1531
01:16:24,720 --> 01:16:27,810
并办理了一通。

1532
01:16:27,810 --> 01:16:30,180
>> JASON赫希洪：确定。

1533
01:16:30,180 --> 01:16:31,800
将工作在冒泡排序。

1534
01:16:31,800 --> 01:16:35,210
但对于选择排序，如果我们不这样做
做一个交换，那可能只是

1535
01:16:35,210 --> 01:16:38,670
因为最小的值是
在它正确的位置。

1536
01:16:38,670 --> 01:16:41,240
我们可能有一个列表1，2，4，3。

1537
01:16:41,240 --> 01:16:42,830
通过我们的第二次
不会让任何掉期。

1538
01:16:42,830 --> 01:16:47,260
我们将在2号，但我们会
仍然需要继续下去。

1539
01:16:47,260 --> 01:16:49,390
那么，我们需要跟踪的时候
我们就大功告成了，还是我们只是想去

1540
01:16:49,390 --> 01:16:50,640
直到完成？

1541
01:16:50,640 --> 01:16:54,098

1542
01:16:54,098 --> 01:16:56,740
>> 学生：我们可以去
直到它完成。

1543
01:16:56,740 --> 01:16:58,090
>> JASON赫希洪：我们可以只
去，直到这个完成。

1544
01:16:58,090 --> 01:17:01,720
在冒泡排序，你是完全正确的，
杰夫和Aleha，与您的解决方案 - 

1545
01:17:01,720 --> 01:17:04,990
它是伟大的跟踪有多少
掉期你做，因为在泡沫

1546
01:17:04,990 --> 01:17:07,920
排序，如果你实际上做不作任何掉期，
大功告成，你也许可以减少你

1547
01:17:07,920 --> 01:17:09,000
问题倒有几分。

1548
01:17:09,000 --> 01:17:11,440
但对于选择排序，你真的
有要经过的结束

1549
01:17:11,440 --> 01:17:14,940
列出在每个时间。

1550
01:17:14,940 --> 01:17:16,200
>> 因此，这是一点。

1551
01:17:16,200 --> 01:17:18,530
我们有两分钟时间。

1552
01:17:18,530 --> 01:17:21,560
让我们所有。

1553
01:17:21,560 --> 01:17:24,340
让我开在这里找到，让
相信我，其实调出 - 

1554
01:17:24,340 --> 01:17:25,610
我不是叫冒泡排序。

1555
01:17:25,610 --> 01:17:29,230
让我们改变这个来选择排序。

1556
01:17:29,230 --> 01:17:31,060
使所有/找到。

1557
01:17:31,060 --> 01:17:32,360
让我们来看看42。

1558
01:17:32,360 --> 01:17:38,110
这一次，我们要传递一个
未排序的列表中，因为它应该排序

1559
01:17:38,110 --> 01:17:43,790
首先，每找到代码 - 要排序
第一次使用我们的排序函数，然后

1560
01:17:43,790 --> 01:17:44,995
寻找的东西。

1561
01:17:44,995 --> 01:17:46,245
手指交叉大家。

1562
01:17:46,245 --> 01:17:48,530

1563
01:17:48,530 --> 01:17:49,370
>> 哦，我的天啊。

1564
01:17:49,370 --> 01:17:50,800
哇，我的心脏跳动。

1565
01:17:50,800 --> 01:17:52,320
所以这是正确的。

1566
01:17:52,320 --> 01:17:57,270
事实上，如果我们跑这更
大量的代码，尽我所能

1567
01:17:57,270 --> 01:17:59,280
说，是完全正确的。

1568
01:17:59,280 --> 01:18:02,150
还有一些建议
我会为你。

1569
01:18:02,150 --> 01:18:06,215
例如，15和16似乎
有点多余。

1570
01:18:06,215 --> 01:18:09,450
好像你不一定
需要保存这两个。

1571
01:18:09,450 --> 01:18:12,790
如果您有最小的位置，你
可以很容易地找到最小值

1572
01:18:12,790 --> 01:18:14,750
只是打字的i值。

1573
01:18:14,750 --> 01:18:18,100
>> 所以，如果我是被分级代码，
我其实会，我会

1574
01:18:18,100 --> 01:18:21,160
大概起飞点，如果你
包括这两种，因为你

1575
01:18:21,160 --> 01:18:22,670
不需要这两个。

1576
01:18:22,670 --> 01:18:25,400
如果你有位置，可以
很容易获得的价值。

1577
01:18:25,400 --> 01:18:27,520
这似乎有点不可思议
来存储它们。

1578
01:18:27,520 --> 01:18:31,070
也许不拿一个点，而是
当然评论说，这也许是

1579
01:18:31,070 --> 01:18:32,670
不是一个风格上的选择
你需要做。

1580
01:18:32,670 --> 01:18:35,290
当然，该代码仍然
运转很好。

1581
01:18:35,290 --> 01:18:36,860
>> 所以很遗憾，我们没
得到冒泡排序。

1582
01:18:36,860 --> 01:18:37,940
我很抱歉这一点。

1583
01:18:37,940 --> 01:18:39,135
我们确实完成选择排序。

1584
01:18:39,135 --> 01:18:41,450
没有任何人有任何问题，最终
关于选择排序？

1585
01:18:41,450 --> 01:18:44,320

1586
01:18:44,320 --> 01:18:47,690
>> 好了，我们才探出头来，我要你
打开你的Chrome浏览器。

1587
01:18:47,690 --> 01:18:54,340
对不起，这仅仅是一个赤裸裸的插头
一种类型的互联网浏览器。

1588
01:18:54,340 --> 01:18:57,770
你可以打开任何类型的浏览器，
但它很可能是Chrome浏览器。

1589
01:18:57,770 --> 01:19:01,250
和去这个网站之后 - 

1590
01:19:01,250 --> 01:19:06,410
sayat.me/cs50。

1591
01:19:06,410 --> 01:19:07,685
如果你不键入您的电脑
现在，你是清楚的

1592
01:19:07,685 --> 01:19:10,210
不这样做，汤姆。

1593
01:19:10,210 --> 01:19:12,870
>> 并且请做任何权利
现在还是在接下来的一个小时 - 

1594
01:19:12,870 --> 01:19:14,260
给我一些反馈。

1595
01:19:14,260 --> 01:19:15,660
这只是部分中的两个。

1596
01:19:15,660 --> 01:19:18,060
我们有更多的共同拥有的，所以我
有很多的提升空间。

1597
01:19:18,060 --> 01:19:19,620
我希望也做了一些事情做好。

1598
01:19:19,620 --> 01:19:22,160
所以，你可以让我觉得全是坏事，但如果
你也想​​给我一个笑脸

1599
01:19:22,160 --> 01:19:24,250
脸，我将不胜感激这一点。

1600
01:19:24,250 --> 01:19:25,330
填补英寸

1601
01:19:25,330 --> 01:19:28,210
>> 并与留一分钟，
这是三周。

1602
01:19:28,210 --> 01:19:30,750
我就站在外面了一下
如果您有任何疑问。

1603
01:19:30,750 --> 01:19:32,220
我会看到你们
讲课的明天。

1604
01:19:32,220 --> 01:19:34,742