1
00:00:00,000 --> 00:00:10,982

2
00:00:10,982 --> 00:00:11,940
大卫马兰：好吧。

3
00:00:11,940 --> 00:00:16,470
所以这是CS50，这是
现在3周的开始。

4
00:00:16,470 --> 00:00:19,960
>> 所以到现在为止，我们已经
在写程序用C

5
00:00:19,960 --> 00:00:23,210
这看起来有点
这样的事情在这里。

6
00:00:23,210 --> 00:00:25,470
所以，我们有几个
尖锐包括在顶部。

7
00:00:25,470 --> 00:00:28,490
我们已经得到了诠释，主要的，无效的，并
然后事情做在中间，

8
00:00:28,490 --> 00:00:30,590
一些代码位内
的该功能。

9
00:00:30,590 --> 00:00:34,170
但重点一直事实
我们一直在说空在这里。

10
00:00:34,170 --> 00:00:39,320
因此作废，这一切的时候，指定
这个程序在运行时，

11
00:00:39,320 --> 00:00:41,300
只能通过其名称来运行。

12
00:00:41,300 --> 00:00:46,330
你不能输入其他文字或
该程序的名称时数后，

13
00:00:46,330 --> 00:00:46,830
运行它。

14
00:00:46,830 --> 00:00:51,200
因此，例如，如果节目是
编译成一个名为hello的文件，

15
00:00:51,200 --> 00:00:53,480
你可以做./hello，但就是这样。

16
00:00:53,480 --> 00:00:56,750
>> 唯一的办法，你可以
提供输入到该程序

17
00:00:56,750 --> 00:00:57,960
是通过调用一个函数。

18
00:00:57,960 --> 00:00:59,790
例如，什么功能
使用迄今还我们一直

19
00:00:59,790 --> 00:01:00,950
以获得来自用户的输入？

20
00:01:00,950 --> 00:01:02,117
>> 听众：获取字符串。

21
00:01:02,117 --> 00:01:04,700
大卫马兰：要获得字符串，或
得到int或你见过其他人，

22
00:01:04,700 --> 00:01:07,630
即使你没有使用它们，
喜欢弄长，长，等等。

23
00:01:07,630 --> 00:01:09,380
但是，假如我们
其实要开始

24
00:01:09,380 --> 00:01:12,760
编写程序是多一点
多才多艺，而且，坦率地说，多一点

25
00:01:12,760 --> 00:01:15,090
就像你已经命令
已经越来越有希望，

26
00:01:15,090 --> 00:01:16,550
有点习惯了。

27
00:01:16,550 --> 00:01:18,560
如CD空间的Dropbox。

28
00:01:18,560 --> 00:01:20,800
此，当然，改变
您的目录，假设

29
00:01:20,800 --> 00:01:23,590
你在约翰·哈佛的家
目录到你的Dropbox文件夹。

30
00:01:23,590 --> 00:01:27,380
同时，这样的命令
创建一个名为pset2新目录，

31
00:01:27,380 --> 00:01:30,290
正如你可能已经或
很快就会在问题设置两个。

32
00:01:30,290 --> 00:01:33,970
当然，做出喂，是一个命令
即建立了一项名为招呼

33
00:01:33,970 --> 00:01:35,770
从一个叫你好点C文件。

34
00:01:35,770 --> 00:01:39,140
和在每个这些
的情况下，现在，我们已经有

35
00:01:39,140 --> 00:01:43,620
在所谓的提供参数
命令行中，闪烁提示，

36
00:01:43,620 --> 00:01:48,540
让化妆知道要建什么，等等
这MKDIR知道文件夹的创建，

37
00:01:48,540 --> 00:01:51,110
和使坎德拉知道
您想去的地方。

38
00:01:51,110 --> 00:01:54,720
但是到现在为止，我们一直在说
在主，您的默认功能，

39
00:01:54,720 --> 00:01:58,500
有一个空洞的表达
这些括号内，

40
00:01:58,500 --> 00:02:01,250
这意味着它
不带任何参数。

41
00:02:01,250 --> 00:02:03,240
>> 所以，从今天起，
我们要做些什么

42
00:02:03,240 --> 00:02:06,270
是，我们要开始
支持这样的事情，甚至。

43
00:02:06,270 --> 00:02:08,990
事实上，在这种情况下，你
通常不手动输入，

44
00:02:08,990 --> 00:02:11,130
让一直在做这
对我们来说，有没有

45
00:02:11,130 --> 00:02:15,840
之一，但一个，两个，三个附加
之后，该程序的命名字符串

46
00:02:15,840 --> 00:02:16,850
铛。

47
00:02:16,850 --> 00:02:18,240
那么，如何才能做到这一点？

48
00:02:18,240 --> 00:02:20,260
>> 好了，从今天开始，
在这里我们要案件

49
00:02:20,260 --> 00:02:22,855
通过提供输入
所谓的命令行

50
00:02:22,855 --> 00:02:24,980
我们要开始添加
这里什么在yellow--

51
00:02:24,980 --> 00:02:30,520
与诠释的argc逗号代替无效
字符串argv的左括号右括号。

52
00:02:30,520 --> 00:02:32,520
现在，这是有趣的
一对夫妇的原因。

53
00:02:32,520 --> 00:02:35,690
一，这将让我们写
程序是多了几分动感。

54
00:02:35,690 --> 00:02:37,570
不过，更令人信服，
这将打开

55
00:02:37,570 --> 00:02:40,340
现在的对话，以
什么阵列可真

56
00:02:40,340 --> 00:02:43,300
可以使用，什么串
真的是引擎盖下方，

57
00:02:43,300 --> 00:02:47,320
等到下星期我们开始跳水
在更深层次，以机器是如何

58
00:02:47,320 --> 00:02:48,590
让所有这些东西的工作。

59
00:02:48,590 --> 00:02:51,920
但现在，让我们来画，
也许，一个图片。

60
00:02:51,920 --> 00:02:54,950
>> 当你写一个程序
与主声明

61
00:02:54,950 --> 00:02:58,810
以这种方式，使得主
有两个参数，一个int

62
00:02:58,810 --> 00:03:03,233
还有 - 什么样的数据类型
是第二个参数？

63
00:03:03,233 --> 00:03:04,529
>> 听众：阵列。

64
00:03:04,529 --> 00:03:05,320
大卫马兰：阵列。

65
00:03:05,320 --> 00:03:09,170
所以，第一眼看上去就像是一个
字符串，但要注意的方括号。

66
00:03:09,170 --> 00:03:12,760
还记得我们去年推出的时间
阵列的概念。

67
00:03:12,760 --> 00:03:16,210
和数组使用方括号
在几个场合。

68
00:03:16,210 --> 00:03:19,160
您可以使用方
括号去到一个数组

69
00:03:19,160 --> 00:03:22,710
并获得一个特定的元素，如
支架0或1架或支架2。

70
00:03:22,710 --> 00:03:25,500
但是我们看到，如果简单地说，
上周，你也

71
00:03:25,500 --> 00:03:28,790
使用这些方括号
声明数组的大小，

72
00:03:28,790 --> 00:03:31,790
如果你事先知道有多少个整数
或者有多少字符串或任何你

73
00:03:31,790 --> 00:03:32,630
其实想。

74
00:03:32,630 --> 00:03:34,790
因此，原来有
这里三分之一的上下文

75
00:03:34,790 --> 00:03:37,890
这里面有没有一些
方括号。

76
00:03:37,890 --> 00:03:41,920
当你指定，因为我这里有，
的类似的argv名称，

77
00:03:41,920 --> 00:03:44,550
这只是一种奇特的方式
话说参数向量，这

78
00:03:44,550 --> 00:03:47,750
是另一种奇特的方式
说的参数数组，

79
00:03:47,750 --> 00:03:50,870
开放式托架右方括号只是
意味着你不一定

80
00:03:50,870 --> 00:03:52,960
预先知道有多大
该阵列将是，

81
00:03:52,960 --> 00:03:55,070
但你知道这将是一个数组。

82
00:03:55,070 --> 00:03:57,320
所以，如果你不知道的
一些不把它放在那里，

83
00:03:57,320 --> 00:04:01,160
开放式托架右方括号
也就是说argv是不是一个字符串，

84
00:04:01,160 --> 00:04:03,124
但一个字符串数组。

85
00:04:03,124 --> 00:04:05,040
所以，语法，如果你
回想上周，

86
00:04:05,040 --> 00:04:09,460
这是非常相似的说法
像整型年龄开支架，

87
00:04:09,460 --> 00:04:10,984
再以后的东西。

88
00:04:10,984 --> 00:04:12,150
那么，这是什么样子的呢？

89
00:04:12,150 --> 00:04:13,399
让我们来实际绘制的图片。

90
00:04:13,399 --> 00:04:18,756
所以，当你运行这个程序有主
有两个参数中定义

91
00:04:18,756 --> 00:04:21,339
这些括号的，你
本质上具有至少两个组块

92
00:04:21,339 --> 00:04:23,560
内存就交给你了
引擎盖下方。

93
00:04:23,560 --> 00:04:26,550
一，我会为绘制这个矩形，
将要被调用的argc。

94
00:04:26,550 --> 00:04:30,645
而只是作为一个快速回顾一下，
什么是ARGC的数据类型？

95
00:04:30,645 --> 00:04:31,270
所以这是一个int。

96
00:04:31,270 --> 00:04:33,480
因此，一些会
走在argc--圈

97
00:04:33,480 --> 00:04:35,660
出代表参数计数。

98
00:04:35,660 --> 00:04:38,887
同时，我画的argv为数组。

99
00:04:38,887 --> 00:04:40,970
我真的不知道
多久将是，

100
00:04:40,970 --> 00:04:42,470
所以对于今天的目的，点点点。

101
00:04:42,470 --> 00:04:43,636
它可能会得到一些长度。

102
00:04:43,636 --> 00:04:45,640
但我在这里想象
至少四个矩形。

103
00:04:45,640 --> 00:04:50,970
所以的argv内存存储块
串串串点点点，

104
00:04:50,970 --> 00:04:53,950
和ARGC只是一大块
的存储器为一个整数。

105
00:04:53,950 --> 00:04:55,710
>> 所以，现在，让我们可以更确切的一点。

106
00:04:55,710 --> 00:04:59,200
如果，当我有串
在这个数组，称为

107
00:04:59,200 --> 00:05:03,290
ARGV，我想向他们
单独的，就像上​​周，

108
00:05:03,290 --> 00:05:05,670
我们将要使用的符号
像argv的支架0

109
00:05:05,670 --> 00:05:07,650
拿到的第一件事数组。

110
00:05:07,650 --> 00:05:10,440
ARGV支架1得到
第二件事情，等等。

111
00:05:10,440 --> 00:05:14,597
这里的关键是，我们还在0
indexed--我们仍然从0开始计数。

112
00:05:14,597 --> 00:05:16,430
所以，现在让我们来实际
装上去的。

113
00:05:16,430 --> 00:05:21,670
如果我要编译一个调用程序
你好，从一个叫你好点C文件，

114
00:05:21,670 --> 00:05:24,340
然后我运行的程序
用点斜线您好，

115
00:05:24,340 --> 00:05:28,380
什么我的电脑，我的笔记本电脑，
像机罩下方

116
00:05:28,380 --> 00:05:31,300
那一刻我跑点
湿地打招呼，敲回车？

117
00:05:31,300 --> 00:05:33,500
那么，这也许是
我们可以描述

118
00:05:33,500 --> 00:05:37,010
为您的计算机的内容
存储器，或RAM--随机存取存储器。

119
00:05:37,010 --> 00:05:40,330
换句话说，计算机
不知怎么给你神奇，

120
00:05:40,330 --> 00:05:45,360
放入的argc数字1，AKA argcount，
它把字面上的字符串

121
00:05:45,360 --> 00:05:48,200
./hello argv中支架0。

122
00:05:48,200 --> 00:05:51,750
我不知道，坦白地说，有什么
argv中托架1或2或3，

123
00:05:51,750 --> 00:05:55,550
因为如果用户具有不
什么类型除了./hello，

124
00:05:55,550 --> 00:05:58,550
我们将假定这些
最有可能的垃圾值

125
00:05:58,550 --> 00:05:59,700
可以这么说。

126
00:05:59,700 --> 00:06:02,650
内存块的那些
存在的，但它不是我们

127
00:06:02,650 --> 00:06:05,710
看着他们，因为
该argcount是唯一的一个。

128
00:06:05,710 --> 00:06:07,870
>> 现在，同时，如果我
编写运行另一个程序，

129
00:06:07,870 --> 00:06:12,250
CD，这是更适当的命令时，
在你眨眼prompt-- CD的空间

130
00:06:12,250 --> 00:06:17,200
当我运行，有效地Dropbox--，
光盘程序运行时，argc个，

131
00:06:17,200 --> 00:06:22,270
我的计算机的内存里面，是
最简短的第二数字2。

132
00:06:22,270 --> 00:06:25,936
然后argv的支架O具有
CD，argv的支架1有Dropbox的，

133
00:06:25,936 --> 00:06:28,560
然后当然命令
完成，所以这一切的记忆

134
00:06:28,560 --> 00:06:30,420
基本消失，
用于别的东西。

135
00:06:30,420 --> 00:06:32,270
这就是为什么我说
只是一个瞬间。

136
00:06:32,270 --> 00:06:35,720
>> 同时，如果我们做的mkdir pset2，
画面看起来几乎一样，

137
00:06:35,720 --> 00:06:37,900
但里面的argv不同的字符串。

138
00:06:37,900 --> 00:06:42,570
如果我做铛冲刺打招呼
你好点C，同样的想法。

139
00:06:42,570 --> 00:06:47,060
更多的东西填充的
的argv和argc个，当然，是4。

140
00:06:47,060 --> 00:06:49,150
因此，换句话说，
尽管这阵

141
00:06:49,150 --> 00:06:52,950
可能会点一些点点，
可变长度的，可以这么说，

142
00:06:52,950 --> 00:06:56,720
你总是知道它在哪里结束
是的，因为的argc是要告诉你

143
00:06:56,720 --> 00:07:00,120
在什么时候你必须停止
看着argv中的元素。

144
00:07:00,120 --> 00:07:03,660
你只能看4
在总在这种情况下。

145
00:07:03,660 --> 00:07:06,600
>> 现在让我们来看看，
也许，一个简单的程序。

146
00:07:06,600 --> 00:07:09,070
一个刚刚打招呼
到有人喜欢Zamyla。

147
00:07:09,070 --> 00:07:12,620
所以，我要求我要编写一个程序
在短短的一瞬间，通过它我可以做

148
00:07:12,620 --> 00:07:16,670
./hello空间Zamyla，然后我想
我的程序打印出来的东西

149
00:07:16,670 --> 00:07:18,520
超级简单的像“你好，Zamyla。”

150
00:07:18,520 --> 00:07:20,100
现在，在过去，我们使用的GetString。

151
00:07:20,100 --> 00:07:22,850
因此，在过去，即使
你是新来编程，

152
00:07:22,850 --> 00:07:27,180
可能你会掀起
使用GetString的程序

153
00:07:27,180 --> 00:07:29,390
然后使用printf的
说喜Zamyla。

154
00:07:29,390 --> 00:07:31,290
但是，我们不要用GetString的这个时候。

155
00:07:31,290 --> 00:07:37,510
让我来代替进入Appliant
做包括标准输入输出点小时。

156
00:07:37,510 --> 00:07:41,160
让我也有CS50网点小时。

157
00:07:41,160 --> 00:07:44,730
现在主要的诠释，而现在我
不会今天做无效。

158
00:07:44,730 --> 00:07:51,200
相反，我该怎么办INT ARGC
字符串的argv开括号右括号，

159
00:07:51,200 --> 00:07:52,640
不指定一个数字。

160
00:07:52,640 --> 00:07:54,644
喏，这就是我所谓的做。

161
00:07:54,644 --> 00:07:57,560
我什么都现在要做的就是，我
打算做一点信仰的飞跃，

162
00:07:57,560 --> 00:08:00,560
我将假设用户的
要正确地使用这个程序，

163
00:08:00,560 --> 00:08:04,980
而我只是去
这样做的printf你好，％锡。

164
00:08:04,980 --> 00:08:06,630
所以，没有什么新的存在。

165
00:08:06,630 --> 00:08:11,470
但我想现在把什么字
该程序的名称后，用户类型。

166
00:08:11,470 --> 00:08:16,970
所以，如果我这样做./hello空间Zamyla，我
要以某种方式编程方式访问

167
00:08:16,970 --> 00:08:20,870
报价引文结束“Zamyla。”所以我
可以进入我的参数向量，

168
00:08:20,870 --> 00:08:25,980
我的字符串数组，并且如果该命令
再次，是./hello空间Zamyla，

169
00:08:25,980 --> 00:08:29,340
什么数字做我想要
argv中放这里？

170
00:08:29,340 --> 00:08:29,840
听众：1。

171
00:08:29,840 --> 00:08:32,355
大卫马兰：1，因为
支架0证明

172
00:08:32,355 --> 00:08:34,230
将是该
节目的名字，正如我们所看到。

173
00:08:34,230 --> 00:08:37,789
所以托架1是第一个字
我的用户，键入。

174
00:08:37,789 --> 00:08:39,559
我要继续前进，保存这个。

175
00:08:39,559 --> 00:08:42,830
我要进入​​我的文件夹
在那里我已经放在这个文件。

176
00:08:42,830 --> 00:08:44,920
我该怎么办让你好3。

177
00:08:44,920 --> 00:08:46,230
比较IO的确定。

178
00:08:46,230 --> 00:08:51,380
./hello Zamyla输入。

179
00:08:51,380 --> 00:08:54,480
我做了什么错？

180
00:08:54,480 --> 00:08:57,270
我措手不及
我自己只是一瞬间出现。

181
00:08:57,270 --> 00:08:58,230
我做了什么错？

182
00:08:58,230 --> 00:08:59,220
>> 听众：名称。

183
00:08:59,220 --> 00:09:01,767
>> 大卫马兰：该文件的
其实所谓的hello3.c。

184
00:09:01,767 --> 00:09:03,850
我这样做只是为了
一致性，因为我们已经

185
00:09:03,850 --> 00:09:06,550
有hello.c中的中
过去在联机代码。

186
00:09:06,550 --> 00:09:11,550
因此，让我们解决这个问题./hello
支架冲刺3 Zamyla。

187
00:09:11,550 --> 00:09:12,370
输入。

188
00:09:12,370 --> 00:09:14,030
现在我们有打招呼，Zamyla。

189
00:09:14,030 --> 00:09:17,650
同时，我可以改变这
是抢，还是真的任何其他文字。

190
00:09:17,650 --> 00:09:19,230
>> 但是，让我们考虑一个角落的情况下。

191
00:09:19,230 --> 00:09:24,360
什么，你可能会想到，如果会发生
我不输入任何人的名字呢？

192
00:09:24,360 --> 00:09:25,270
>> 听众：错误。

193
00:09:25,270 --> 00:09:27,300
>> 大卫马兰：错误
的一些，也许。

194
00:09:27,300 --> 00:09:28,200
让我们来看看。

195
00:09:28,200 --> 00:09:29,440
输入。

196
00:09:29,440 --> 00:09:30,210
NULL。

197
00:09:30,210 --> 00:09:33,870
所以printf的实际上是被
一点点保护我们

198
00:09:33,870 --> 00:09:38,131
在这里，和字面移印开括号
空，但更糟糕的事情都可能发生。

199
00:09:38,131 --> 00:09:40,130
而只是为了展示
东西你绝对

200
00:09:40,130 --> 00:09:42,800
不该做的事，让我们在
在这里，并开始闲逛。

201
00:09:42,800 --> 00:09:43,300
对不对？

202
00:09:43,300 --> 00:09:46,410
如果我知道，在画面
内存基本上是这样，

203
00:09:46,410 --> 00:09:52,660
argv的支架1具有Zamyla，ARGV
托架0具有./hello，或./hello-3。

204
00:09:52,660 --> 00:09:55,400
什么是支架2？

205
00:09:55,400 --> 00:09:58,210
这样我就可以回答这个问题
怀疑自己，对不对？

206
00:09:58,210 --> 00:10:00,460
我只能改变1到2。

207
00:10:00,460 --> 00:10:07,270
我现在可以重新编译您好3，
./hello3让我们放大并按下回车键。

208
00:10:07,270 --> 00:10:08,270
哎呦。

209
00:10:08,270 --> 00:10:10,660
没有引号。

210
00:10:10,660 --> 00:10:12,540
有意思的。

211
00:10:12,540 --> 00:10:15,530
所以这是一种很酷
看到的是在这里还有什么。

212
00:10:15,530 --> 00:10:17,130
>> 那么，我的笔记本电脑里还有什么？

213
00:10:17,130 --> 00:10:20,390
让我们将它保存与支架3。

214
00:10:20,390 --> 00:10:25,190
请hello3，./hello-3。

215
00:10:25,190 --> 00:10:26,500
好奇的。

216
00:10:26,500 --> 00:10:30,560
现在，让我们真正bold-- 50。

217
00:10:30,560 --> 00:10:34,340
所以，这真的跳水深
进入我的电脑的内存中。

218
00:10:34,340 --> 00:10:35,930
50指数研究。

219
00:10:35,930 --> 00:10:41,950
所以要喂3 ./hello-3。

220
00:10:41,950 --> 00:10:42,680
好奇的。

221
00:10:42,680 --> 00:10:44,660
好吧，现在我只是
要得到鲁莽。

222
00:10:44,660 --> 00:10:47,331
让我们去到5000。

223
00:10:47,331 --> 00:10:47,830
好吧。

224
00:10:47,830 --> 00:10:49,520
因此，让我重新编译。

225
00:10:49,520 --> 00:10:51,460
请hello3，./hello-3。

226
00:10:51,460 --> 00:10:55,780

227
00:10:55,780 --> 00:10:56,460
行。

228
00:10:56,460 --> 00:10:59,250
现在，你们中的一些，可能
一个灯泡去了。

229
00:10:59,250 --> 00:11:01,900
你们有多少人有
之前看过这个消息？

230
00:11:01,900 --> 00:11:03,440
行。

231
00:11:03,440 --> 00:11:04,420
那么，为什么呢？

232
00:11:04,420 --> 00:11:07,250
>> 赔率are--并有不同
事情可能会导致此，

233
00:11:07,250 --> 00:11:09,730
并明确你的好
company--我们必须清楚

234
00:11:09,730 --> 00:11:11,900
造成了所谓
分段故障。

235
00:11:11,900 --> 00:11:15,890
而长话短说今天，我
已经触及记忆的片段

236
00:11:15,890 --> 00:11:17,060
我不应该有。

237
00:11:17,060 --> 00:11:19,970
其中段仅仅意味着一大块
记忆，我不应该有。

238
00:11:19,970 --> 00:11:25,530
现在的电脑可以保证，如果我
运行./helloZamyla我能触摸的argv

239
00:11:25,530 --> 00:11:27,760
是支架0和argv支架1。

240
00:11:27,760 --> 00:11:32,730
但ARGC是值2，这意味着我
只有allowed--这有点荣誉

241
00:11:32,730 --> 00:11:35,180
系统 - 触摸
0支架及支架1。

242
00:11:35,180 --> 00:11:37,990
如果我再往前走，有
绝对将是存储器那里。

243
00:11:37,990 --> 00:11:40,660
我的内存物理上存在
在计算机中。

244
00:11:40,660 --> 00:11:42,080
但谁知道那里有什么？

245
00:11:42,080 --> 00:11:44,450
事实上，我在运行多个
程序在同一时间。

246
00:11:44,450 --> 00:11:46,910
我可能有seen--如果我不
在Appliant这样做

247
00:11:46,910 --> 00:11:49,937
但在我的Mac或PC--我可能有
观察的电子邮件的内容。

248
00:11:49,937 --> 00:11:52,270
我可能会看到瞬间
消息我最近发。

249
00:11:52,270 --> 00:11:55,390
任何可能
在内存周围徘徊

250
00:11:55,390 --> 00:11:59,180
可以通过的方式被访问
这个任意方括号。

251
00:11:59,180 --> 00:12:02,850
或者，更糟糕的是，你可能有
发现了我的密码1

252
00:12:02,850 --> 00:12:05,859
我想最近输入的，一个
方案已存储在内存中，从而

253
00:12:05,859 --> 00:12:07,900
验证了我，
然后种刚刚离开它

254
00:12:07,900 --> 00:12:09,910
在内存中，直到我退出该程序。

255
00:12:09,910 --> 00:12:12,860
>> 事实上，这是一
的危险，一个权力

256
00:12:12,860 --> 00:12:15,980
使用类似C的语言
您可以自由访问

257
00:12:15,980 --> 00:12:18,860
到的全部内容
程序的内存，

258
00:12:18,860 --> 00:12:21,340
什么坏人能
即使在做这些cases--

259
00:12:21,340 --> 00:12:23,807
特别是当我们
得到Web编程

260
00:12:23,807 --> 00:12:26,890
朝学期结束，我们将
重温这topic--是闲逛，

261
00:12:26,890 --> 00:12:31,660
可能有人是电脑的
记忆，找到这样的事情感到好奇

262
00:12:31,660 --> 00:12:32,570
因为我们看到了那里。

263
00:12:32,570 --> 00:12:36,900
甚至更糟糕的是，口令，他
或者她可以用它来干坏事。

264
00:12:36,900 --> 00:12:40,240
>> 所以，显然我不应该这样做，
因为奇怪的事情开始发生。

265
00:12:40,240 --> 00:12:42,310
的确，这是一个程序崩溃。

266
00:12:42,310 --> 00:12:44,580
这将是等效
的Mac OS的Windows或

267
00:12:44,580 --> 00:12:46,770
程序窗口刚刚消失。

268
00:12:46,770 --> 00:12:48,300
已发生未预期的错误。

269
00:12:48,300 --> 00:12:50,840
在命令行环境
我们看到这样的事情。

270
00:12:50,840 --> 00:12:54,480
但是，这是为什么，是我只是碰
不属于我的记忆。

271
00:12:54,480 --> 00:12:57,090
>> 因此，让我们对这样的防守
以不同的方式点点

272
00:12:57,090 --> 00:12:59,010
通过看这个节目在这里。

273
00:12:59,010 --> 00:13:01,000
因此，再次，骨架
我们看到先前已经

274
00:13:01,000 --> 00:13:02,480
我已经强调了这一次诠释。

275
00:13:02,480 --> 00:13:05,900
而这一切的时候主要有
实际上返回的值。

276
00:13:05,900 --> 00:13:09,120
即使在我们大部分的演讲
我们从来没有使用一次例子

277
00:13:09,120 --> 00:13:10,990
返回主任何东西。

278
00:13:10,990 --> 00:13:13,710
我们只是写的printf关闭
大括号，就是这样。

279
00:13:13,710 --> 00:13:16,500
但对于自由，什么
编译器已经做了你，

280
00:13:16,500 --> 00:13:19,510
有效，则返回0给你。

281
00:13:19,510 --> 00:13:22,950
打开out--，它是一个小
counterintuitive-- 0是好。

282
00:13:22,950 --> 00:13:24,690
这并不意味着错误本身。

283
00:13:24,690 --> 00:13:29,080
0是好，任何非0
值时，世界已经决定，

284
00:13:29,080 --> 00:13:30,619
可以表示一个错误。

285
00:13:30,619 --> 00:13:32,910
所以，如果你曾经搞砸
什么您的计算机上，

286
00:13:32,910 --> 00:13:36,600
或计划刚刚去世，你和
你已经得到了一些错误窗口

287
00:13:36,600 --> 00:13:40,360
在屏幕上，说错误
负49或错误23--

288
00:13:40,360 --> 00:13:44,170
一些看似随意的value--这
因为程序员已经硬编码

289
00:13:44,170 --> 00:13:49,370
像49负或正的值
23代表任意数字，敢说，

290
00:13:49,370 --> 00:13:53,340
四十亿可能的事情
可能出错的程序。

291
00:13:53,340 --> 00:13:55,700
>> 所以，我怎么可能拿
利用这一点我自己？

292
00:13:55,700 --> 00:13:58,970
好吧，让我打开一个程序
我提前写了，

293
00:13:58,970 --> 00:14:01,450
和闲逛在线名为hello 4。

294
00:14:01,450 --> 00:14:05,650
这几乎是相同的，不同之处在于
它得到了错误检查的一点点。

295
00:14:05,650 --> 00:14:09,660
在这种情况下，我再次声明
主要是考虑两个参数，

296
00:14:09,660 --> 00:14:13,180
但是这一次，在第17行，通知
我做了一下仔细的检查了。

297
00:14:13,180 --> 00:14:17,100
我要确保
的argc等于等于2。

298
00:14:17,100 --> 00:14:18,960
因为如果是，那
意味着我可以安全地

299
00:14:18,960 --> 00:14:21,420
触摸不仅托架0，但是支架1。

300
00:14:21,420 --> 00:14:24,330
我继续前进，打印出来，
在这种情况下，Zamyla或抢劫

301
00:14:24,330 --> 00:14:26,020
或什么字我打出来。

302
00:14:26,020 --> 00:14:28,020
而现在只是为了让
多一点正确的，

303
00:14:28,020 --> 00:14:31,910
我要明确地返回
0来表示一切都很好。

304
00:14:31,910 --> 00:14:33,300
没什么不好的事情发生了。

305
00:14:33,300 --> 00:14:38,590
>> 不过，按照惯例，我要
返回1，或者坦白任何非0值，

306
00:14:38,590 --> 00:14:40,160
如果出事了。

307
00:14:40,160 --> 00:14:43,270
现在，用户不会
真正注意到发生了什么事情。

308
00:14:43,270 --> 00:14:50,410
事实上，如果我进入这个目录，
我们放大，做让你好4，

309
00:14:50,410 --> 00:14:54,210
./hello-4 Zamyla表现如我所料。

310
00:14:54,210 --> 00:14:58,570
但是，如果我不是不键入
什么，似乎什么都没有发生，

311
00:14:58,570 --> 00:14:59,680
但它不会崩溃。

312
00:14:59,680 --> 00:15:04,660
如果我不是做一些事情
像罗布是一个监考人

313
00:15:04,660 --> 00:15:07,550
在Thayer--共享
任意信息。

314
00:15:07,550 --> 00:15:13,680
但通知，argv的1，2，3，4，和
5现在应该存在于内存中。

315
00:15:13,680 --> 00:15:16,540
这也并不是什么
我的程序需要，

316
00:15:16,540 --> 00:15:20,300
因为我已经检查是否
的argc等于等于2或没有。

317
00:15:20,300 --> 00:15:22,140
所以，我现在防御这一点。

318
00:15:22,140 --> 00:15:25,290
>> 现在，顺便说一句，我们的
programmer--或者说我们的users--

319
00:15:25,290 --> 00:15:29,670
从来没有看到一个0或1，但使用
工具，称为调试器或其它工具，

320
00:15:29,670 --> 00:15:32,250
和以前一样，我们会看到
长，你的程序员

321
00:15:32,250 --> 00:15:36,590
其实可以看看可能是什么
你的程序里面去错了。

322
00:15:36,590 --> 00:15:39,170
>> 因此，在ARGC什么问题吗？

323
00:15:39,170 --> 00:15:40,873
是啊。

324
00:15:40,873 --> 00:15:45,292
>> 听众：我见过他们
还没有的字符，[听不清]

325
00:15:45,292 --> 00:15:49,669
刚才说的串星D，如
字符星号逗号。

326
00:15:49,669 --> 00:15:50,710
他们是等价吗？

327
00:15:50,710 --> 00:15:51,626
>> 大卫马兰：他们是。

328
00:15:51,626 --> 00:15:55,080
所以，问题是，你有
偶尔可见的程序

329
00:15:55,080 --> 00:15:57,270
像这样不
说字符串argv的支架

330
00:15:57,270 --> 00:16:01,015
而是说些什么
像炭明星argv的支架。

331
00:16:01,015 --> 00:16:03,140
甚至还有其他
变体，你可能会看到。

332
00:16:03,140 --> 00:16:04,264
他们确实是等价的。

333
00:16:04,264 --> 00:16:06,240
现在，我们有这些
这类训练车轮

334
00:16:06,240 --> 00:16:09,737
在字符串中的CS50的形式
库，但在短短一个多星期

335
00:16:09,737 --> 00:16:12,570
还是让我们将删除
完全梗阻，实际上

336
00:16:12,570 --> 00:16:16,820
看看炭和星
有，以及这些涉及到内存

337
00:16:16,820 --> 00:16:18,140
代表更普遍。

338
00:16:18,140 --> 00:16:19,540
因此，我们会回来的。

339
00:16:19,540 --> 00:16:21,540
>> 在我们的argv和argc个其他的问题吗？

340
00:16:21,540 --> 00:16:22,397
是啊。

341
00:16:22,397 --> 00:16:24,438
听众：为什么会回来
错误[听不清]？

342
00:16:24,438 --> 00:16:27,147

343
00:16:27,147 --> 00:16:29,230
大卫马兰：为什么会
返回一个错误only--哦！

344
00:16:29,230 --> 00:16:31,813
在前面的情况下，当我们
带记忆功能均围绕把玩，

345
00:16:31,813 --> 00:16:35,110
为什么只返回一个错误
当我真正输入一个大数目？

346
00:16:35,110 --> 00:16:36,620
简短的回答是，我们只是很幸运。

347
00:16:36,620 --> 00:16:39,240
一般来说，一台计算机
在块分配内存，

348
00:16:39,240 --> 00:16:42,900
它给了我一个足够大的存储块，它
我得到了，而不被发觉，

349
00:16:42,900 --> 00:16:46,280
感人的支架2，支架3，
支架50，但只要我推

350
00:16:46,280 --> 00:16:49,080
我的运气，我去超越
的存储器中的数据块的边界

351
00:16:49,080 --> 00:16:50,520
操作系统给了我。

352
00:16:50,520 --> 00:16:52,720
这就是当
取缔并说，没有。

353
00:16:52,720 --> 00:16:54,580
分割错误。

354
00:16:54,580 --> 00:16:55,692
是啊。

355
00:16:55,692 --> 00:16:58,890
>> 听众：如何在电脑
知道的argc的值？

356
00:16:58,890 --> 00:17:02,390
>> 大卫马兰：请问该如何
计算机知道的argc的值？

357
00:17:02,390 --> 00:17:07,920
当你运行一个程序，该程序，
通过闪烁提示性质，

358
00:17:07,920 --> 00:17:11,359
被传递的数组
被输入的字

359
00:17:11,359 --> 00:17:13,300
在提示符下，这是
键入的。

360
00:17:13,300 --> 00:17:16,569
因此，这是你的工作
系统的本质

361
00:17:16,569 --> 00:17:20,329
填充主要的论点为您服务。

362
00:17:20,329 --> 00:17:22,829
所以这是一个服务
之类的，你得到的，偷偷的

363
00:17:22,829 --> 00:17:24,869
的机罩下方
一个操作系统。

364
00:17:24,869 --> 00:17:27,118
其他问题吗？

365
00:17:27,118 --> 00:17:27,618
是啊。

366
00:17:27,618 --> 00:17:29,787
>> 听众：什么是核心转储是什么意思？

367
00:17:29,787 --> 00:17:31,370
大卫马兰：这是什么核心转储是什么意思？

368
00:17:31,370 --> 00:17:32,950
所以这是一个很好的问题。

369
00:17:32,950 --> 00:17:35,312
让我重新回到
该目录在这里。

370
00:17:35,312 --> 00:17:37,270
而且你会发现，
我有一个新的文件存在。

371
00:17:37,270 --> 00:17:41,670
它确实是叫核心，它的
其实通常一个体面的大小的文件。

372
00:17:41,670 --> 00:17:45,300
这是本质上的快照
我的程序的内存内容

373
00:17:45,300 --> 00:17:46,902
或RAM时坠毁。

374
00:17:46,902 --> 00:17:49,110
并且这将是有用的，
可能，诊断，

375
00:17:49,110 --> 00:17:52,850
当我们谈论在未来的演讲
而有关调试部分，

376
00:17:52,850 --> 00:17:55,730
因为你实际上可以做的
数字尸检相当于

377
00:17:55,730 --> 00:18:00,300
在该文件中，以帮助找出
你做错了什么在你的程序。

378
00:18:00,300 --> 00:18:01,220
是啊。

379
00:18:01,220 --> 00:18:04,450
>> 听众：是的argc的命令
本身，或者你的名字什么？

380
00:18:04,450 --> 00:18:05,575
>> 大卫马兰：好问题。

381
00:18:05,575 --> 00:18:08,040
是的argc命令本身，
或者你能想到的东西吗？

382
00:18:08,040 --> 00:18:09,290
这绝对不是一个命令。

383
00:18:09,290 --> 00:18:13,500
这是一个简单的变量
命名或参数的名称，

384
00:18:13,500 --> 00:18:15,481
所以，我们绝
可以称之为富，

385
00:18:15,481 --> 00:18:18,480
我们可以把这个吧，这往往
是去到的话，一个计算机

386
00:18:18,480 --> 00:18:19,860
科学家去。

387
00:18:19,860 --> 00:18:22,820
但按照惯例，我们用argc和argv。

388
00:18:22,820 --> 00:18:25,360
但是，这只是一个人
按惯例，仅此而已。

389
00:18:25,360 --> 00:18:25,860
好吧。

390
00:18:25,860 --> 00:18:28,140
所以，事实证明，我已经
讲述一个有点白lie--的

391
00:18:28,140 --> 00:18:31,264
坦率地说，在未来，你会看到
我们已经告诉其他善意的谎言。

392
00:18:31,264 --> 00:18:33,510
但现在，我们要
剥离背部的其中之一。

393
00:18:33,510 --> 00:18:37,310
在这种情况下这里的时候，我在前面
跑起来像./hello或./hello-3方案

394
00:18:37,310 --> 00:18:42,780
Zamyla，我们有内容我
计算机的内存期待大致如下

395
00:18:42,780 --> 00:18:43,280
这个。

396
00:18:43,280 --> 00:18:45,070
但是记得什么是字符串。

397
00:18:45,070 --> 00:18:49,279
咱们怎么说的一个星期前有什么
字符串实际上是引擎盖底下？

398
00:18:49,279 --> 00:18:50,320
听众：字符数组。

399
00:18:50,320 --> 00:18:52,111
大卫马兰：这是一个
字符数组的，对不对？

400
00:18:52,111 --> 00:18:55,760
因此，我们可能有一个数组
字符串，但是，反过来，一个字符串

401
00:18:55,760 --> 00:18:57,150
是字符数组。

402
00:18:57,150 --> 00:19:00,010
所以，如果我真的想成为
当我画这幅画的肛门，

403
00:19:00,010 --> 00:19:03,290
我真的画
它有点像这样，

404
00:19:03,290 --> 00:19:08,000
由此在每个这些
我argv数组的索引，

405
00:19:08,000 --> 00:19:11,432
存在本身就是一个整串
这本身是一个数组。

406
00:19:11,432 --> 00:19:13,140
现在的善意的谎言
我们今天讲

407
00:19:13,140 --> 00:19:15,181
就是图片不
看上去很喜欢这个。

408
00:19:15,181 --> 00:19:19,110
事实上，小广场都是
一般外面的大矩形

409
00:19:19,110 --> 00:19:19,610
那里。

410
00:19:19,610 --> 00:19:21,280
但我们会回来用不了多久。

411
00:19:21,280 --> 00:19:25,440
但是，这是./hello反斜线0，
这是特殊字符

412
00:19:25,440 --> 00:19:28,310
划定一个字符串的结尾，
我们已经得到了一个又一个后

413
00:19:28,310 --> 00:19:29,360
Zamyla的名字。

414
00:19:29,360 --> 00:19:30,900
所以，这是什么意思？

415
00:19:30,900 --> 00:19:33,410
>> 好了，让我继续前进，
打开另外两个例子

416
00:19:33,410 --> 00:19:35,220
这是在网上提供。

417
00:19:35,220 --> 00:19:40,590
一个被称为argv1.c
另一种是argv2。

418
00:19:40,590 --> 00:19:44,260
这是一个超级简单的程序，
与过去​​不同的方案

419
00:19:44,260 --> 00:19:47,260
在现在，我使用
argc和argv在这里。

420
00:19:47,260 --> 00:19:54,300
现在我有一个for循环积分
在长达argc那样线18，从i = 0。

421
00:19:54,300 --> 00:19:56,850
而且我怎么办
与这行代码在这里？

422
00:19:56,850 --> 00:19:58,270
用英语。

423
00:19:58,270 --> 00:20:00,510
这显然​​表明使用的argc的。

424
00:20:00,510 --> 00:20:03,670
但在英语有哪些呢
它这样做，如果我运行这个程序？

425
00:20:03,670 --> 00:20:04,366
是吗？

426
00:20:04,366 --> 00:20:07,386
>> 听众：这将打印
只要你想筛选多次。

427
00:20:07,386 --> 00:20:08,260
马兰大卫：没错。

428
00:20:08,260 --> 00:20:10,480
所以，无论话我
在提示符处键入，它的

429
00:20:10,480 --> 00:20:13,120
要吐出
他们看着我，每行一个。

430
00:20:13,120 --> 00:20:14,370
因此，让我们继续前进，做到这一点。

431
00:20:14,370 --> 00:20:17,862
让我进入我的目录
做让argv1 ./argv1。

432
00:20:17,862 --> 00:20:20,521

433
00:20:20,521 --> 00:20:21,770
现在，让我们保持简单。

434
00:20:21,770 --> 00:20:23,834
让我们什么也不做第一。

435
00:20:23,834 --> 00:20:26,750
它没有打印出一件事，
这是确实的程序的名称，

436
00:20:26,750 --> 00:20:28,240
因为这是在支架0。

437
00:20:28,240 --> 00:20:33,290
如果我现在说富，它会做
这两个，如果我说富吧，

438
00:20:33,290 --> 00:20:35,580
它会说，这三样东西。

439
00:20:35,580 --> 00:20:37,740
现在，这是有点有趣，也许。

440
00:20:37,740 --> 00:20:41,450
但记得的argv
是一个字符串数组，

441
00:20:41,450 --> 00:20:45,960
但字符串是字符数组，
所以我们可以拿东西了一个档次

442
00:20:45,960 --> 00:20:48,560
并应用基本
逻辑，使代码

443
00:20:48,560 --> 00:20:51,160
看起来多了几分神秘，无可否认。

444
00:20:51,160 --> 00:20:53,540
但是，有一个嵌套
循环的东西，类似于

445
00:20:53,540 --> 00:20:57,030
什么，你可能还记得马里奥，
举例来说，如果你这样做，是这样的。

446
00:20:57,030 --> 00:21:00,380
>> 所以现在看到第19行，我
再次遍历我的论点，

447
00:21:00,380 --> 00:21:02,410
从0一直到argc那样。

448
00:21:02,410 --> 00:21:05,510
现在的行21--我
借用去年week--一招

449
00:21:05,510 --> 00:21:11,090
我检查什么
长的argv支架I的。

450
00:21:11,090 --> 00:21:12,920
我存储在正的答案。

451
00:21:12,920 --> 00:21:18,230
然后我从J于一体
到n，其中j被初始化为0。

452
00:21:18,230 --> 00:21:19,460
所以，约定计算。

453
00:21:19,460 --> 00:21:22,335
一旦你使用了我，如果你有一个
嵌套循环，不能再次使用I，

454
00:21:22,335 --> 00:21:25,770
否则你会揍，潜在的，
内环以外的值。

455
00:21:25,770 --> 00:21:27,200
所以我用j通过约定。

456
00:21:27,200 --> 00:21:28,020
我们可以使用k。

457
00:21:28,020 --> 00:21:31,080
如果你比k的多了，你可能
有太多的嵌套，一般。

458
00:21:31,080 --> 00:21:33,800
但现在，我发现的printf
线是略有不同的。

459
00:21:33,800 --> 00:21:37,520
我不打印％S，我
当然，印刷％C，其中，

460
00:21:37,520 --> 00:21:39,460
是一个占位符字符。

461
00:21:39,460 --> 00:21:40,770
>> 现在看到这个语法。

462
00:21:40,770 --> 00:21:41,270
新。

463
00:21:41,270 --> 00:21:42,630
我们以前没有见过。

464
00:21:42,630 --> 00:21:47,290
但在逻辑上，这也就意味着
获得argv中第i个字符串

465
00:21:47,290 --> 00:21:50,067
并获得第j个什么？

466
00:21:50,067 --> 00:21:50,900
听众：字符。

467
00:21:50,900 --> 00:21:52,800
大卫马兰：字符的字符串。

468
00:21:52,800 --> 00:21:57,100
所以可以用方括号
其次是方括号，

469
00:21:57,100 --> 00:22:00,390
这是第一次跳水
进入ARGV的字符串，

470
00:22:00,390 --> 00:22:02,225
然后将第二
方括号内为J

471
00:22:02,225 --> 00:22:06,580
是在深入的字符
argv中的特定字符串。

472
00:22:06,580 --> 00:22:09,562
然后，只为好措施，
我打印了新线在这里。

473
00:22:09,562 --> 00:22:12,020
所以，现在让我继续前进，开
一个稍微大一点的窗口

474
00:22:12,020 --> 00:22:13,600
所以我们可以看到这个动作。

475
00:22:13,600 --> 00:22:15,700
让我进入该文件夹。

476
00:22:15,700 --> 00:22:22,550
现在做让argv中，2--
whoops--作出的argv-2，./argv 2。

477
00:22:22,550 --> 00:22:23,110
输入。

478
00:22:23,110 --> 00:22:24,860
这是一个有点硬
垂直阅读，

479
00:22:24,860 --> 00:22:27,920
但是这确实是名
程序，其次是一个空行。

480
00:22:27,920 --> 00:22:30,210
现在让我继续前进，做富。

481
00:22:30,210 --> 00:22:33,210
同样难读，但它的
的确打印每行一个字符。

482
00:22:33,210 --> 00:22:36,780
如果我去做吧，这是现在
打印这些一行行。

483
00:22:36,780 --> 00:22:40,140
因此，这里的外卖是没有这么多
，哇，看这整齐的新把戏

484
00:22:40,140 --> 00:22:44,750
在那里你可以在内容获取
的阵列的特定字符，

485
00:22:44,750 --> 00:22:48,380
而是如何我们正在采取这些基本
这样的创意索引到一个数组中，

486
00:22:48,380 --> 00:22:51,620
然后索引到一个
数组是数组，

487
00:22:51,620 --> 00:22:56,180
而在应用了同样的想法，
稍微复杂的例子。

488
00:22:56,180 --> 00:22:59,560
但基础实在不
改变，即使是自上周以来。

489
00:22:59,560 --> 00:23:02,350
>> 现在，这是有点及时，
在那，记得，零一周

490
00:23:02,350 --> 00:23:04,110
我们打​​了一个电话本这样。

491
00:23:04,110 --> 00:23:06,670
即使这是明显
物理的纸片，

492
00:23:06,670 --> 00:23:09,150
种你能想到的
电话簿为一个数组。

493
00:23:09,150 --> 00:23:12,770
当然，如果你要重新实现
这件这些纸片

494
00:23:12,770 --> 00:23:15,260
在一台电脑，可能
你会使用的东西

495
00:23:15,260 --> 00:23:20,270
像一个数组来存储所有这些
从A一路姓名和电话号码

496
00:23:20,270 --> 00:23:23,800
到Z所以这是很好的，因为
它让我们有机会，

497
00:23:23,800 --> 00:23:28,310
也许，要考虑你怎么可能
真正实现类似的东西。

498
00:23:28,310 --> 00:23:31,250
由于有一系列的门这里。

499
00:23:31,250 --> 00:23:36,380
所以，如果我could--我们需要一个
自愿到来吧。

500
00:23:36,380 --> 00:23:36,980
让我们来看看。

501
00:23:36,980 --> 00:23:40,650
一个陌生的面孔也许，
陌生的脸也许。

502
00:23:40,650 --> 00:23:42,090
怎么样在橙色？

503
00:23:42,090 --> 00:23:42,680
这里。

504
00:23:42,680 --> 00:23:45,870
橙色的衬衫，上来吧。

505
00:23:45,870 --> 00:23:52,230
>> 现在，让我们和举措继续
这些门上的侧

506
00:23:52,230 --> 00:23:54,020
将这些闪开了一会儿。

507
00:23:54,020 --> 00:23:56,600

508
00:23:56,600 --> 00:23:57,760
你叫什么名字？

509
00:23:57,760 --> 00:23:58,580
>> AJAY：

510
00:23:58,580 --> 00:23:58,655
>> 大卫马兰：阿贾伊。

511
00:23:58,655 --> 00:23:58,680
大卫。

512
00:23:58,680 --> 00:23:59,451
很高兴认识你。

513
00:23:59,451 --> 00:23:59,950
好吧。

514
00:23:59,950 --> 00:24:04,500
因此，我们有这六个背后
门数字上screen--

515
00:24:04,500 --> 00:24:07,810
或者说，七门上
screen--一大堆数字。

516
00:24:07,810 --> 00:24:10,099
我已经告诉你什么
在advance--同意？

517
00:24:10,099 --> 00:24:11,140
AJAY：事先没有。

518
00:24:11,140 --> 00:24:14,730
大卫马兰：我只想要你做
现在是时候找到我，对我们来说，

519
00:24:14,730 --> 00:24:20,920
真的，数量50，
一步一个脚印的时间。

520
00:24:20,920 --> 00:24:21,830
>> AJAY：50号？

521
00:24:21,830 --> 00:24:22,580
>> 大卫马兰：数字50。

522
00:24:22,580 --> 00:24:24,746
而且你可以发现什么
后面这些门

523
00:24:24,746 --> 00:24:27,930
只需用手指触摸它。

524
00:24:27,930 --> 00:24:31,364
该死的。 [笑]

525
00:24:31,364 --> 00:24:34,560
>> [掌声]

526
00:24:34,560 --> 00:24:39,540
>> 非常出色。

527
00:24:39,540 --> 00:24:40,400
行。

528
00:24:40,400 --> 00:24:44,090
我们有一个可爱的礼物
奖你在这里。

529
00:24:44,090 --> 00:24:46,520
你挑的电影，我们
上周讨论。

530
00:24:46,520 --> 00:24:47,362
>> AJAY：哦，伙计。

531
00:24:47,362 --> 00:24:49,050
哦，我从来没有见过太空炮弹。

532
00:24:49,050 --> 00:24:49,520
>> 大卫马兰：太空炮弹。

533
00:24:49,520 --> 00:24:50,140
好吧。

534
00:24:50,140 --> 00:24:53,790
因此，坚持只是一个瞬间。

535
00:24:53,790 --> 00:24:57,430
How--让我们做这个
受教moment--

536
00:24:57,430 --> 00:25:00,412
你怎么去
寻找50号？

537
00:25:00,412 --> 00:25:01,370
AJAY：我选择了随机。

538
00:25:01,370 --> 00:25:03,420
马兰大卫：所以你选择了
随机真的很幸运。

539
00:25:03,420 --> 00:25:03,790
AJAY：是的。

540
00:25:03,790 --> 00:25:04,456
大卫马兰：确定。

541
00:25:04,456 --> 00:25:05,050
优秀的。

542
00:25:05,050 --> 00:25:08,470
所以，现在，你有没有
得到幸运的话，还有什么

543
00:25:08,470 --> 00:25:10,210
可能发生背后的门？

544
00:25:10,210 --> 00:25:12,930
所以，如果我继续前进，
这里透露这些数字，

545
00:25:12,930 --> 00:25:15,180
他们实际上是在随机顺序。

546
00:25:15,180 --> 00:25:17,750
而最好的，你可以有
完成后，坦率地说，是，最终，

547
00:25:17,750 --> 00:25:19,410
在最坏的情况下，检查了他们。

548
00:25:19,410 --> 00:25:23,000
所以，你有超级幸运的，这
是不是我们所说的算法。

549
00:25:23,000 --> 00:25:24,730
是的，恭喜。

550
00:25:24,730 --> 00:25:27,010
但现在let's--幽默我，如果你能。

551
00:25:27,010 --> 00:25:28,310
让我们在此选项卡在这里。

552
00:25:28,310 --> 00:25:31,460
这里是明确的数字
似乎是随机的顺序，

553
00:25:31,460 --> 00:25:32,280
而且他们。

554
00:25:32,280 --> 00:25:35,160
但现在，如果我不是索赔
这背后的门

555
00:25:35,160 --> 00:25:39,070
是被排序号码。

556
00:25:39,070 --> 00:25:41,780
现在的目标是要还
找到我们的数50。

557
00:25:41,780 --> 00:25:45,910
但这样做算法上，而
告诉我们你要去了解它。

558
00:25:45,910 --> 00:25:48,020
如果你找到它，你把这部电影。

559
00:25:48,020 --> 00:25:49,520
你不觉得，你给它回来。

560
00:25:49,520 --> 00:25:52,720

561
00:25:52,720 --> 00:25:58,112
AJAY：所以我要去检查结束
首先，确定是否there's--

562
00:25:58,112 --> 00:26:02,048
[笑声及掌声]

563
00:26:02,048 --> 00:26:04,451

564
00:26:04,451 --> 00:26:05,492
大卫马兰：在这里你去。

565
00:26:05,492 --> 00:26:17,080

566
00:26:17,080 --> 00:26:21,700
让我们来看看1
Ajay的前辈，

567
00:26:21,700 --> 00:26:25,450
肖恩，谁是没有那么幸运了。

568
00:26:25,450 --> 00:26:28,670
好了，你在这里的任务，
肖恩，是下面的内容。

569
00:26:28,670 --> 00:26:32,970
我隐藏在这些
门七位数，

570
00:26:32,970 --> 00:26:37,200
但在一些宗门藏
以及其他的非负数。

571
00:26:37,200 --> 00:26:40,730
你的目标是要想到这
号的最上一行作为仅有的阵列。

572
00:26:40,730 --> 00:26:43,590
我们是件只是一个序列
纸与他们背后的数字。

573
00:26:43,590 --> 00:26:47,640
你的目标是，只有使用顶部
阵这里，我找了七位数。

574
00:26:47,640 --> 00:26:51,200
我们随后将要批判
你如何去这样做。

575
00:26:51,200 --> 00:26:52,920
找到我们七位数，请。

576
00:26:52,920 --> 00:27:02,570

577
00:27:02,570 --> 00:27:03,070
号

578
00:27:03,070 --> 00:27:06,760

579
00:27:06,760 --> 00:27:08,179
5，19，13。

580
00:27:08,179 --> 00:27:16,752

581
00:27:16,752 --> 00:27:17,835
这不是一个脑筋急转弯。

582
00:27:17,835 --> 00:27:21,420

583
00:27:21,420 --> 00:27:21,920
1。

584
00:27:21,920 --> 00:27:26,715

585
00:27:26,715 --> 00:27:29,840
在这一点上你的分数不是很
好，所以你还不如继续下去。

586
00:27:29,840 --> 00:27:32,870

587
00:27:32,870 --> 00:27:33,370
3。

588
00:27:33,370 --> 00:27:38,570

589
00:27:38,570 --> 00:27:39,802
去。

590
00:27:39,802 --> 00:27:42,510
坦白说，我不禁怀疑
什么你甚至想。

591
00:27:42,510 --> 00:27:44,990
>> 肖恩：我可以只从最上面一行。

592
00:27:44,990 --> 00:27:46,240
大卫马兰：只有最上面一行。

593
00:27:46,240 --> 00:27:47,281
所以，你有三个左。

594
00:27:47,281 --> 00:27:48,310
所以找我7。

595
00:27:48,310 --> 00:27:54,758

596
00:27:54,758 --> 00:27:59,141
>> [听众呼喊几点建议]

597
00:27:59,141 --> 00:28:22,210

598
00:28:22,210 --> 00:28:26,130
因此，这两个都是惊人
非常不同的原因。

599
00:28:26,130 --> 00:28:29,150
所以这是我们
离开片刻前，

600
00:28:29,150 --> 00:28:32,530
这里的关键洞察力
在这些门有号

601
00:28:32,530 --> 00:28:37,390
在他们身后被整理的，理想的
外卖的是，你可以做

602
00:28:37,390 --> 00:28:39,670
在根本上更好
本次example--

603
00:28:39,670 --> 00:28:42,380
而事实上，这是肖恩的
第一次尝试用随机数

604
00:28:42,380 --> 00:28:45,460
正如before--但只要
作为这些数进行排序，

605
00:28:45,460 --> 00:28:47,980
像电​​话簿，
你能很明显吗？

606
00:28:47,980 --> 00:28:50,090
或者，你如何利用这些知识？

607
00:28:50,090 --> 00:28:51,530
是啊。

608
00:28:51,530 --> 00:28:54,910
>> 听众：你走到半路[听不清]。

609
00:28:54,910 --> 00:28:55,660
马兰大卫：是啊。

610
00:28:55,660 --> 00:28:56,160
没错。

611
00:28:56,160 --> 00:28:59,680
所以Ajay的初始反应是
检查结束后，我记得，

612
00:28:59,680 --> 00:29:02,320
然后排序，我们完成
这个例子很快。

613
00:29:02,320 --> 00:29:05,220
但是，如果我们开始做这个多
有条不紊地沿着这些线路，

614
00:29:05,220 --> 00:29:07,860
但是，在可能开始
中间，因为他们排序，

615
00:29:07,860 --> 00:29:10,900
只要我们揭示
16号，所以我们知道 - 

616
00:29:10,900 --> 00:29:14,850
，让我们做的正是that--我们
因此，知道50，在今天的情况下，

617
00:29:14,850 --> 00:29:16,080
已经该杀到右侧。

618
00:29:16,080 --> 00:29:18,735
所以，就像在零一周时
我们在半撕电话簿

619
00:29:18,735 --> 00:29:21,490
扔一半
的问题了，在这里同样的想法。

620
00:29:21,490 --> 00:29:23,680
我们可以抛出这个半
这个问题了。

621
00:29:23,680 --> 00:29:25,730
也可能是你
可能会做算法上，

622
00:29:25,730 --> 00:29:28,710
一旦你知道，50必须
在正确的，如果它的任何地方，

623
00:29:28,710 --> 00:29:31,390
是尝试在那里，在中间
的其余的门。

624
00:29:31,390 --> 00:29:33,450
当然，图50是高
超过42，所以我们可以

625
00:29:33,450 --> 00:29:36,060
抛出这个剩余
四分之一的问题了，

626
00:29:36,060 --> 00:29:38,510
并且，最后，确定
像50。

627
00:29:38,510 --> 00:29:41,050
但是，就像用
电话簿，这些数字

628
00:29:41,050 --> 00:29:44,560
在给予我们已经
有序，这给我们留下

629
00:29:44,560 --> 00:29:47,450
有问题，你怎么了
得到的东西进入的排序顺序？

630
00:29:47,450 --> 00:29:49,640
而且，坦率地说，代价是什么？

631
00:29:49,640 --> 00:29:51,390
这是一件事是
递给电话簿

632
00:29:51,390 --> 00:29:54,810
然后通过找到打动你的朋友
电话号码真的很快，对不对？

633
00:29:54,810 --> 00:29:58,520
撕裂32页开始寻找
人出四十亿的网页，

634
00:29:58,520 --> 00:30:00,470
我们说的是一个极端的例子。

635
00:30:00,470 --> 00:30:03,320
但是有多少时候都不需要
Verizon公司进行排序的电话簿？

636
00:30:03,320 --> 00:30:06,170
它没有多少时间带我们
这七个数字排序？

637
00:30:06,170 --> 00:30:10,110
这是我们一直的问题
迄今完全忽略。

638
00:30:10,110 --> 00:30:12,330
>> 现在让我们回答这个问题。

639
00:30:12,330 --> 00:30:15,920
而且我们都出电影了，
但是我们确实有一些压力球。

640
00:30:15,920 --> 00:30:19,480
如果，比如说，8名志愿者
不介意加入我们了吗？

641
00:30:19,480 --> 00:30:24,100
让我们继续做，怎么样
你们四个，你们三个在这里？

642
00:30:24,100 --> 00:30:25,290
得到一些新的面孔。

643
00:30:25,290 --> 00:30:27,220
和你们四个有？

644
00:30:27,220 --> 00:30:30,760
和now--我们不要偏见这里 - 和
数字8在这里就完了。

645
00:30:30,760 --> 00:30:32,060
上来吧。

646
00:30:32,060 --> 00:30:32,560
好吧。

647
00:30:32,560 --> 00:30:37,480
所以，我们在这里为
你们每个人是一个数字。

648
00:30:37,480 --> 00:30:40,055
如果你想去
未来，拿这个号码。

649
00:30:40,055 --> 00:30:40,763
你叫什么名字？

650
00:30:40,763 --> 00:30:41,950
>> ARTIE：阿蒂。

651
00:30:41,950 --> 00:30:43,100
>> 大卫马兰：阿蒂，好吧。

652
00:30:43,100 --> 00:30:44,297
你是1号。

653
00:30:44,297 --> 00:30:45,310
>> 阿明：阿明。

654
00:30:45,310 --> 00:30:46,060
大卫马兰：阿明。

655
00:30:46,060 --> 00:30:46,820
大卫。

656
00:30:46,820 --> 00:30:47,530
你是2号。

657
00:30:47,530 --> 00:30:49,100
并继续前进，因为我的手
你的纸的片材，

658
00:30:49,100 --> 00:30:52,130
排队了自己在音乐面前
站在相同的顺序在那里。

659
00:30:52,130 --> 00:30:52,660
>> 安迪：嗨，安迪。

660
00:30:52,660 --> 00:30:53,970
>> 大卫马兰：安迪，很高兴见到你。

661
00:30:53,970 --> 00:30:54,520
3号。

662
00:30:54,520 --> 00:30:55,310
>> 雅各雅各。

663
00:30:55,310 --> 00:30:56,760
>> 大卫马兰：雅各，4号。

664
00:30:56,760 --> 00:30:57,549
欢迎登机。

665
00:30:57,549 --> 00:30:58,090
格兰特：格兰特。

666
00:30:58,090 --> 00:30:58,881
大卫马兰：格兰特。

667
00:30:58,881 --> 00:31:00,348
号码5。

668
00:31:00,348 --> 00:31:01,200
>> ALANNA：Alanna。

669
00:31:01,200 --> 00:31:02,766
>> 大卫马兰：Alanna，6号。

670
00:31:02,766 --> 00:31:03,589
>> FRANCES：弗朗西斯。

671
00:31:03,589 --> 00:31:04,880
大卫马兰：弗朗西斯，7号。

672
00:31:04,880 --> 00:31:05,200
和？

673
00:31:05,200 --> 00:31:05,830
>> RACHEL：瑞秋。

674
00:31:05,830 --> 00:31:06,815
>> 大卫马兰：雷切尔，8号。

675
00:31:06,815 --> 00:31:07,100
好吧。

676
00:31:07,100 --> 00:31:08,766
来吧，让自己在这个秩序。

677
00:31:08,766 --> 00:31:11,440
让我把剩下的一个
乐谱架的地方。

678
00:31:11,440 --> 00:31:13,670
你在哪里需要一个立场？

679
00:31:13,670 --> 00:31:14,170
行。

680
00:31:14,170 --> 00:31:18,710
来吧，只要把你的号码
那里的观众可以看到他们，

681
00:31:18,710 --> 00:31:20,340
在乐谱架朝外。

682
00:31:20,340 --> 00:31:27,240
并希望，我们的第一个
完整性检查这里 -  4，2，6。

683
00:31:27,240 --> 00:31:27,890
哦，哦。

684
00:31:27,890 --> 00:31:29,070
等待一分钟。

685
00:31:29,070 --> 00:31:31,140
我们没有8。

686
00:31:31,140 --> 00:31:35,180
我需要从你驱逐
这个例子莫名其妙。

687
00:31:35,180 --> 00:31:35,680
号

688
00:31:35,680 --> 00:31:36,940
不，没关系。

689
00:31:36,940 --> 00:31:37,890
让我们来看看。

690
00:31:37,890 --> 00:31:38,880
我们可以做到这一点。

691
00:31:38,880 --> 00:31:39,440
支持。

692
00:31:39,440 --> 00:31:43,970

693
00:31:43,970 --> 00:31:45,740
我们走吧。

694
00:31:45,740 --> 00:31:46,800
正确。

695
00:31:46,800 --> 00:31:47,360
好吧。

696
00:31:47,360 --> 00:31:50,260
所以，现在我们有8个，1，3 7 5。

697
00:31:50,260 --> 00:31:50,760
行。

698
00:31:50,760 --> 00:31:51,360
优秀的。

699
00:31:51,360 --> 00:31:54,400
>> 因此，目前的问题是，在
什么样的代价，并通过什么方法，

700
00:31:54,400 --> 00:31:58,580
可我们实际上这些数字在这里进行排序
所以那种认为我们可以倒推，

701
00:31:58,580 --> 00:32:02,759
最终，和decide--是不是真的
令人印象深刻的，是不是真的有效，

702
00:32:02,759 --> 00:32:04,550
我可以分裂，
征服电话簿？

703
00:32:04,550 --> 00:32:06,716
是不是真的有效了
我可以分而治之

704
00:32:06,716 --> 00:32:08,600
这些数字件
纸在黑板上，

705
00:32:08,600 --> 00:32:14,500
如果，也许这将花费我们
发迹于时间或精力或CPU周期

706
00:32:14,500 --> 00:32:17,340
真正让我们的数据
成一些有序？

707
00:32:17,340 --> 00:32:18,930
因此，让我们问这个问题。

708
00:32:18,930 --> 00:32:22,077
>> 所以，首先，这些数字都是
在几乎随机的顺序，

709
00:32:22,077 --> 00:32:24,160
而我要建议
一种算法或过程

710
00:32:24,160 --> 00:32:25,970
通过它，我们可以将这些人进行排序。

711
00:32:25,970 --> 00:32:28,100
我要去接近
这个漂亮的天真。

712
00:32:28,100 --> 00:32:30,730
我要去认识
这是种了很多对我来说

713
00:32:30,730 --> 00:32:32,890
环绕在我的脑海
全部数据设定为一次。

714
00:32:32,890 --> 00:32:33,640
但是你知道吗？

715
00:32:33,640 --> 00:32:37,450
我要做出一些
很简单的边际修正。

716
00:32:37,450 --> 00:32:41,152
4和图2是不按顺序，如果
目标是从1到去多达8。

717
00:32:41,152 --> 00:32:41,860
所以，你知道吗？

718
00:32:41,860 --> 00:32:43,776
我要拥有你
球员交换，如果切换

719
00:32:43,776 --> 00:32:46,380
物理位置和
您的纸片。

720
00:32:46,380 --> 00:32:47,894
现在4和6，这些都是为了。

721
00:32:47,894 --> 00:32:49,060
我要离开的是。

722
00:32:49,060 --> 00:32:50,227
图6和8中，那些符合规定。

723
00:32:50,227 --> 00:32:51,185
要离开他们是。

724
00:32:51,185 --> 00:32:52,170
8 AND1，乱序。

725
00:32:52,170 --> 00:32:54,790
如果你们两个不会介意交换。

726
00:32:54,790 --> 00:32:57,300
现在8和3，如果你们可以交换。

727
00:32:57,300 --> 00:32:59,320
8和7，如果你们可以交换。

728
00:32:59,320 --> 00:33:01,790
8和5，如果你们可以交换。

729
00:33:01,790 --> 00:33:03,980
>> 现在，我是不是做了什么？

730
00:33:03,980 --> 00:33:05,200
不，显然不是。

731
00:33:05,200 --> 00:33:07,880
但我所做的
情况较好的，对不对？

732
00:33:07,880 --> 00:33:09,430
什么又是你的名字，8号？

733
00:33:09,430 --> 00:33:10,055
>> RACHEL：瑞秋。

734
00:33:10,055 --> 00:33:12,850
马兰大卫：所以瑞秋有
有效地冒泡很远，

735
00:33:12,850 --> 00:33:15,660
一路的端
我的数字阵列在这里。

736
00:33:15,660 --> 00:33:17,310
所以这个问题是种解决。

737
00:33:17,310 --> 00:33:21,670
现在，很明显，2仍需要
动了一下，4和6和1。

738
00:33:21,670 --> 00:33:24,420
但我似乎已经获得了
更近些的溶液。

739
00:33:24,420 --> 00:33:26,790
因此，让我们应用同样的
天真的启发式一次。

740
00:33:26,790 --> 00:33:27,690
2和4，确定。

741
00:33:27,690 --> 00:33:28,810
4和6，确定。

742
00:33:28,810 --> 00:33:29,930
图6和1，毫米毫米。

743
00:33:29,930 --> 00:33:32,230
让我们来交换。

744
00:33:32,230 --> 00:33:33,200
图6和3，毫米毫米。

745
00:33:33,200 --> 00:33:34,420
让我们来交换。

746
00:33:34,420 --> 00:33:35,580
6和7就可以了。

747
00:33:35,580 --> 00:33:36,590
7和5，没了。

748
00:33:36,590 --> 00:33:37,790
让我们来交换。

749
00:33:37,790 --> 00:33:38,470
现在图7和8。

750
00:33:38,470 --> 00:33:39,862
而你叫什么名字来着？

751
00:33:39,862 --> 00:33:40,570
FRANCES：弗朗西斯。

752
00:33:40,570 --> 00:33:41,445
大卫马兰：弗朗西斯。

753
00:33:41,445 --> 00:33:44,230
所以，现在弗朗西斯是，即使一个更好的
位置，因为现在7和8

754
00:33:44,230 --> 00:33:46,440
正确鼓泡到顶部。

755
00:33:46,440 --> 00:33:47,510
因此，2和4，确定。

756
00:33:47,510 --> 00:33:48,720
4和1，我们交换。

757
00:33:48,720 --> 00:33:50,410
4和3，让我们交换。

758
00:33:50,410 --> 00:33:51,550
4和6，你真行。

759
00:33:51,550 --> 00:33:53,340
6和5，让我们交换。

760
00:33:53,340 --> 00:33:54,590
而现在那些家伙都不错。

761
00:33:54,590 --> 00:33:55,780
我们快到了。

762
00:33:55,780 --> 00:33:57,706
2和1，乱序，所以交换。

763
00:33:57,706 --> 00:33:59,080
现在让我做一个全面的检查。

764
00:33:59,080 --> 00:34:03,080
图2和3，图3和4，图4和
5,5和6,6和7,8。

765
00:34:03,080 --> 00:34:05,060
好了，我们就大功告成了。

766
00:34:05,060 --> 00:34:09,310
>> 但代价是什么没有我
这些数字在这里进行排序？

767
00:34:09,310 --> 00:34:13,960
那么，有多少步骤可能我做
整理这些人的时候走？

768
00:34:13,960 --> 00:34:15,710
好了，我们会回来的问题。

769
00:34:15,710 --> 00:34:18,030
但是，坦率地说，如果你有
有点无聊，这是

770
00:34:18,030 --> 00:34:22,270
种揭示，这是不
也许是最有效的算法。

771
00:34:22,270 --> 00:34:25,230
事实上，坦率地说，我出汗
更来回走动。

772
00:34:25,230 --> 00:34:26,639
这并没有觉得特别有效率。

773
00:34:26,639 --> 00:34:27,805
因此，让我们试试别的。

774
00:34:27,805 --> 00:34:31,870
如果你们能重置
你们这八个值。

775
00:34:31,870 --> 00:34:32,969
好工作。

776
00:34:32,969 --> 00:34:36,570
>> 让我们来看看数字，对于刚
片刻之前，我们尝试别的东西，

777
00:34:36,570 --> 00:34:38,179
在刚刚发生了什么。

778
00:34:38,179 --> 00:34:41,330
在这里，你即将看到一个
这八人的可视化

779
00:34:41,330 --> 00:34:44,719
由此蓝色和红色
线表示数字。

780
00:34:44,719 --> 00:34:46,670
该高了吧，
更大的数目。

781
00:34:46,670 --> 00:34:48,510
酒吧越短，
数字越小。

782
00:34:48,510 --> 00:34:51,560
而且你会看到什么是在
随机顺序当中超过八人。

783
00:34:51,560 --> 00:34:55,830
你会看到这些酒吧
越来越排序方式是相同的算法，

784
00:34:55,830 --> 00:34:59,890
或指令集，其
我们会打电话给今后冒泡排序。

785
00:34:59,890 --> 00:35:04,000
所以请注意，每一秒左右，
两个酒吧都照亮了红色，

786
00:35:04,000 --> 00:35:05,590
由计算机进行比较。

787
00:35:05,590 --> 00:35:08,630
然后如果大条和
小酒吧是乱序，

788
00:35:08,630 --> 00:35:11,220
他们被交换给我。

789
00:35:11,220 --> 00:35:15,120
>> 现在，这是令人难以置信的繁琐
看这个，当然，

790
00:35:15,120 --> 00:35:18,630
很长，但要注意的
takeaway--大条向右移动，

791
00:35:18,630 --> 00:35:20,460
小棒移动到左侧。

792
00:35:20,460 --> 00:35:23,380
让我们来终止这个进程
并加快这

793
00:35:23,380 --> 00:35:27,330
要快很多，所以我们可以
得到一个什么样的高层次感，

794
00:35:27,330 --> 00:35:29,970
的确，冒泡排序在做什么。

795
00:35:29,970 --> 00:35:33,150
事实上，它的向上冒泡到
列表中的右手侧，

796
00:35:33,150 --> 00:35:35,260
或阵列，更大的酒吧。

797
00:35:35,260 --> 00:35:40,020
反之，小酒吧
鼓泡的方式，以左，

798
00:35:40,020 --> 00:35:42,950
虽然以更快的速度
比我们以前做了。

799
00:35:42,950 --> 00:35:45,850
因此，很难看到人，
但在视觉上这确实是

800
00:35:45,850 --> 00:35:46,540
正在发生的事情。

801
00:35:46,540 --> 00:35:49,110
>> 但是，让我们尝试从根本上
不同的方法了。

802
00:35:49,110 --> 00:35:52,387
让我们尝试不同的
算法即能满足您

803
00:35:52,387 --> 00:35:59,640
球员开始在这些原
位置，这是这个顺序在这里。

804
00:35:59,640 --> 00:36:00,827
而现在让我们继续。

805
00:36:00,827 --> 00:36:02,910
而我要做的事
即使是简单的，对不对？

806
00:36:02,910 --> 00:36:06,710
现在回想起来，再两两交换
又一次，几乎是小聪明。

807
00:36:06,710 --> 00:36:10,460
让我们做事情更天真，
在那里，如果我想这些人进行排序，

808
00:36:10,460 --> 00:36:12,560
让我继续找
为最小的元素。

809
00:36:12,560 --> 00:36:14,570
所以现在，4是
最小号我见过。

810
00:36:14,570 --> 00:36:15,695
我要记住这一点。

811
00:36:15,695 --> 00:36:17,750
不，2是更好的，记住这一点。

812
00:36:17,750 --> 00:36:20,730
1更小。

813
00:36:20,730 --> 00:36:21,970
3，7，5。

814
00:36:21,970 --> 00:36:22,470
行。

815
00:36:22,470 --> 00:36:23,750
埃德蒙顿你叫什么名字来着？

816
00:36:23,750 --> 00:36:24,400
>> ARTIE：阿蒂。

817
00:36:24,400 --> 00:36:24,610
>> 大卫马兰：阿蒂。

818
00:36:24,610 --> 00:36:25,460
因此，阿蒂，勇往直前。

819
00:36:25,460 --> 00:36:27,043
我要拉你出来就行了。

820
00:36:27,043 --> 00:36:28,400
如果你能回到这里来。

821
00:36:28,400 --> 00:36:30,790
我需要腾出空间给他。

822
00:36:30,790 --> 00:36:32,040
我们有一个决策点这里。

823
00:36:32,040 --> 00:36:36,000
怎么可能，我们腾出阿蒂这里
在其中1号所属的开始？

824
00:36:36,000 --> 00:36:36,770
>> 听众：移位。

825
00:36:36,770 --> 00:36:38,950
>> 大卫马兰：好了，我们
可能会改变每一个人。

826
00:36:38,950 --> 00:36:40,860
但提出了一个优化。

827
00:36:40,860 --> 00:36:43,410
这感觉有点恼人
我要问四人

828
00:36:43,410 --> 00:36:44,620
一路向下移动。

829
00:36:44,620 --> 00:36:45,520
我还能做什么？

830
00:36:45,520 --> 00:36:46,360
>> 听众：切换。

831
00:36:46,360 --> 00:36:46,850
>> 大卫马兰：切换。

832
00:36:46,850 --> 00:36:47,900
而你叫什么名字来着？

833
00:36:47,900 --> 00:36:48,441
>> 雅各雅各。

834
00:36:48,441 --> 00:36:50,330
大卫马兰：雅各移动。

835
00:36:50,330 --> 00:36:54,440
更高效只需要有
与阿蒂雅各互换位置，

836
00:36:54,440 --> 00:36:56,710
而不是迫使
这些人的所有四个，

837
00:36:56,710 --> 00:36:58,734
非常感谢你，给
其正确的位置。

838
00:36:58,734 --> 00:37:01,150
有什么好的关于阿蒂现在，
他在他的正确位置。

839
00:37:01,150 --> 00:37:02,060
让我们再次做到这一点。

840
00:37:02,060 --> 00:37:03,730
2，这是最小的数字我见过。

841
00:37:03,730 --> 00:37:05,690
3，7，5。

842
00:37:05,690 --> 00:37:06,190
行。

843
00:37:06,190 --> 00:37:07,467
2，绝对是最小的。

844
00:37:07,467 --> 00:37:08,550
没有做任何工作。

845
00:37:08,550 --> 00:37:09,320
让我们再做一次。

846
00:37:09,320 --> 00:37:10,070
6。

847
00:37:10,070 --> 00:37:10,640
最小？

848
00:37:10,640 --> 00:37:11,140
8。

849
00:37:11,140 --> 00:37:11,590
不。

850
00:37:11,590 --> 00:37:11,720
4？

851
00:37:11,720 --> 00:37:12,220
哦。

852
00:37:12,220 --> 00:37:13,420
我记得4。

853
00:37:13,420 --> 00:37:13,950
3。

854
00:37:13,950 --> 00:37:15,110
我记得3。

855
00:37:15,110 --> 00:37:16,080
7,5。

856
00:37:16,080 --> 00:37:18,490
最小的数字我已经
看到这一关就是3。

857
00:37:18,490 --> 00:37:20,340
如果你会来上了。

858
00:37:20,340 --> 00:37:21,986
我们去哪儿把你吗？

859
00:37:21,986 --> 00:37:22,860
而你叫什么名字？

860
00:37:22,860 --> 00:37:23,530
>> ALANNA：Alanna。

861
00:37:23,530 --> 00:37:25,780
>> 大卫马兰：Alanna，我们
不得不赶你。

862
00:37:25,780 --> 00:37:28,670
但是，这是更有效的，
只是换了两个人，

863
00:37:28,670 --> 00:37:31,850
比有多人
实际上回避了。

864
00:37:31,850 --> 00:37:32,850
现在，让我们再次做到这一点。

865
00:37:32,850 --> 00:37:34,980
我会选择4，所以就来了。

866
00:37:34,980 --> 00:37:36,540
和谁去动？

867
00:37:36,540 --> 00:37:37,750
8号，当然。

868
00:37:37,750 --> 00:37:40,260
如果我现在发现5号，拜托了。

869
00:37:40,260 --> 00:37:42,104
8号会得到再次驱逐。

870
00:37:42,104 --> 00:37:43,770
我现在要去找到位数6。

871
00:37:43,770 --> 00:37:44,410
7到位。

872
00:37:44,410 --> 00:37:45,080
8就位。

873
00:37:45,080 --> 00:37:48,590
>> 我们刚才所做的是
一些所谓的选择排序，

874
00:37:48,590 --> 00:37:52,560
如果我们想象这一点，它的
会觉得有一点不同。

875
00:37:52,560 --> 00:37:56,800
让我们继续前进，从这个
菜单在这里，这visualization--

876
00:37:56,800 --> 00:38:02,920
让我们改变这个to--来吧，Firefox浏览器。

877
00:38:02,920 --> 00:38:07,610
让我们改变这个选择排序。

878
00:38:07,610 --> 00:38:11,830
让像以前一样的加快步伐，
现在开始的可视化。

879
00:38:11,830 --> 00:38:13,990
该算法具有
不同的感觉。

880
00:38:13,990 --> 00:38:16,480
在每次迭代中，坦率地说，
它更简单。

881
00:38:16,480 --> 00:38:18,385
我只是选择的最小元素。

882
00:38:18,385 --> 00:38:21,510
现在，坦率地说，我有点幸运，
时间，在它的排序超快。

883
00:38:21,510 --> 00:38:22,660
这些元素是随机的。

884
00:38:22,660 --> 00:38:25,520
这不是，因为我们最终会
看，根本快。

885
00:38:25,520 --> 00:38:29,400
但是，让我们看到了第三次也是最后
此方法，因为要发生的事情。

886
00:38:29,400 --> 00:38:36,230
因此，让我们继续前进，重新你们
一最后一次是在这里这个顺序。

887
00:38:36,230 --> 00:38:38,450
>> 而现在，我要
有一点更聪明，

888
00:38:38,450 --> 00:38:40,220
只是圆了我们的算法。

889
00:38:40,220 --> 00:38:41,230
我会做到这一点。

890
00:38:41,230 --> 00:38:43,140
我会不会去
来回这么多。

891
00:38:43,140 --> 00:38:44,900
坦率地说，我已经厌倦了
这一切的穿越。

892
00:38:44,900 --> 00:38:47,691
我只是要带什么，我
在列表的开头给出

893
00:38:47,691 --> 00:38:49,460
我要去排序
那，然后有。

894
00:38:49,460 --> 00:38:50,140
所以，我们在这里。

895
00:38:50,140 --> 00:38:51,030
4号。

896
00:38:51,030 --> 00:38:53,680
我要插入数
4成排序的列表。

897
00:38:53,680 --> 00:38:54,180
完成。

898
00:38:54,180 --> 00:38:58,300
我现在声称，只是让这个更
显然，这部分我的列表进行排序。

899
00:38:58,300 --> 00:39:02,610
这是一种愚蠢的索赔，但确确实实
4是按尺寸1的列表。

900
00:39:02,610 --> 00:39:04,210
现在，我要承担数2。

901
00:39:04,210 --> 00:39:07,670
2号，我现在要
插入到合适的位置。

902
00:39:07,670 --> 00:39:08,680
那么，这是否属于2？

903
00:39:08,680 --> 00:39:09,824
显然，在这里。

904
00:39:09,824 --> 00:39:11,490
所以，尽管回迁，如果你能。

905
00:39:11,490 --> 00:39:14,406
而为什么你们不只是把
你的音乐代表了你这一次。

906
00:39:14,406 --> 00:39:17,020
而且，我们强行插入您
到列表的开头。

907
00:39:17,020 --> 00:39:17,936
所以，更多一点的工作。

908
00:39:17,936 --> 00:39:20,890
我不得不提出雅各布身边，
而你叫什么名字？

909
00:39:20,890 --> 00:39:21,420
>> 阿明：阿明。

910
00:39:21,420 --> 00:39:22,270
>> 大卫马兰：阿明。

911
00:39:22,270 --> 00:39:24,350
但至少我没有去来回。

912
00:39:24,350 --> 00:39:25,739
我只是以事，我去。

913
00:39:25,739 --> 00:39:27,530
我只是将它们插入
在正确的地方。

914
00:39:27,530 --> 00:39:29,220
6，其实这是很容易的。

915
00:39:29,220 --> 00:39:31,510
让我们将你在那边，如果你
只是想稍微移动了。

916
00:39:31,510 --> 00:39:32,870
8号，也非常的方便。

917
00:39:32,870 --> 00:39:33,741
就在那边。

918
00:39:33,741 --> 00:39:34,240
该死的。

919
00:39:34,240 --> 00:39:37,590
1号，我们不能只
与阿明在这里交换，

920
00:39:37,590 --> 00:39:39,340
因为这是怎么回事
乱了秩序。

921
00:39:39,340 --> 00:39:40,660
因此，我们要多一点聪明。

922
00:39:40,660 --> 00:39:42,770
因此，阿蒂，如果你能
备份了一下。

923
00:39:42,770 --> 00:39:46,550
让我们继续前进，现在转移，
不像我们以前的算法，

924
00:39:46,550 --> 00:39:50,910
让路给阿蒂
这里开头。

925
00:39:50,910 --> 00:39:54,690
所以，在这一天结束时，我种
做什么，我想避免之前。

926
00:39:54,690 --> 00:39:57,770
所以我的算法排序
逆转，智，

927
00:39:57,770 --> 00:39:59,070
从它最初是什么。

928
00:39:59,070 --> 00:40:01,240
我只是在做转移
在不同的点。

929
00:40:01,240 --> 00:40:02,291
现在，我在3。

930
00:40:02,291 --> 00:40:02,790
哦，该死的。

931
00:40:02,790 --> 00:40:04,039
我们必须重新做更多的工作。

932
00:40:04,039 --> 00:40:05,060
因此，让我们推你出去。

933
00:40:05,060 --> 00:40:09,360
让我们继续前进8,6，4--哦oh--和
3是要去那里。

934
00:40:09,360 --> 00:40:11,490
所以至少略有节余这个时候。

935
00:40:11,490 --> 00:40:13,100
7，没有太多的工作要做。

936
00:40:13,100 --> 00:40:15,370
所以，如果你想弹出
回来了，让我们来插入你。

937
00:40:15,370 --> 00:40:17,440
最后，图5，如果你
想弹回，我们

938
00:40:17,440 --> 00:40:22,610
需要转向你，你，
你，直到5到位。

939
00:40:22,610 --> 00:40:25,670
>> 所以，现在看到了这点
高水平的图形，

940
00:40:25,670 --> 00:40:31,080
让我们做这个算法
可视化的一个额外的时间。

941
00:40:31,080 --> 00:40:33,580
所以这个我们称之为插入排序。

942
00:40:33,580 --> 00:40:37,700
我们会运行它就像
快，从这里开始吧。

943
00:40:37,700 --> 00:40:39,580
而且，也有不同的感受。

944
00:40:39,580 --> 00:40:42,180
这有点越来越好，
好，但它从来就不是完美

945
00:40:42,180 --> 00:40:44,630
直到我走在光滑的这些差距。

946
00:40:44,630 --> 00:40:47,860
因为，同样的，我只服用了
我正考虑由左到右。

947
00:40:47,860 --> 00:40:50,350
所以，我没有那么幸运了
这一切都是完美的。

948
00:40:50,350 --> 00:40:54,190
这就是为什么我们有这些小
我们在固定的时间mispositions。

949
00:40:54,190 --> 00:40:58,890
>> 因此，所有这些算法似乎
在略微不同的速度运行。

950
00:40:58,890 --> 00:41:02,030
事实上，你想说的是
最好的或迄今最快？

951
00:41:02,030 --> 00:41:03,450
冒泡排序，第一个？

952
00:41:03,450 --> 00:41:05,000
选择排序，第二次？

953
00:41:05,000 --> 00:41:08,450
插入排序，第三？

954
00:41:08,450 --> 00:41:10,710
我听到了一些选择排序。

955
00:41:10,710 --> 00:41:13,280
其他的想法？

956
00:41:13,280 --> 00:41:16,880
>> 所以，事实证明，
所有这些算法

957
00:41:16,880 --> 00:41:22,400
基本上是一样有效，因为
每个other--或者相反，正如

958
00:41:22,400 --> 00:41:25,980
低效的，彼此
因为我们能做到从根本上

959
00:41:25,980 --> 00:41:28,120
不是所有的三个好
这些算法。

960
00:41:28,120 --> 00:41:29,990
而这一点善意的谎言的，太。

961
00:41:29,990 --> 00:41:32,580
当我说是有效的
或者效率低下，

962
00:41:32,580 --> 00:41:35,040
这至少为
超级大n值的。

963
00:41:35,040 --> 00:41:38,450
当我们只有八人在这里，
或者是50元左右吧在屏幕上，

964
00:41:38,450 --> 00:41:41,645
你会发现绝对差异
其中这3种算法。

965
00:41:41,645 --> 00:41:44,020
但随着N，人数，
或号码的数目，

966
00:41:44,020 --> 00:41:46,350
或者人在电话号码
书，或网页的数

967
00:41:46,350 --> 00:41:48,230
在谷歌的数据库
变得越来越大，

968
00:41:48,230 --> 00:41:51,650
我们会看到，所有这三个
算法实际上是非常差的。

969
00:41:51,650 --> 00:41:54,060
而我们能做的根本
比这更好。

970
00:41:54,060 --> 00:41:56,830
>> 让我们来看看，最后，
什么这些算法可能

971
00:41:56,830 --> 00:41:59,520
听起来像在
几人背景

972
00:41:59,520 --> 00:42:03,550
并通过这种方式
可视化在这里

973
00:42:03,550 --> 00:42:06,860
这将我们介绍给
一些算法。

974
00:42:06,860 --> 00:42:10,330
让我们继续前进，并祝贺
在这里我们的参与者，所有的人

975
00:42:10,330 --> 00:42:11,690
整理自己很好。

976
00:42:11,690 --> 00:42:15,124
如果你想借此临别礼物。

977
00:42:15,124 --> 00:42:16,540
你可以把你的号码也是如此。

978
00:42:16,540 --> 00:42:19,460

979
00:42:19,460 --> 00:42:22,520
你会看到什么，
或者更确切地说，听，现在，

980
00:42:22,520 --> 00:42:25,710
是因为我们把声音
每个这些条

981
00:42:25,710 --> 00:42:28,660
并将其与软件相关联，
不同频率的声音，

982
00:42:28,660 --> 00:42:33,970
你可以用你的头脑更audioly
各地各有什么这些东西

983
00:42:33,970 --> 00:42:34,470
看起来像。

984
00:42:34,470 --> 00:42:39,325
其中第一个是插入排序

985
00:42:39,325 --> 00:42:44,275
>> [音调]

986
00:42:44,275 --> 00:42:47,245

987
00:42:47,245 --> 00:42:49,720
>> 这是冒泡排序。

988
00:42:49,720 --> 00:42:54,175
>> [音调]

989
00:42:54,175 --> 00:43:17,250

990
00:43:17,250 --> 00:43:18,222
>> 选择排序。

991
00:43:18,222 --> 00:43:22,596
>> [音调]

992
00:43:22,596 --> 00:43:33,570

993
00:43:33,570 --> 00:43:35,150
>> 一些所谓的合并排序。

994
00:43:35,150 --> 00:43:38,140
>> [音调]

995
00:43:38,140 --> 00:43:49,510

996
00:43:49,510 --> 00:43:51,278
>> 侏儒排序。

997
00:43:51,278 --> 00:43:56,390
>> [音调]

998
00:43:56,390 --> 00:44:08,240

999
00:44:08,240 --> 00:44:09,430
>> 这就是它的CS50。

1000
00:44:09,430 --> 00:44:13,360
我们会看到你在星期三。

1001
00:44:13,360 --> 00:44:16,671
>> 旁白：现在，“深
思考“，由Daven法纳姆。

1002
00:44:16,671 --> 00:44:19,910

1003
00:44:19,910 --> 00:44:21,590
为什么一个循环？

1004
00:44:21,590 --> 00:44:23,200
为什么不让它变得更好？

1005
00:44:23,200 --> 00:44:25,970
我做了五圈。

1006
00:44:25,970 --> 00:44:28,720
>> [笑]