1
00:00:00,000 --> 00:00:12,610

2
00:00:12,610 --> 00:00:12,900
>> DAVID J.马兰：好的。

3
00:00:12,900 --> 00:00:16,790
所以欢迎大家来首次
CS50死后来做个测试​​。

4
00:00:16,790 --> 00:00:18,340
我们认为我们会开幕
这一传统在今年。

5
00:00:18,340 --> 00:00:20,960
这将是一个机会
漫步

6
00:00:20,960 --> 00:00:22,220
解决方案的测试。

7
00:00:22,220 --> 00:00:26,160
我们会加快或基于放缓
对那些在这里的利益。

8
00:00:26,160 --> 00:00:29,730
>> 所以你可能在这里，因为你
感兴趣的是如何你可以有或

9
00:00:29,730 --> 00:00:31,170
应该回答一些
的这些问题。

10
00:00:31,170 --> 00:00:33,300
那么我们为什么不来看看
在本节第一？

11
00:00:33,300 --> 00:00:34,450
因此让字符串。

12
00:00:34,450 --> 00:00:37,600
这给了你三个不同的版本
一个程序，是的，最终，

13
00:00:37,600 --> 00:00:39,650
为了从用户获得一个字符串。

14
00:00:39,650 --> 00:00:42,530
不论它这样做是
留给你来决定。

15
00:00:42,530 --> 00:00:45,150
>> 我们问的问题0，
假设第1版

16
00:00:45,150 --> 00:00:46,400
编译和执行。

17
00:00:46,400 --> 00:00:48,860
为什么会程序出现段错误？

18
00:00:48,860 --> 00:00:51,150
乍一看，有什么建​​议
至于为什么？

19
00:00:51,150 --> 00:00:54,012

20
00:00:54,012 --> 00:00:54,489
是啊。

21
00:00:54,489 --> 00:00:59,260
>> 观众：所以我记得在看到这个
看着在前面的例子

22
00:00:59,260 --> 00:01:05,506
的char * s和看到S的扫描和
看到因为它是一个指针，如何

23
00:01:05,506 --> 00:01:07,971
没有它会影响您的扫描？

24
00:01:07,971 --> 00:01:10,940
它是S或s的地址？

25
00:01:10,940 --> 00:01:11,180
>> DAVID J.马兰：确定。

26
00:01:11,180 --> 00:01:11,480
好。

27
00:01:11,480 --> 00:01:14,830
所以，最后，任何问题的来源
大概是要减少

28
00:01:14,830 --> 00:01:16,210
该变量s。

29
00:01:16,210 --> 00:01:17,280
而且这的确是一个变量。

30
00:01:17,280 --> 00:01:19,900
该变量的数据类型是
的char *，这意味着它要

31
00:01:19,900 --> 00:01:22,570
包含一个字符的地址。

32
00:01:22,570 --> 00:01:23,850
而这其中就有敏锐的洞察力。

33
00:01:23,850 --> 00:01:28,330
它要包含的地址
一个字符，或者更一般地，本

34
00:01:28,330 --> 00:01:32,110
在第一个字符的地址
字符的整个块。

35
00:01:32,110 --> 00:01:36,680
>> 但美中不足的是，扫描秒，目的在
生活中，被赋予一个地址和给定的

36
00:01:36,680 --> 00:01:40,960
格式的代码，如％s，读取
字符串转换成的块

37
00:01:40,960 --> 00:01:42,330
存储在该地址。

38
00:01:42,330 --> 00:01:46,040
但因为没有等号前
在第一次的分号

39
00:01:46,040 --> 00:01:49,310
一行代码，因为我们实际上并不
分配任何内存

40
00:01:49,310 --> 00:01:53,020
malloc的，其实是因为它没有
分配一些大小的数组，所有

41
00:01:53,020 --> 00:01:57,620
你正在做的是读取用户
键盘输入到一些完整的

42
00:01:57,620 --> 00:02:00,490
垃圾值，
是s中默认情况​​下。

43
00:02:00,490 --> 00:02:04,480
所以赔率是你要出现段错误，如果
该地址并不仅仅如此发生

44
00:02:04,480 --> 00:02:08,009
是一个值就可以了，
其实，写。

45
00:02:08,009 --> 00:02:10,889
如此糟糕不分配
你的内存有。

46
00:02:10,889 --> 00:02:13,150
>> 因此，在问题1中，我们问，
假设2版

47
00:02:13,150 --> 00:02:14,230
编译和执行。

48
00:02:14,230 --> 00:02:15,900
为什么会这个程序出现段错误？

49
00:02:15,900 --> 00:02:17,990
所以这一块是bug更少。

50
00:02:17,990 --> 00:02:21,470
而且也真的只有一个
显而易见的方法，你可以

51
00:02:21,470 --> 00:02:22,810
这里触发段错误。

52
00:02:22,810 --> 00:02:23,730
这是主题。

53
00:02:23,730 --> 00:02:28,180
任何我们用c + +在内存中的时间，有什么
你能做些什么来诱发段错误

54
00:02:28,180 --> 00:02:30,718
与第2版？

55
00:02:30,718 --> 00:02:35,560
>> 观众：如果您使用的输入
一个字符串，它比49再

56
00:02:35,560 --> 00:02:35,975
字符。

57
00:02:35,975 --> 00:02:37,260
>> DAVID J.马兰：没错。

58
00:02:37,260 --> 00:02:41,420
你看到的东西固定长度的任何时间
当它涉及到一个数组，你

59
00:02:41,420 --> 00:02:44,650
雷达会熄灭，这可能是
有问题的，如果你不检查

60
00:02:44,650 --> 00:02:45,810
阵列的界限。

61
00:02:45,810 --> 00:02:46,650
这就是这里的问题。

62
00:02:46,650 --> 00:02:47,910
我们仍然使用scanf函数。

63
00:02:47,910 --> 00:02:52,200
我们还在用％s，这意味着尝试
从用户读取的字符串。

64
00:02:52,200 --> 00:02:56,300
这就是它会被读成s，，
在这一点上，是有效的

65
00:02:56,300 --> 00:02:58,570
内存块的地址
或同类产品。

66
00:02:58,570 --> 00:03:02,080
这是一个数组的名字
的内存字符。

67
00:03:02,080 --> 00:03:07,610
>> 但恰恰是，如果你读一个字符串
这是超过49个字符，49长

68
00:03:07,610 --> 00:03:10,440
因为你需要的空间反斜线
0，你要溢出

69
00:03:10,440 --> 00:03:11,390
该缓冲区。

70
00:03:11,390 --> 00:03:16,410
你可能会得到幸运，能够
写一个字第51，第52，第53。

71
00:03:16,410 --> 00:03:18,560
但在某些时候，操作系统
会说，没有。

72
00:03:18,560 --> 00:03:21,270
这绝对不是内存
你不准碰。

73
00:03:21,270 --> 00:03:23,380
并且程序将会出现段错误。

74
00:03:23,380 --> 00:03:26,650
>> 因此，启发式应该有任何
你已经有了固定长度的时间，你有

75
00:03:26,650 --> 00:03:30,150
确保你检查的长度
不管它是什么你想要

76
00:03:30,150 --> 00:03:31,090
读了进去。

77
00:03:31,090 --> 00:03:35,110
>> 观众：所以要解决这个问题，你可以
有一个说法实际上检查

78
00:03:35,110 --> 00:03:37,140
为长度大于
大于或小于？

79
00:03:37,140 --> 00:03:37,730
>> DAVID J.马兰：当然可以。

80
00:03:37,730 --> 00:03:41,706
你只需要一个条件
那说，如果 - 

81
00:03:41,706 --> 00:03:46,080
或者说你不一定知道
提前多少个字符

82
00:03:46,080 --> 00:03:49,060
用户将要输入时，因为
你有鸡和蛋。

83
00:03:49,060 --> 00:03:51,860
直到你跟scanf函数读取它
你可以计算出它有多长。

84
00:03:51,860 --> 00:03:54,500
但在这一点上，为时已晚，
因为你已经将它读入

85
00:03:54,500 --> 00:03:55,710
一些内存块。

86
00:03:55,710 --> 00:03:59,590
所以，作为一个在旁边，CS50库避免了
这个问题完全，召回

87
00:03:59,590 --> 00:04:01,060
用龟etc。

88
00:04:01,060 --> 00:04:05,390
它读取一个字符时，
针尖沿着八字，知道你

89
00:04:05,390 --> 00:04:08,060
不能溢出一个字符，如果
你读一次。

90
00:04:08,060 --> 00:04:11,580
>> 美中不足的是GetString的召回
我们必须不断地调整大小

91
00:04:11,580 --> 00:04:13,590
那大块的内存，这
仅仅是一个痛苦。

92
00:04:13,590 --> 00:04:15,310
这是一个很大的行
代码来做到这一点。

93
00:04:15,310 --> 00:04:18,779
因此，另一种方法是将
实际使用的表弟，所以

94
00:04:18,779 --> 00:04:19,790
说话scanf函数的。

95
00:04:19,790 --> 00:04:22,820
有很多这样的变种
功能，实际上检查

96
00:04:22,820 --> 00:04:25,870
的长度多少个字符
你可能会最大限度地阅读。

97
00:04:25,870 --> 00:04:29,430
并且您可以指定，不读
超过50个字符。

98
00:04:29,430 --> 00:04:34,110
所以这将是另一种方法，但
更大的投入较少宽松。

99
00:04:34,110 --> 00:04:37,040
>> 所以，问题2问，假设版本
3编译和执行。

100
00:04:37,040 --> 00:04:39,960
为什么会是程序出现段错误？

101
00:04:39,960 --> 00:04:42,650
所以这一块实际上是相同的
回答，即使它

102
00:04:42,650 --> 00:04:43,590
看起来有点票友。

103
00:04:43,590 --> 00:04:46,440
我们正在使用的malloc，这感觉就像
我们正在给自己更多的选择。

104
00:04:46,440 --> 00:04:48,030
然后我们释放了
存储在末尾。

105
00:04:48,030 --> 00:04:49,580
它仍然只有50个字节的内存。

106
00:04:49,580 --> 00:04:53,620
因此，我们可能仍然尝试读取
在51，52，1000字节。

107
00:04:53,620 --> 00:04:55,830
它会出现段错误的
正是由于同样的原因。

108
00:04:55,830 --> 00:04:57,530
>> 但还有另外一个原因了。

109
00:04:57,530 --> 00:05:03,890
还有什么能malloc返回除了
内存块的地址？

110
00:05:03,890 --> 00:05:04,920
它可能返回null。

111
00:05:04,920 --> 00:05:07,560
而且因为我们不检查
这一点，我们可能会做一些

112
00:05:07,560 --> 00:05:11,350
愚蠢的另一个原因，那就是
我们可能会告诉scanf函数，读取

113
00:05:11,350 --> 00:05:16,050
用户从键盘输入
到0的位置，又名空。

114
00:05:16,050 --> 00:05:18,890
而这，也一定会
触发段错误。

115
00:05:18,890 --> 00:05:21,590
所以对于测验的目的，我们将
已接受或者那些作为的

116
00:05:21,590 --> 00:05:22,740
正当理由。

117
00:05:22,740 --> 00:05:23,420
一个是相同的。

118
00:05:23,420 --> 00:05:25,720
一个是多了几分微妙。

119
00:05:25,720 --> 00:05:28,975
>> 最后，相对于该节目的
使用的内存，怎么办第2版和

120
00:05:28,975 --> 00:05:30,350
第3版有什么区别？

121
00:05:30,350 --> 00:05:35,070
因此，对于它的价值，我们看到了一个
可能看似源源不绝

122
00:05:35,070 --> 00:05:35,770
回答这个。

123
00:05:35,770 --> 00:05:39,300
而人与人之间的答案，我们都
希望，但我们接受的其他

124
00:05:39,300 --> 00:05:42,250
的东西，是一些提到的
事实上版本2使用

125
00:05:42,250 --> 00:05:44,560
所谓堆栈。

126
00:05:44,560 --> 00:05:46,710
版本3正在使用的堆。

127
00:05:46,710 --> 00:05:50,060
而在功能上，这并没有真正
让所有的多大的差别。

128
00:05:50,060 --> 00:05:54,040
在一天结束的时候，我们仍然
刚开50字节的内存。

129
00:05:54,040 --> 00:05:56,640
>> 但是，这是可能的答案之一
我们在看。

130
00:05:56,640 --> 00:05:59,730
但你会看到，当你得到你的测验
从转录因子回首，那我们做

131
00:05:59,730 --> 00:06:04,330
接受其他讨论他们的
内存完全不同的用途。

132
00:06:04,330 --> 00:06:08,600
但堆栈和堆本来
一个简单的答案去用。

133
00:06:08,600 --> 00:06:11,150
有问题吗？

134
00:06:11,150 --> 00:06:12,400
我给你抢。

135
00:06:12,400 --> 00:06:18,360

136
00:06:18,360 --> 00:06:20,210
>> ROB BOWDEN：所以问题4。

137
00:06:20,210 --> 00:06:21,985
这是一个在那里你必须填写
在字节数出所有的

138
00:06:21,985 --> 00:06:23,460
这些不同类型的使用。

139
00:06:23,460 --> 00:06:24,830
我们看到那么第一件事情。

140
00:06:24,830 --> 00:06:27,930
假设一个32-bit架构，
这样CS50设备。

141
00:06:27,930 --> 00:06:33,530
所以对基本的事情之一
32位体系结构，它告诉我们

142
00:06:33,530 --> 00:06:37,490
到底有多大的指针是怎么回事
是在体系结构。

143
00:06:37,490 --> 00:06:43,020
>> 于是马上，我们知道，任何指针
类型是32位或4个字节。

144
00:06:43,020 --> 00:06:46,010
所以看这个表，
节点*为指针类型。

145
00:06:46,010 --> 00:06:47,250
这将是4个字节。

146
00:06:47,250 --> 00:06:51,640
结构节点*，这是字面上
相同的节点明星。

147
00:06:51,640 --> 00:06:53,590
所以那将是4个字节。

148
00:06:53,590 --> 00:06:58,270
字符串，所以它看起来并不像一个
指针还，但自定义类型，一

149
00:06:58,270 --> 00:07:01,590
字符串只是一个char *，这
为指针类型。

150
00:07:01,590 --> 00:07:03,550
所以这将是4个字节。

151
00:07:03,550 --> 00:07:06,150
>> 所以，这三个都是4个字节。

152
00:07:06,150 --> 00:07:09,350
现在，节点和学生都
更复杂一点。

153
00:07:09,350 --> 00:07:15,160
所以看着节点和学生，我们看到
节点为一个整数和一个指针。

154
00:07:15,160 --> 00:07:18,050
和学生是两个指针
里面的它。

155
00:07:18,050 --> 00:07:23,340
所以至少在我们的情况下在这里，该方法
我们最终计算的大小

156
00:07:23,340 --> 00:07:27,020
这个结构是只加了一切
这就是结构体里面。

157
00:07:27,020 --> 00:07:30,690
>> 因此，对于节点，我们有一个整数，
这是4个字节。

158
00:07:30,690 --> 00:07:32,830
我们有一个指针，它是4个字节。

159
00:07:32,830 --> 00:07:35,820
所以一个节点是怎么回事
占用8个字节。

160
00:07:35,820 --> 00:07:39,490
同样的学生，我们有
指针，该指针是4字节而另一个

161
00:07:39,490 --> 00:07:40,770
指针就是4个字节。

162
00:07:40,770 --> 00:07:43,180
所以这将结束
最高为8个字节。

163
00:07:43,180 --> 00:07:45,480
因此，节点和学生都是8个字节。

164
00:07:45,480 --> 00:07:48,950
而这三项都是4个字节。

165
00:07:48,950 --> 00:07:50,240
该问题？

166
00:07:50,240 --> 00:07:54,640

167
00:07:54,640 --> 00:07:54,990
是。

168
00:07:54,990 --> 00:07:58,413
>> 观众：是它是一个64位
建筑，那会

169
00:07:58,413 --> 00:07:59,880
加倍所有的人？

170
00:07:59,880 --> 00:08:01,790
>> ROB BOWDEN：不会
加倍所有的人。

171
00:08:01,790 --> 00:08:05,830
因此，64位架构，它再次，
的变化，根本的东西，一个

172
00:08:05,830 --> 00:08:08,910
指针现在是64位。

173
00:08:08,910 --> 00:08:09,290
是啊。

174
00:08:09,290 --> 00:08:10,930
这样一个指针是8个字节。

175
00:08:10,930 --> 00:08:15,420
因此，这些是分别为4个字节
都将是8个字节。

176
00:08:15,420 --> 00:08:18,617
一个学生，这是两个指针，
好了，现在它要

177
00:08:18,617 --> 00:08:19,800
是8个字节，8字节。

178
00:08:19,800 --> 00:08:21,980
这将会使16个字节。

179
00:08:21,980 --> 00:08:25,710
>> 但一个节点仍然是4个字节。

180
00:08:25,710 --> 00:08:27,800
所以这个指针是怎么回事
为8字节。

181
00:08:27,800 --> 00:08:28,930
这是4个字节。

182
00:08:28,930 --> 00:08:30,870
所以一个节点只打算
为12个字节。

183
00:08:30,870 --> 00:08:36,309

184
00:08:36,309 --> 00:08:39,280
在那一个别的问题吗？

185
00:08:39,280 --> 00:08:44,500
所以，下一个，这些都是
HTTP状态码。

186
00:08:44,500 --> 00:08:48,000
而你必须描述的情况
根据这些威力

187
00:08:48,000 --> 00:08:49,810
退还给您。

188
00:08:49,810 --> 00:08:56,730
我听到有些同学一个问题
有是，他们试图使

189
00:08:56,730 --> 00:08:58,950
错误是在客户端的结束。

190
00:08:58,950 --> 00:09:02,320
所以，当我们试图提出要求
到服务器上，出了

191
00:09:02,320 --> 00:09:03,820
错在我们这边。

192
00:09:03,820 --> 00:09:07,660
但一般来说，这些代码是
服务器正在返回。

193
00:09:07,660 --> 00:09:11,720
因此，我们要弄清楚这是怎么回事
错误或正确的服务器上

194
00:09:11,720 --> 00:09:14,280
导致返回这些东西。

195
00:09:14,280 --> 00:09:18,670
那么，为什么一个服务器返回
状态代码200？

196
00:09:18,670 --> 00:09:19,920
有什么想法？

197
00:09:19,920 --> 00:09:23,360

198
00:09:23,360 --> 00:09:23,730
>> 是啊。

199
00:09:23,730 --> 00:09:27,850
因此，一些关于成功
请求经历。

200
00:09:27,850 --> 00:09:30,260
而且他们能够返回
不管你提出的要求。

201
00:09:30,260 --> 00:09:32,240
所以，一切都很好。

202
00:09:32,240 --> 00:09:35,662
怎么样302发现了什么？

203
00:09:35,662 --> 00:09:36,618
是啊。

204
00:09:36,618 --> 00:09:39,008
>> 观众：服务器一直在寻找
为你所要求的。

205
00:09:39,008 --> 00:09:40,442
但无法找到它。

206
00:09:40,442 --> 00:09:42,850
所以这是一个错误。

207
00:09:42,850 --> 00:09:47,720
>> ROB BOWDEN：那么服务器是
找你想要的东西。

208
00:09:47,720 --> 00:09:51,682
所以只是看这里，302发现，
它能够找到它。

209
00:09:51,682 --> 00:09:53,035
>> 观众：我很抱歉。

210
00:09:53,035 --> 00:09:54,388
发现意味着，他们没有找到它。

211
00:09:54,388 --> 00:09:55,638
抱歉。

212
00:09:55,638 --> 00:09:58,120

213
00:09:58,120 --> 00:10:00,160
>> ROB BOWDEN：那么302个记录。

214
00:10:00,160 --> 00:10:02,350
该服务器能够找到
你想要的东西。

215
00:10:02,350 --> 00:10:04,640
>> 观众：但它不显示呢？

216
00:10:04,640 --> 00:10:08,180
>> ROB BOWDEN：之间的区别
这个302和200的是，它

217
00:10:08,180 --> 00:10:09,280
知道你想要什么。

218
00:10:09,280 --> 00:10:12,000
但它是不完全的地方
你要问。

219
00:10:12,000 --> 00:10:14,580
所以302是一个典型的重定向。

220
00:10:14,580 --> 00:10:16,510
所以，你所请求的页面。

221
00:10:16,510 --> 00:10:19,590
它知道，哦，我想
给你退货。

222
00:10:19,590 --> 00:10:21,070
但是，这是在一个不同的URL。

223
00:10:21,070 --> 00:10:23,534
所以，嘿，你真正想要的。

224
00:10:23,534 --> 00:10:26,950
>> DAVID J.马兰：这是一块提到
我们给你们一个重定向

225
00:10:26,950 --> 00:10:30,830
函数所使用的头功能
这，反过来，打印出来的位置，

226
00:10:30,830 --> 00:10:34,110
冒号，然后到的URL
你要拒绝的用户。

227
00:10:34,110 --> 00:10:37,480
即使你没看见302
明确存在，这就是PHP的

228
00:10:37,480 --> 00:10:41,550
会奇迹般地插入的标头
说正是罗布说有 - 

229
00:10:41,550 --> 00:10:41,930
发现。

230
00:10:41,930 --> 00:10:43,180
但到这里吧。

231
00:10:43,180 --> 00:10:45,960

232
00:10:45,960 --> 00:10:46,160
>> ROB BOWDEN：确定。

233
00:10:46,160 --> 00:10:47,630
那么，关于403被禁止？

234
00:10:47,630 --> 00:10:52,240

235
00:10:52,240 --> 00:10:57,120
>> 观众：我认为这是服务器
基本上说，在客户端

236
00:10:57,120 --> 00:10:59,970
无法访问主页。

237
00:10:59,970 --> 00:11:03,260
>> ROB BOWDEN：所以，是的。

238
00:11:03,260 --> 00:11:07,670
嗯，典型的答案我们
期待是一样的东西，这些文件

239
00:11:07,670 --> 00:11:08,920
没有适当chmodded。

240
00:11:08,920 --> 00:11:11,590
这可能是在什么情况下
你看见了他们。

241
00:11:11,590 --> 00:11:18,920
但还有一个原因，客户端
可能是错在这里。

242
00:11:18,920 --> 00:11:20,440
实际上，有另外一个状态代码 - 

243
00:11:20,440 --> 00:11:21,210
401。

244
00:11:21,210 --> 00:11:22,820
因此，这些都是非常相似的。

245
00:11:22,820 --> 00:11:24,590
>> 401是未经授权的。

246
00:11:24,590 --> 00:11:26,130
而403是被禁止的。

247
00:11:26,130 --> 00:11:31,890
所以你们擅自专
如果你没有登录。得到

248
00:11:31,890 --> 00:11:34,520
但登录可能意味着
你被授权。

249
00:11:34,520 --> 00:11:37,930
但如果你已经登录，并且您
仍然没有权限，然后

250
00:11:37,930 --> 00:11:40,140
你也可以禁止。

251
00:11:40,140 --> 00:11:45,320
所以，如果你登录并且没有
许可，严禁也是

252
00:11:45,320 --> 00:11:47,164
有些东西你可以得到的。

253
00:11:47,164 --> 00:11:48,900
>> DAVID J.马兰：而到了机制
这些问题通常是

254
00:11:48,900 --> 00:11:53,100
解决了在服务器上是
通过什么命令？

255
00:11:53,100 --> 00:11:57,700
文件模式，如果是，的确，一个权限
发出的文件或目录。

256
00:11:57,700 --> 00:11:59,220
>> ROB BOWDEN：那404未找​​到。

257
00:11:59,220 --> 00:12:03,100

258
00:12:03,100 --> 00:12:03,470
是啊。

259
00:12:03,470 --> 00:12:10,150
所以不像302的地方是不完全
在那里你问，但它知道什么

260
00:12:10,150 --> 00:12:12,710
你想，这一点，它只是
不知道你想要什么。

261
00:12:12,710 --> 00:12:15,648
而你没有请求
一些有效的。

262
00:12:15,648 --> 00:12:18,580

263
00:12:18,580 --> 00:12:22,310
418我是一个茶壶，然后
500内部服务器。

264
00:12:22,310 --> 00:12:24,870
那么，为什么你明白了吗？

265
00:12:24,870 --> 00:12:26,120
>> 所以出现段错误 - 

266
00:12:26,120 --> 00:12:28,760

267
00:12:28,760 --> 00:12:30,640
我居然不知道该分级
标准这一点。

268
00:12:30,640 --> 00:12:34,850
但是，如果你的PHP代码有一些东西
错了，从理论上讲，它可以

269
00:12:34,850 --> 00:12:39,650
实际上段错误，在这种情况下，这
500内部服务器错误，东西

270
00:12:39,650 --> 00:12:41,400
是错误的与您的服务器的
配置。

271
00:12:41,400 --> 00:12:44,320
或者有语法错误
在你的PHP代码。

272
00:12:44,320 --> 00:12:46,095
或坏事是怎么回事。

273
00:12:46,095 --> 00:12:48,320
>> DAVID J.马兰：我们确实看到段错误
其中几个人的答案。

274
00:12:48,320 --> 00:12:49,490
而在技术上，它可能发生。

275
00:12:49,490 --> 00:12:53,820
但是这将是一个PHP的程序
其他人写的，实际上

276
00:12:53,820 --> 00:12:57,790
segfaulted，只如果那些人
搞砸了，并在写bug的代码

277
00:12:57,790 --> 00:13:00,680
他们的解释器
PHP本身出现段错误。

278
00:13:00,680 --> 00:13:06,460
因此，即使500就像是一个段错误
在精神上，它几乎总是

279
00:13:06,460 --> 00:13:10,490
配置文件问题的结果
与您的Web服务器，或如罗布说，

280
00:13:10,490 --> 00:13:13,200
一个语法错误，像你
没有关闭的报价。

281
00:13:13,200 --> 00:13:16,180
或者你在某处失去了一个分号。

282
00:13:16,180 --> 00:13:23,677
>> 观众：所以对于班车PSET，我
认为当我做到了，一旦我点击

283
00:13:23,677 --> 00:13:26,300
浏览器，但没有上来，
他们所谓的白页。

284
00:13:26,300 --> 00:13:28,056
但它是因为代码。

285
00:13:28,056 --> 00:13:29,440
我认为这是JavaScript的，对不对？

286
00:13:29,440 --> 00:13:29,770
>> ROB BOWDEN：是啊。

287
00:13:29,770 --> 00:13:31,180
>> 观众：请问这个错误
还是来了？

288
00:13:31,180 --> 00:13:34,290
>> ROB BOWDEN：所以你就不会得到
这个错误，因为一切

289
00:13:34,290 --> 00:13:36,930
从Web服务器的角度来看
是完全没问题。

290
00:13:36,930 --> 00:13:39,090
但你要求的index.html。

291
00:13:39,090 --> 00:13:42,000
你要求shuttle.js
和service.js。

292
00:13:42,000 --> 00:13:44,580
它能够成功返回
给你所有这些事情 - 

293
00:13:44,580 --> 00:13:44,980
200。

294
00:13:44,980 --> 00:13:45,680
确定。

295
00:13:45,680 --> 00:13:49,330
只有当您的浏览器尝试
解释JavaScript代码

296
00:13:49,330 --> 00:13:51,370
这就像，等待，这是不
有效的JavaScript错误。

297
00:13:51,370 --> 00:13:55,720

298
00:13:55,720 --> 00:13:58,210
还有没有其他问题？

299
00:13:58,210 --> 00:14:00,750
好的。

300
00:14:00,750 --> 00:14:04,120
>> DAVID J.马兰：那么下一个
时间为11号。

301
00:14:04,120 --> 00:14:07,610
和11是最可怕的
对于很多人。

302
00:14:07,610 --> 00:14:14,620

303
00:14:14,620 --> 00:14:18,570
所以最重要的事情需要注意
是，这是，事实上，大约

304
00:14:18,570 --> 00:14:19,840
一个双向链表。

305
00:14:19,840 --> 00:14:23,160
但是，这并不等同于去年的
双向链表的问题，

306
00:14:23,160 --> 00:14:27,170
它没有给你有条件的，就是
这个名单可以，其实是未排序。

307
00:14:27,170 --> 00:14:29,640
>> 这样一个事实，即列表是排序的
而事实上，这个词是

308
00:14:29,640 --> 00:14:32,930
有下划线是为了传达
这实际上是一种简化

309
00:14:32,930 --> 00:14:35,430
什么否则会一直
更具挑战性的问题

310
00:14:35,430 --> 00:14:36,600
和一个较长的一个。

311
00:14:36,600 --> 00:14:40,760
所以这里一个常见的​​错误是已经把
您的最后一个年度的解决方案

312
00:14:40,760 --> 00:14:45,580
寻呼机，然后就盲目地复制
跌的答案，这是正确的

313
00:14:45,580 --> 00:14:48,520
回答不同的问题
类似的精神。

314
00:14:48,520 --> 00:14:51,340
但这里的微妙之处
分别如下。

315
00:14:51,340 --> 00:14:55,200
>> 因此，一个，我们有一个节点，并宣布
在这里以通常的方式来定义。

316
00:14:55,200 --> 00:14:59,230
然后，我们定义列表是一个全球性的
指针初始化为null。

317
00:14:59,230 --> 00:15:02,150
那么显然，有两个功能
我们有原型在这里，插入

318
00:15:02,150 --> 00:15:03,240
并删除。

319
00:15:03,240 --> 00:15:06,600
然后，我们这里有一些示例代码
的做了一堆插入的。

320
00:15:06,600 --> 00:15:09,930
然后，我们要求你完成
下面的实施刀片以这样

321
00:15:09,930 --> 00:15:14,380
一种方式，它插入n转换成列表
在固定的时间，还强调，

322
00:15:14,380 --> 00:15:15,730
即使已经存在。

323
00:15:15,730 --> 00:15:20,600
>> 因此能够插入美女
在常数时间是，它意味着

324
00:15:20,600 --> 00:15:23,060
你必须插入
新的节点在哪里？

325
00:15:23,060 --> 00:15:23,690
到前面。

326
00:15:23,690 --> 00:15:27,760
所以它消除了，幸运的是，至少
的过去需要一个案件

327
00:15:27,760 --> 00:15:30,520
甚至更多的代码行，像它那样
去年，甚至在上课的时候​​我们

328
00:15:30,520 --> 00:15:34,040
通过这种事情谈
与人类和一些

329
00:15:34,040 --> 00:15:35,250
语言伪代码。

330
00:15:35,250 --> 00:15:39,190
所以在这里的解决方案，让我们跳过
到只是为了有一个视觉上的

331
00:15:39,190 --> 00:15:40,480
在屏幕上。

332
00:15:40,480 --> 00:15:42,230
>> 请注意，我们正在做以下。

333
00:15:42,230 --> 00:15:45,140
同时也注意到另一种简化
是，即使是

334
00:15:45,140 --> 00:15:48,280
已经存在的，所以这意味着即使
数已经是存在的，你可以

335
00:15:48,280 --> 00:15:50,280
只是一味地插入另一
它的副本。

336
00:15:50,280 --> 00:15:52,560
而这，太，本来是一个
简化，这样你可以

337
00:15:52,560 --> 00:15:54,940
集中精力，说真的，一些比较
智力有趣的部分和

338
00:15:54,940 --> 00:15:58,090
不只是一些额外的错误检查
在有限的时间。

339
00:15:58,090 --> 00:16:02,880
>> 所以在这个示例解决方案，我们分配
在左侧的指针

340
00:16:02,880 --> 00:16:04,510
这里边一个节点。

341
00:16:04,510 --> 00:16:07,190
现在，认识到指针，如
罗布说，只有32位。

342
00:16:07,190 --> 00:16:09,060
而实际上它并不包含
一个地址，直到你

343
00:16:09,060 --> 00:16:09,970
分配给它的地址。

344
00:16:09,970 --> 00:16:13,220
我们这样做的右手
通过malloc的一面。

345
00:16:13,220 --> 00:16:16,550
像一个好公民，我们检查
malloc的是不是，事实上，空，从而使

346
00:16:16,550 --> 00:16:18,690
我们不小心创建
这里一个段错误。

347
00:16:18,690 --> 00:16:22,840
任何时候你在生活中使用malloc，你
应检查null，以免

348
00:16:22,840 --> 00:16:24,090
你有一个微妙的错误。

349
00:16:24,090 --> 00:16:28,460
>> 然后我们初始化由空
分配n和上一页和下一页。

350
00:16:28,460 --> 00:16:32,450
而在这里这种情况下，我初始化
以前为null，因为这个新的

351
00:16:32,450 --> 00:16:34,780
节点将是新的
开始我的名单。

352
00:16:34,780 --> 00:16:37,050
所以有将是
什么才。

353
00:16:37,050 --> 00:16:42,010
我想基本上追加
现有列表，由新的节点

354
00:16:42,010 --> 00:16:44,700
接下来设置等于列表本身。

355
00:16:44,700 --> 00:16:47,120
但我没有这样做，只是还没有。

356
00:16:47,120 --> 00:16:51,780
所以，如果列表本身已经存在，
并且有至少有一个节点

357
00:16:51,780 --> 00:16:57,070
已经到位，如果是这样的列表
在这里，我插入一个新的节点在这里，我

358
00:16:57,070 --> 00:17:01,840
需要确保我的前任节点
向后指向我的新节点，

359
00:17:01,840 --> 00:17:04,260
因为这是再一次
一个双向链表。

360
00:17:04,260 --> 00:17:05,460
>> 所以我们做完整性检查。

361
00:17:05,460 --> 00:17:10,109
如果列表不为空，如果有已经
一个或多个节点存在，则

362
00:17:10,109 --> 00:17:12,470
添加反向引用可以这么说。

363
00:17:12,470 --> 00:17:15,420
然后，我们需要的最后一件事
这样做实际上是更新全局

364
00:17:15,420 --> 00:17:20,329
变量列表本身为指向
到该新节点。

365
00:17:20,329 --> 00:17:21,790
是啊。

366
00:17:21,790 --> 00:17:26,579
>> 观众：在指针箭头
[听不清]等于null，即不

367
00:17:26,579 --> 00:17:30,420
处理列表中，因为
该列表为空？

368
00:17:30,420 --> 00:17:30,596
>> DAVID J.马兰：不。

369
00:17:30,596 --> 00:17:34,500
这简直是​​我正在积极
小心，因为如果这是我的

370
00:17:34,500 --> 00:17:38,730
原来列表也许更多一些节点
在这里，我插入我的

371
00:17:38,730 --> 00:17:42,380
在这里新的节点，还有的将
是什么在这里。

372
00:17:42,380 --> 00:17:44,720
我希望捕获的想法
通过设置前，以

373
00:17:44,720 --> 00:17:47,740
在新节点上无效。

374
00:17:47,740 --> 00:17:51,410
想必，如果我的代码是正确的
并有插入没有其他办法

375
00:17:51,410 --> 00:17:54,970
节点比这个功能以外，
据推测，即使列表已经有

376
00:17:54,970 --> 00:18:00,090
在它的一个或多个节点，想必
列表中，在第一个节点，将具有

377
00:18:00,090 --> 00:18:02,750
空本身先前的指针。

378
00:18:02,750 --> 00:18:03,550
>> 观众：而就在跟进。

379
00:18:03,550 --> 00:18:08,139
你把指针下一个等号的原因
列表是你正在做的指针

380
00:18:08,139 --> 00:18:13,579
列表中，它的指向前
下一个，我猜 - 

381
00:18:13,579 --> 00:18:14,980
我鸵鸟政策 - 

382
00:18:14,980 --> 00:18:15,450
只是列出？

383
00:18:15,450 --> 00:18:16,400
>> DAVID J.马兰：没错。

384
00:18:16,400 --> 00:18:19,400
所以，让我们真正考虑两种情况
这里真的，即使

385
00:18:19,400 --> 00:18:22,070
订单，我们会考虑他们是不是
不太一样的代码。

386
00:18:22,070 --> 00:18:26,250
但在一个高的水平，如果该指
列表，这是一个32位的

387
00:18:26,250 --> 00:18:29,560
指针，最简单的情况是
这是默认为空。

388
00:18:29,560 --> 00:18:33,010
并假设我想插入
数字50是一个数字。

389
00:18:33,010 --> 00:18:37,640
所以我要继续前进并分配
一个节点，它也会包含

390
00:18:37,640 --> 00:18:38,770
三个领域 - 

391
00:18:38,770 --> 00:18:42,070
N，上一页和下一页。

392
00:18:42,070 --> 00:18:44,580
>> 我打算把50号
在这里，因为这会为n。

393
00:18:44,580 --> 00:18:46,130
这将是下一个。

394
00:18:46,130 --> 00:18:48,530
而这将是以前的。

395
00:18:48,530 --> 00:18:50,910
所以我该怎么在这种情况下呢？

396
00:18:50,910 --> 00:18:53,900
好吧，我刚刚做1号线在这里。

397
00:18:53,900 --> 00:18:55,400
指针n得到Ñ。

398
00:18:55,400 --> 00:18:57,740
我接着说，以前的
应该得到空。

399
00:18:57,740 --> 00:18:59,470
因此，这将是空。

400
00:18:59,470 --> 00:19:01,365
然后我会说下
是会得到列表。

401
00:19:01,365 --> 00:19:05,150
>> 而这只是工作搞好。

402
00:19:05,150 --> 00:19:06,500
这是空。

403
00:19:06,500 --> 00:19:10,620
所以我说，新节点的下一个
字段应该得到什么，这是。

404
00:19:10,620 --> 00:19:12,570
让把另一个空在那里。

405
00:19:12,570 --> 00:19:14,510
再过去的事情
我要做的就是在这里检查。

406
00:19:14,510 --> 00:19:17,870
如果list不等于空，但它
等于空，所以我们跳过

407
00:19:17,870 --> 00:19:18,470
干脆。

408
00:19:18,470 --> 00:19:23,520
等等一切我下一步要做的就是获取列表
指针，它形象地导致

409
00:19:23,520 --> 00:19:25,570
类似的图片。

410
00:19:25,570 --> 00:19:26,620
所以这是一个情景。

411
00:19:26,620 --> 00:19:30,490
>> 和一个你问的是有关
具体是这样的情况，

412
00:19:30,490 --> 00:19:33,190
我们已经有一个单节点列表。

413
00:19:33,190 --> 00:19:36,240
如果我回去了原
问题陈述，接下来我们将

414
00:19:36,240 --> 00:19:39,320
插入说的是34，只为
就事论事。

415
00:19:39,320 --> 00:19:46,210
所以我打算只方便
绘制在这里。

416
00:19:46,210 --> 00:19:47,540
我刚刚malloced。

417
00:19:47,540 --> 00:19:49,310
假设我检查null。

418
00:19:49,310 --> 00:19:51,870
>> 现在，我要初始化
电量为34。

419
00:19:51,870 --> 00:19:53,040
这将为n。

420
00:19:53,040 --> 00:19:54,670
这将是下一个。

421
00:19:54,670 --> 00:19:57,100
而这将是以前的。

422
00:19:57,100 --> 00:19:59,370
让我们确保我没有
得到这个倒退。

423
00:19:59,370 --> 00:20:01,110
上一页至上
在该定义中。

424
00:20:01,110 --> 00:20:03,070
让我来解决这个问题。

425
00:20:03,070 --> 00:20:04,410
这是以前的。

426
00:20:04,410 --> 00:20:05,780
这是下一个。

427
00:20:05,780 --> 00:20:08,620
尽管这些是相同的，
让我们保持一致。

428
00:20:08,620 --> 00:20:09,450
>> 上一页。

429
00:20:09,450 --> 00:20:11,030
这是下一个。

430
00:20:11,030 --> 00:20:16,310
所以，我刚刚malloced我的注意，检查
为null，则分配34到节点。

431
00:20:16,310 --> 00:20:17,570
上一页变空。

432
00:20:17,570 --> 00:20:19,480
所以，让我说。

433
00:20:19,480 --> 00:20:21,010
下一步得到列表。

434
00:20:21,010 --> 00:20:22,370
所以列表是这样的。

435
00:20:22,370 --> 00:20:26,520
所以这个现在是一样的绘画本
箭头，使它们指向一个

436
00:20:26,520 --> 00:20:27,940
中是相同的。

437
00:20:27,940 --> 00:20:30,400
然后我检查，如果列表
不等于空。

438
00:20:30,400 --> 00:20:31,740
它不是这个时候。

439
00:20:31,740 --> 00:20:35,580
那么我该怎么办名单
先前得到的指针。

440
00:20:35,580 --> 00:20:39,700
>> 所以列表上得到的PTR。

441
00:20:39,700 --> 00:20:44,300
所以这把的效果
这里的图形箭头。

442
00:20:44,300 --> 00:20:46,930
这就是开始有点
波浪状的线条。

443
00:20:46,930 --> 00:20:50,780
然后，我最后更新
列出指向指针。

444
00:20:50,780 --> 00:20:55,560
所以，现在这个指向这个家伙。

445
00:20:55,560 --> 00:20:57,170
现在，让我们做一个快速
完整性检查。

446
00:20:57,170 --> 00:20:59,470
>> 这里的名单，这是
全局变量。

447
00:20:59,470 --> 00:21:02,850
第一个节点是，事实上，34，因为
我下面的箭头。

448
00:21:02,850 --> 00:21:05,210
这就是正确的，因为我想
插入在列表的开头

449
00:21:05,210 --> 00:21:06,070
所有新的节点。

450
00:21:06,070 --> 00:21:08,860
他的下一场让我这个家伙。

451
00:21:08,860 --> 00:21:10,710
如果我坚持下去，我打接下来为空。

452
00:21:10,710 --> 00:21:11,760
所以没有更多的列表。

453
00:21:11,760 --> 00:21:14,460
如果我打以前，我得到
回到了我的期望。

454
00:21:14,460 --> 00:21:16,435
>> 所以还是有几个指针，
显然，操纵。

455
00:21:16,435 --> 00:21:19,870
但事实上，你被告知这样做
这在常数时间内只意味着你

456
00:21:19,870 --> 00:21:22,910
有一个事物的有限数目
你可以这样做。

457
00:21:22,910 --> 00:21:24,290
那是什么号码？

458
00:21:24,290 --> 00:21:25,185
它可能是一个步骤。

459
00:21:25,185 --> 00:21:25,700
这可能有两个。

460
00:21:25,700 --> 00:21:26,820
这可能是1000步。

461
00:21:26,820 --> 00:21:30,500
但它是有限的，这意味着你不能
有什么样的循环的事

462
00:21:30,500 --> 00:21:32,010
在这里，没有递归，没有循环。

463
00:21:32,010 --> 00:21:37,390
这只是必须是硬编码线
的代码，因为我们有这样的样本。

464
00:21:37,390 --> 00:21:42,330
>> 所以接下来的问题12问我们
完成删除的实现

465
00:21:42,330 --> 00:21:46,740
下面以这样一种方式，它消除
N从该列表中的线性时间。

466
00:21:46,740 --> 00:21:48,740
所以，你必须多一点
现在回旋的余地。

467
00:21:48,740 --> 00:21:52,380
你可以假设N，如果存在
在列表中，将存在

468
00:21:52,380 --> 00:21:53,340
不超过一次。

469
00:21:53,340 --> 00:21:56,770
而这也意味着是一个测验为基础的
简化的假设，因此

470
00:21:56,770 --> 00:21:59,780
如果你发现数字50的地方
在列表中，你不还

471
00:21:59,780 --> 00:22:02,890
担心继续
遍历，寻找一切可能的

472
00:22:02,890 --> 00:22:06,990
50个拷贝，这将只是下放
为在有限的时间一些细节。

473
00:22:06,990 --> 00:22:10,460
>> 因此，与删除，这其中肯定
更具挑战性和更

474
00:22:10,460 --> 00:22:11,640
代码编写。

475
00:22:11,640 --> 00:22:14,990
但乍一看，坦率地说，它可能
看起来喧宾夺主，喜欢的东西

476
00:22:14,990 --> 00:22:17,060
有没有办法，你可以有
拿出了一个小测验。

477
00:22:17,060 --> 00:22:22,450
但是，如果我们专注于各个步骤，
希望，它会突然

478
00:22:22,450 --> 00:22:26,060
打击你，每个个体的
步骤做明显的感觉

479
00:22:26,060 --> 00:22:27,080
回想起来。

480
00:22:27,080 --> 00:22:28,200
因此，让我们一起来看看。

481
00:22:28,200 --> 00:22:32,570
>> 因此，首先，我们初始化指针
是列表本身。

482
00:22:32,570 --> 00:22:36,040
因为我想线性时间，那手段
我要去有一些循环。

483
00:22:36,040 --> 00:22:39,730
和常见的方式来遍历
在列表结构或任何种类的节点

484
00:22:39,730 --> 00:22:43,860
结构的迭代是采取
一个指针的数据的前

485
00:22:43,860 --> 00:22:46,990
结构，然后就开始更新
它和走你的路

486
00:22:46,990 --> 00:22:48,650
通过该数据结构中。

487
00:22:48,650 --> 00:22:50,040
所以我打算这样做。

488
00:22:50,040 --> 00:22:54,260
>> 虽然指针，我的临时变量，
不等于空，让我们

489
00:22:54,260 --> 00:22:55,660
继续和检查。

490
00:22:55,660 --> 00:22:56,910
难道我很幸运？

491
00:22:56,910 --> 00:23:01,740
是我目前的节点n场
看着等于

492
00:23:01,740 --> 00:23:03,380
数我在找？

493
00:23:03,380 --> 00:23:05,410
如果是这样，让我们​​做一些事情。

494
00:23:05,410 --> 00:23:10,020
现在，请注意这一点，如果条件
围绕整个

495
00:23:10,020 --> 00:23:11,520
代码如下行。

496
00:23:11,520 --> 00:23:14,610
这是我所关心的唯一的事情 - 
发现了一些问题。

497
00:23:14,610 --> 00:23:18,010
所以没有其他人，从而简化
概念上的东西一点点。

498
00:23:18,010 --> 00:23:22,040
>> 但现在，我才明白，你可能有
只有思前想后意识到了这一点

499
00:23:22,040 --> 00:23:24,720
它通过了一下，有
实际上2箱子这里。

500
00:23:24,720 --> 00:23:28,060
一种是其中的节点是在
开头的列表，这是一个的

501
00:23:28,060 --> 00:23:31,040
有点讨厌，因为这是一个
特殊情况，因为你必须处理

502
00:23:31,040 --> 00:23:33,340
有了这个东西，这
是唯一的异常。

503
00:23:33,340 --> 00:23:35,720
放眼天下，列表，
这是同样的事情。

504
00:23:35,720 --> 00:23:38,050
有一个以前的节点和下一
节点，前一个节点，下一个节点。

505
00:23:38,050 --> 00:23:40,940
不过这家伙有点特殊
如果他是在开始。

506
00:23:40,940 --> 00:23:48,710
>> 因此，如果该指针等于列表
本身，因此，如果我在初

507
00:23:48,710 --> 00:23:53,960
列表中，我发现N，我需要
做了几件事情。

508
00:23:53,960 --> 00:23:59,230
一，我需要改变列表
指向下一个领域，50。

509
00:23:59,230 --> 00:24:01,270
因此，假设我想
删除34。

510
00:24:01,270 --> 00:24:03,560
原来这家伙的得走了
走一会儿就好了。

511
00:24:03,560 --> 00:24:07,210
>> 所以我要说，列表
获取指针下一个。

512
00:24:07,210 --> 00:24:08,570
那么，这是指针。

513
00:24:08,570 --> 00:24:10,360
接着指向了这里。

514
00:24:10,360 --> 00:24:17,470
所以，这种情况正在改变这个箭头向右
现在指向这个家伙在这里。

515
00:24:17,470 --> 00:24:19,580
现在，请记住，我们有
一个临时变量。

516
00:24:19,580 --> 00:24:23,520
所以我们并没有孤立的任何节点，
因为我也有这个家伙在我

517
00:24:23,520 --> 00:24:25,010
执行删除的。

518
00:24:25,010 --> 00:24:29,600
所以，现在，如果列表本身不为空，
我需要修复的一点心意。

519
00:24:29,600 --> 00:24:32,690
>> 我现在需要确保这个箭头，
这是先前指向

520
00:24:32,690 --> 00:24:36,830
从50到34，这得走了，
因为如果我试图摆脱

521
00:24:36,830 --> 00:24:41,910
34，50，最好不要保留任何
一种反向引用它作为

522
00:24:41,910 --> 00:24:42,820
箭头提示。

523
00:24:42,820 --> 00:24:44,820
所以，我只是做了这一行。

524
00:24:44,820 --> 00:24:46,520
所以后来我做。

525
00:24:46,520 --> 00:24:48,040
这种情况下，实际上是非常容易的。

526
00:24:48,040 --> 00:24:51,010
斩去列表的头部
相对来说比较简单。

527
00:24:51,010 --> 00:24:52,980
>> 遗憾的是，这
恼人的else块。

528
00:24:52,980 --> 00:24:56,170
所以，现在，我要考虑的情况下
那里有什么东西在中间。

529
00:24:56,170 --> 00:24:59,880
但它不是太可怕了，除了
像这样的语法。

530
00:24:59,880 --> 00:25:03,080
所以，如果我不在的开始
名单，我在中间某个地方。

531
00:25:03,080 --> 00:25:08,160
而这条线在这里是说，开始
在任何节点你在。

532
00:25:08,160 --> 00:25:11,210

533
00:25:11,210 --> 00:25:18,550
前往上一个节点的下一个字段
并指出，在指针。

534
00:25:18,550 --> 00:25:20,390
>> 让我们做这样形象地。

535
00:25:20,390 --> 00:25:21,640
这是越来越复杂。

536
00:25:21,640 --> 00:25:30,480

537
00:25:30,480 --> 00:25:37,990
所以，如果我有一个以前的领域在这里 - 
让我们做到这一点 - 下一个栏位在这里。

538
00:25:37,990 --> 00:25:41,200
我要简化我的指针，而
比画出一大堆

539
00:25:41,200 --> 00:25:45,710
东西来回往返奔波
对方。

540
00:25:45,710 --> 00:25:50,870
现在，让我们只说这是1，2，
3为便于讨论，甚至

541
00:25:50,870 --> 00:25:53,410
虽然不与排队
所讨论的问题。

542
00:25:53,410 --> 00:25:55,900
>> 因此，这里是我的链接列表。

543
00:25:55,900 --> 00:25:59,300
我想在此删除两个
特别版本的故事。

544
00:25:59,300 --> 00:26:01,960
所以，我已经更新指针
是指向这个家伙。

545
00:26:01,960 --> 00:26:03,315
因此，这是PTR。

546
00:26:03,315 --> 00:26:04,530
他指指点点。

547
00:26:04,530 --> 00:26:07,170
这是列表，其中存在
作为全球前。

548
00:26:07,170 --> 00:26:09,200
而且他指指点点不管。

549
00:26:09,200 --> 00:26:10,800
而现在，我试图删除两个。

550
00:26:10,800 --> 00:26:13,850
>> 所以，如果指针指向这里，我
要遵循，显然，该

551
00:26:13,850 --> 00:26:17,110
以前的指针，这使我在1。

552
00:26:17,110 --> 00:26:22,290
我接着要说的话，下一个
场，这使我到这

553
00:26:22,290 --> 00:26:25,410
框这里，将要
平等的指针下一个。

554
00:26:25,410 --> 00:26:28,400
因此，如果这个指针，这是下一个。

555
00:26:28,400 --> 00:26:31,840
这意味着，该箭头的需求
指向这个家伙。

556
00:26:31,840 --> 00:26:35,140
>> 那么，这行代码刚
所做的就是这一点。

557
00:26:35,140 --> 00:26:37,500
而现在，这看起来像一个
步在正确的方向。

558
00:26:37,500 --> 00:26:41,390
我们基本上要剪断2出
的1和3的中间。

559
00:26:41,390 --> 00:26:44,400
因此，它是有道理的，我们要
路线this指针周围。

560
00:26:44,400 --> 00:26:50,400
因此，这下一行检查，如果指针
接下来是不是null，则

561
00:26:50,400 --> 00:26:54,200
确实有人为2的右边，
这意味着我们还必须做

562
00:26:54,200 --> 00:26:55,850
这里一点剪断。

563
00:26:55,850 --> 00:27:00,590
>> 所以，我现在需要遵循这个指针
和更新先前的指针

564
00:27:00,590 --> 00:27:05,410
这家伙做的一点点
解决办法在这里这里的重点。

565
00:27:05,410 --> 00:27:07,100
而现在，在视觉上，这是很好的。

566
00:27:07,100 --> 00:27:11,930
这是一个有点凌乱在有
没有人在2指点了。

567
00:27:11,930 --> 00:27:13,600
2是指向左边。

568
00:27:13,600 --> 00:27:14,980
和图2是指向右侧。

569
00:27:14,980 --> 00:27:17,480
但他可以做任何他想做的，因为
他即将得到释放。

570
00:27:17,480 --> 00:27:19,480
它什么都无所谓
这些值了。

571
00:27:19,480 --> 00:27:23,040
>> 最重要的是，剩余的
家伙上面的路由

572
00:27:23,040 --> 00:27:24,280
现在他之下。

573
00:27:24,280 --> 00:27:25,810
事实上，这正是我们下一步的行动。

574
00:27:25,810 --> 00:27:29,360
我们免费的指针，这意味着我们告诉
操作系统，欢迎你

575
00:27:29,360 --> 00:27:30,906
回收这一点。

576
00:27:30,906 --> 00:27:34,900
然后最后，我们返回。

577
00:27:34,900 --> 00:27:37,220
否则含蓄，如果我们
还没有还回来，

578
00:27:37,220 --> 00:27:38,290
我们必须继续寻找。

579
00:27:38,290 --> 00:27:41,485
所以指针等于next指针刚
这里指移动这个家伙。

580
00:27:41,485 --> 00:27:42,600
搬到这里这个家伙。

581
00:27:42,600 --> 00:27:45,400
这里提出这个家伙的话，其实，
我们没有发现的数

582
00:27:45,400 --> 00:27:46,960
我们正在寻找的呢。

583
00:27:46,960 --> 00:27:49,630
>> 所以坦率地说，它看起来完全
铺天盖地，我认为，首先

584
00:27:49,630 --> 00:27:52,180
一目了然，特别是如果你挣扎
与此测验中则见

585
00:27:52,180 --> 00:27:52,850
这样的事情。

586
00:27:52,850 --> 00:27:55,050
和你拍拍自己的背。

587
00:27:55,050 --> 00:27:57,080
那么，有没有办法，我能有
想出，关于测验。

588
00:27:57,080 --> 00:28:00,470
但我认为，你可以，如果你打破
它分解成这些个人

589
00:28:00,470 --> 00:28:04,400
例，只是通过它走
小心，虽然，不可否认，在

590
00:28:04,400 --> 00:28:06,300
压力的情况下。

591
00:28:06,300 --> 00:28:09,470
>> 值得庆幸的是，画面制作
一切快乐。

592
00:28:09,470 --> 00:28:11,050
你可以在此画
任何数量的方式。

593
00:28:11,050 --> 00:28:12,760
你不必做交叉的
这里的事情。

594
00:28:12,760 --> 00:28:14,520
你可以用直线做
线路是这样的。

595
00:28:14,520 --> 00:28:18,790
但这个问题的要点，在
一般情况下，是要认识到，在

596
00:28:18,790 --> 00:28:22,060
图片到底应该看起来有点
这样的事情，因为

597
00:28:22,060 --> 00:28:25,030
固定的时间暗示你保持
干扰与抗干扰和干扰的

598
00:28:25,030 --> 00:28:29,900
在开始新的节点
的列表。

599
00:28:29,900 --> 00:28:31,960
有问题吗？

600
00:28:31,960 --> 00:28:34,565
可能是最具挑战性的
肯定是编码的问题。

601
00:28:34,565 --> 00:28:37,690
>> 观众：那么类似于清单
在头前面的例子。

602
00:28:37,690 --> 00:28:39,640
>> DAVID J. MALAN：没错，没错。

603
00:28:39,640 --> 00:28:43,130
只是不同的名称
一个全局变量。

604
00:28:43,130 --> 00:28:44,380
世界各地的什么？

605
00:28:44,380 --> 00:28:48,880

606
00:28:48,880 --> 00:28:49,730
>> ROB BOWDEN：确定。

607
00:28:49,730 --> 00:28:52,020
因此，这是一个在那里你
不得不写一段。

608
00:28:52,020 --> 00:28:56,060
有些人撰写的论文
对于这个问题。

609
00:28:56,060 --> 00:29:00,230
但是，你只需要使用这六个条款
描述发生的事情时，

610
00:29:00,230 --> 00:29:02,440
你尝试联系facebook.com。

611
00:29:02,440 --> 00:29:07,930
所以我就谈谈整个过程
使用所有这些条款。

612
00:29:07,930 --> 00:29:11,290
所以在我们的浏览器，我们输入facebook.com
然后按Enter键。

613
00:29:11,290 --> 00:29:17,280
因此，我们的浏览器将构建一个
HTTP请求，它将会发送

614
00:29:17,280 --> 00:29:22,220
通过一些过程的Facebook
Facebook来与回应我们

615
00:29:22,220 --> 00:29:24,450
它的HTML页面。

616
00:29:24,450 --> 00:29:28,800
>> 那么，什么是过程
该HTTP请求

617
00:29:28,800 --> 00:29:30,730
实得到Facebook？

618
00:29:30,730 --> 00:29:32,790
因此，首先我们需要翻译
Facebook.com。

619
00:29:32,790 --> 00:29:38,780
因此，只要给定的名称Facebook.com，
其中实际执行HTTP请求

620
00:29:38,780 --> 00:29:39,940
需要去？

621
00:29:39,940 --> 00:29:44,120
因此，我们需要翻译Facebook.com
到一个IP地址，它唯一

622
00:29:44,120 --> 00:29:47,620
标识实际上是什么，我们的机器
要将此请求发送到。

623
00:29:47,620 --> 00:29:49,310
你的笔记本电脑都有一个IP地址。

624
00:29:49,310 --> 00:29:52,240
任何连接到互联网
有一个IP地址。

625
00:29:52,240 --> 00:29:59,030
>> 所以DNS，域名系统，也就是
这是怎么回事处理翻译

626
00:29:59,030 --> 00:30:03,750
从facebook.com到一个IP地址，
你其实是要联系。

627
00:30:03,750 --> 00:30:08,075
所以我们联系了DNS服务器和
比如说，什么是facebook.com？

628
00:30:08,075 --> 00:30:16,560
它说，哦，它的IP地址190.212
什么，什么，什么的。

629
00:30:16,560 --> 00:30:16,900
好的。

630
00:30:16,900 --> 00:30:18,850
现在，我知道什么机器
我想联系。

631
00:30:18,850 --> 00:30:22,360
>> 这样的话你把你的HTTP请求
在该机器。

632
00:30:22,360 --> 00:30:24,140
那么它是怎样得到那台机器？

633
00:30:24,140 --> 00:30:27,200
好了，该请求会从
路由器到路由器的反弹。

634
00:30:27,200 --> 00:30:32,630
请记住这个例子在课堂上，在那里
我们居然看到了路由的

635
00:30:32,630 --> 00:30:35,340
包了，当我们试图
进行通信。

636
00:30:35,340 --> 00:30:38,460
我们看到它跳过去的大西洋
海洋在一个点或什么的。

637
00:30:38,460 --> 00:30:42,820
>> 所以最后期限端口。

638
00:30:42,820 --> 00:30:46,520
所以这是现在你的电脑上。

639
00:30:46,520 --> 00:30:49,970
你可以有多个当前的事情
与互联网通信。

640
00:30:49,970 --> 00:30:53,730
这样我就可以运行，例如，Skype公司。

641
00:30:53,730 --> 00:30:55,670
我可能有一个Web浏览器中打开。

642
00:30:55,670 --> 00:30:59,010
我可能有一些
torrenting文件。

643
00:30:59,010 --> 00:31:00,880
因此，所有这些事情都
与通信

644
00:31:00,880 --> 00:31:02,600
互联网以某种方式。

645
00:31:02,600 --> 00:31:08,070
>> 所以，当您的计算机接收的一些数据
从互联网上，是怎么做的

646
00:31:08,070 --> 00:31:10,130
知道什么是真正的应用
想要的数据？

647
00:31:10,130 --> 00:31:12,610
它如何知道是否这个特殊的
数据，是为

648
00:31:12,610 --> 00:31:16,070
torrenting应用程序，而不是
到web浏览器？

649
00:31:16,070 --> 00:31:20,980
因此，这是在该端口的目的
所有这些应用都

650
00:31:20,980 --> 00:31:22,720
要求您的计算机上的端口。

651
00:31:22,720 --> 00:31:27,580
所以，你的网页浏览器说，哎，
我正在侦听端口1000。

652
00:31:27,580 --> 00:31:32,240
和你的torrenting程序是在说，
我正在侦听端口3000。

653
00:31:32,240 --> 00:31:34,770
和Skype说，我使用的是端口4000。

654
00:31:34,770 --> 00:31:41,950
>> 所以，当你得到一些数据属于
一个这些应用程序，数据

655
00:31:41,950 --> 00:31:45,510
标有哪个端口它实际上
沿途应该被发送。

656
00:31:45,510 --> 00:31:47,950
所以这个说，哦，我是属于
到端口1000。

657
00:31:47,950 --> 00:31:50,950
我知道，那么我就需要这个转发
跟着我的网页浏览器。

658
00:31:50,950 --> 00:31:56,440
因此，它之所以与此有关
是Web服务器往往

659
00:31:56,440 --> 00:31:58,240
侦听端口80。

660
00:31:58,240 --> 00:32:02,420
所以，当我联系Facebook.com，我
配有人机通信。

661
00:32:02,420 --> 00:32:06,390
但我需要说的是哪个端口
机器我要与之通信。

662
00:32:06,390 --> 00:32:09,160
和Web服务器往往是
侦听端口80。

663
00:32:09,160 --> 00:32:14,010
>> 如果他们想要的，他们可以将其设置
高达所以它会列出为端口7000。

664
00:32:14,010 --> 00:32:19,090
然后在Web浏览器，我可以
手动输入Facebook.com：7000

665
00:32:19,090 --> 00:32:24,600
将请求发送到端口7000
Facebook的Web服务器。

666
00:32:24,600 --> 00:32:26,820
>> DAVID J. MALAN：而且在这种情况下，即使
虽然我们没有要求的人

667
00:32:26,820 --> 00:32:30,000
提到这一点，在这种情况下，什么端口
会的要求，其实去？

668
00:32:30,000 --> 00:32:36,630

669
00:32:36,630 --> 00:32:37,880
请再试一次。

670
00:32:37,880 --> 00:32:42,810

671
00:32:42,810 --> 00:32:44,300
没错。

672
00:32:44,300 --> 00:32:47,960
不找了，但一个微妙
那有没有最后一次。

673
00:32:47,960 --> 00:32:51,770
>> ROB BOWDEN：所以HTTPS的，因为它是
听专门为

674
00:32:51,770 --> 00:32:55,180
加密的，它在端口4430。

675
00:32:55,180 --> 00:32:57,680
>> 观众：和电子邮件是25吧？

676
00:32:57,680 --> 00:33:00,670
>> DAVID J.马兰：出站
电子邮件，25，是的。

677
00:33:00,670 --> 00:33:03,760
>> ROB BOWDEN：我什至不知道大多数的
的 - 所有的较低的往往是

678
00:33:03,760 --> 00:33:06,310
对于保留的东西。

679
00:33:06,310 --> 00:33:09,260
我觉得一切都在
1024被保留。

680
00:33:09,260 --> 00:33:13,450
>> 观众：你为什么说
3是打错电话了？

681
00:33:13,450 --> 00:33:18,820
>> ROB BOWDEN：因为在一个IP地址，
有四组数字。

682
00:33:18,820 --> 00:33:21,090
并且他们是从0到255。

683
00:33:21,090 --> 00:33:28,060
所以192.168.2.1是一种常见的
本地网络的IP地址。

684
00:33:28,060 --> 00:33:30,840
请注意，所有这些都小于255。

685
00:33:30,840 --> 00:33:33,570
所以，当我开始用300，这
不可能有

686
00:33:33,570 --> 00:33:35,210
一直是数字之一。

687
00:33:35,210 --> 00:33:38,170
>> DAVID J.马兰：但是，这傻夹
从 - 这是CSI，在那里他们有一个

688
00:33:38,170 --> 00:33:39,970
数字太大
为IP地址。

689
00:33:39,970 --> 00:33:42,940

690
00:33:42,940 --> 00:33:46,110
>> ROB BOWDEN：本有问题吗？

691
00:33:46,110 --> 00:33:51,710
下一个，在如此彻底的改变
的话题，但是我们有这个PHP数组的

692
00:33:51,710 --> 00:33:53,270
房子在四。

693
00:33:53,270 --> 00:33:56,360
我们有一个无序列表。

694
00:33:56,360 --> 00:33:59,550
我们想打印出每个列表项
只是含有的房子名字。

695
00:33:59,550 --> 00:34:09,090

696
00:34:09,090 --> 00:34:11,870
所以我们有一个foreach循环。

697
00:34:11,870 --> 00:34:17,540
所以请记住，语法的foreach
数组作为项目的数组中。

698
00:34:17,540 --> 00:34:22,360
因此，通过循环的每次迭代，
房子是要采取的一个

699
00:34:22,360 --> 00:34:24,060
该数组内的值。

700
00:34:24,060 --> 00:34:26,530
>> 在第一次迭代中，房子
将卡博特众议院。

701
00:34:26,530 --> 00:34:30,370
在第二次迭代，房子会
是快递楼等。

702
00:34:30,370 --> 00:34:34,370
因此，对于每一个为四家，我们是
只是要打印 - 

703
00:34:34,370 --> 00:34:37,250
你也可以呼应 - 

704
00:34:37,250 --> 00:34:42,199
列表项，然后房子的名字
然后关闭列表项。

705
00:34:42,199 --> 00:34:45,210
花括号是可选的在这里。

706
00:34:45,210 --> 00:34:49,480
>> 然后我们又在这个问题说
本身，记得关闭

707
00:34:49,480 --> 00:34:50,770
无序列表标记。

708
00:34:50,770 --> 00:34:53,949
因此，我们需要退出PHP模式
为了做到这一点。

709
00:34:53,949 --> 00:35:00,280
或者，我们也可以呼应
关闭无序列表标记。

710
00:35:00,280 --> 00:35:02,380
>> DAVID J.马兰：精也将在这里
一直使用旧的学校

711
00:35:02,380 --> 00:35:07,340
循环使用$ I = 0，并使用计数
计算出射线的长度。

712
00:35:07,340 --> 00:35:09,240
完全没问题，只要
有点wordier。

713
00:35:09,240 --> 00:35:12,170

714
00:35:12,170 --> 00:35:14,742
>> 观众：所以，如果你要
[听不清]，你会怎么做 - 

715
00:35:14,742 --> 00:35:16,734
我忘记了环[听不清]是什么。

716
00:35:16,734 --> 00:35:21,380
你会$四架我？

717
00:35:21,380 --> 00:35:21,850
>> DAVID J.马兰：没错。

718
00:35:21,850 --> 00:35:23,100
是的，没错。

719
00:35:23,100 --> 00:35:26,650

720
00:35:26,650 --> 00:35:27,900
>> ROB BOWDEN：还有别的吗？

721
00:35:27,900 --> 00:35:31,350

722
00:35:31,350 --> 00:35:32,010
>> DAVID J.马兰：好的。

723
00:35:32,010 --> 00:35:32,300
权衡。

724
00:35:32,300 --> 00:35:38,290
因此，有答案的串
可以为每个这些。

725
00:35:38,290 --> 00:35:40,510
我们真的只是寻找
对于一个颠倒和令人信服的东西

726
00:35:40,510 --> 00:35:41,100
不利的一面。

727
00:35:41,100 --> 00:35:44,830
和16号要求，验证用户的
输入客户端，使用JavaScript，

728
00:35:44,830 --> 00:35:47,280
而不是服务器端，如使用PHP。

729
00:35:47,280 --> 00:35:49,450
那么什么是一个颠倒
做客户端？

730
00:35:49,450 --> 00:35:53,780
>> 好了，我们提出的事情之一是
你减少等待时间，因为你

731
00:35:53,780 --> 00:35:56,750
不必费心接触
服务器，这可能需要几分钟

732
00:35:56,750 --> 00:36:00,390
毫秒甚至几秒钟
通过避免和公正

733
00:36:00,390 --> 00:36:04,670
验证用户的输入客户端通过
触发的提交和处理程序

734
00:36:04,670 --> 00:36:06,650
只是检查，没有他们的类型
在对名称的东西？

735
00:36:06,650 --> 00:36:08,080
难道他们输入一些内容
在电子邮件地址？

736
00:36:08,080 --> 00:36:10,950
难道他们从中选择一个宿舍
下拉菜单？

737
00:36:10,950 --> 00:36:14,360
>> 你可以给他们即时的反馈
使用千兆赫兹的电脑

738
00:36:14,360 --> 00:36:16,770
或不管他们有那
其实自己的办公桌上。

739
00:36:16,770 --> 00:36:19,310
所以它只是一个更好的用户
通常会遇到。

740
00:36:19,310 --> 00:36:24,460
但在做客户端的缺点
验证，如果你这样做也没有

741
00:36:24,460 --> 00:36:29,860
做服务器端验证是
大多数人现身CS50都知道

742
00:36:29,860 --> 00:36:33,980
你可以直接发送你想要的任何数据
到服务器任何数目的方式。

743
00:36:33,980 --> 00:36:37,030
坦率地说，在几乎所有的浏览器，你可以
单击各地在设置和公正

744
00:36:37,030 --> 00:36:40,110
关闭JavaScript，这会，
因此，禁止任何形式的

745
00:36:40,110 --> 00:36:41,080
验证。

746
00:36:41,080 --> 00:36:44,460
>> 但您可能还记得，即使我
没有使用类的一些神秘的东西

747
00:36:44,460 --> 00:36:47,790
telnet和实际假装
是一个浏览器通过发送GET

748
00:36:47,790 --> 00:36:49,240
请求到服务器。

749
00:36:49,240 --> 00:36:51,030
而这当然不是
使用任何JavaScript。

750
00:36:51,030 --> 00:36:53,290
这只是我输入命令
在一个键盘。

751
00:36:53,290 --> 00:36:57,410
所以真的，足够在任何程序员
舒适与Web和HTTP

752
00:36:57,410 --> 00:37:01,690
可以发送任何数据，他或她想要的
到未经验证的服务器。

753
00:37:01,690 --> 00:37:05,470
如果你的服务器是不是也检查，
没有他们给我一个名字，是

754
00:37:05,470 --> 00:37:08,930
这实际上是一个有效的电子邮件地址，做
他们选择一个宿舍，你可能最终

755
00:37:08,930 --> 00:37:12,800
向上插入伪造的或只是空白数据
进入你的数据库，这可能

756
00:37:12,800 --> 00:37:15,450
不会是一件好事，如果
你假设它在那里。

757
00:37:15,450 --> 00:37:16,770
>> 所以这是一个恼人的现实。

758
00:37:16,770 --> 00:37:19,890
但在一般情况下，客户端
验证是很大的。

759
00:37:19,890 --> 00:37:21,810
但它意味着两倍的工​​作。

760
00:37:21,810 --> 00:37:25,970
虽然确实存在各
库的JavaScript库

761
00:37:25,970 --> 00:37:28,830
例如，使这么多，
更不用说头痛。

762
00:37:28,830 --> 00:37:31,940
并且可以重复使用一些代码
服务器端，客户端。

763
00:37:31,940 --> 00:37:35,980
但一定要明白，这是典型的
额外的工作。

764
00:37:35,980 --> 00:37:36,415
是啊。

765
00:37:36,415 --> 00:37:37,792
>> 观众：所以，如果我们只是
说不太安全 - 

766
00:37:37,792 --> 00:37:39,205
>> DAVID J.马兰：[笑]

767
00:37:39,205 --> 00:37:39,680
唉。

768
00:37:39,680 --> 00:37:43,105
那些总是更难
那些作出裁决。

769
00:37:43,105 --> 00:37:44,480
>> ROB BOWDEN：那倒
已被接受。

770
00:37:44,480 --> 00:37:44,810
>> DAVID J.马兰：什么？

771
00:37:44,810 --> 00:37:45,810
>> ROB BOWDEN：我创造了这个问题。

772
00:37:45,810 --> 00:37:46,735
这将被接受。

773
00:37:46,735 --> 00:37:47,220
>> DAVID J.马兰：是啊。

774
00:37:47,220 --> 00:37:47,830
>> 观众：酷。

775
00:37:47,830 --> 00:37:51,770
>> ROB BOWDEN：但我们不接受
第1  - 

776
00:37:51,770 --> 00:37:53,630
好了，我们要找的是
像你不必

777
00:37:53,630 --> 00:37:55,270
与服务器通信。

778
00:37:55,270 --> 00:37:58,355
我们不接受只是速度更快。

779
00:37:58,355 --> 00:38:00,080
>> 观众：怎么样
不重新加载页面？

780
00:38:00,080 --> 00:38:00,430
>> ROB BOWDEN：是的。

781
00:38:00,430 --> 00:38:03,000
这是一个公认的答案。

782
00:38:03,000 --> 00:38:06,300
>> DAVID J.马兰：凡是我们认为
它比不太可能更容易

783
00:38:06,300 --> 00:38:09,780
你知道你是什么
说，这是一个艰难的

784
00:38:09,780 --> 00:38:13,500
有时行画。

785
00:38:13,500 --> 00:38:16,000
使用链接列表，而不是
阵列保持的

786
00:38:16,000 --> 00:38:17,590
排序的整数列表。

787
00:38:17,590 --> 00:38:21,000
所以，一个颠倒，我们经常引用与链接
这促使他们的整个列表

788
00:38:21,000 --> 00:38:22,370
引入是你的活力。

789
00:38:22,370 --> 00:38:23,030
他们可以成长。

790
00:38:23,030 --> 00:38:23,950
他们可以收缩。

791
00:38:23,950 --> 00:38:27,370
所以，你不必赴汤蹈火
实际创建更多的内存

792
00:38:27,370 --> 00:38:28,140
与阵列。

793
00:38:28,140 --> 00:38:30,310
或者你也不必只
说，对不起，用户。

794
00:38:30,310 --> 00:38:31,410
阵列被充满。

795
00:38:31,410 --> 00:38:35,850
列表中的那么强劲增长。

796
00:38:35,850 --> 00:38:37,210
虽然链表的缺点？

797
00:38:37,210 --> 00:38:40,916

798
00:38:40,916 --> 00:38:43,356
>> 观众：它是线性的。

799
00:38:43,356 --> 00:38:45,800
搜索关于链表是线性的
而不是你登录。

800
00:38:45,800 --> 00:38:46,360
>> DAVID J.马兰：没错。

801
00:38:46,360 --> 00:38:50,160
上搜索一个链表是线性的，
即使它的排序，因为你可以

802
00:38:50,160 --> 00:38:53,170
只有遵循这些面包屑，这些
指针，从列表的开始

803
00:38:53,170 --> 00:38:53,570
到结束。

804
00:38:53,570 --> 00:38:57,970
你不能利用随机访问和，
因而，二进制搜索，即使它是

805
00:38:57,970 --> 00:39:00,740
排序，您可以
做的一个数组。

806
00:39:00,740 --> 00:39:02,390
还有还有另一个代价。

807
00:39:02,390 --> 00:39:02,966
是啊。

808
00:39:02,966 --> 00:39:03,800
>> 观众：内存效率低下？

809
00:39:03,800 --> 00:39:04,130
>> DAVID J.马兰：是啊。

810
00:39:04,130 --> 00:39:06,940
好吧，我不一定会
说效率低下。

811
00:39:06,940 --> 00:39:10,110
但它确实花费你更多的内存，
因为你需要32位，每

812
00:39:10,110 --> 00:39:13,400
节点为额外的指针，在
至少一个单向链表。

813
00:39:13,400 --> 00:39:16,660
现在，如果你只是存储整数，
您要添加的指针，这是

814
00:39:16,660 --> 00:39:17,830
种不平凡的实际。

815
00:39:17,830 --> 00:39:19,340
这是加倍的内存量。

816
00:39:19,340 --> 00:39:22,330
但在现实中，如果你存储一个
可能有结构的链表

817
00:39:22,330 --> 00:39:25,540
8字节，16字节，甚至更
重要的是，也许是少

818
00:39:25,540 --> 00:39:26,500
的边际成本。

819
00:39:26,500 --> 00:39:28,320
但它的成本仍然。

820
00:39:28,320 --> 00:39:31,880
因此，无论是那些已经会
被罚款的缺点。

821
00:39:31,880 --> 00:39:32,110
>> 18。

822
00:39:32,110 --> 00:39:36,100
使用PHP，而非C + +写
一个命令行程序。

823
00:39:36,100 --> 00:39:41,890
所以在这里，它往往更快的使用
如PHP或Ruby或Python语言。

824
00:39:41,890 --> 00:39:43,700
你只是迅速打开
一个文本编辑器。

825
00:39:43,700 --> 00:39:45,900
你有更多的功能
提供给您。

826
00:39:45,900 --> 00:39:49,325
PHP有功能的厨房水槽，
而在C中，你

827
00:39:49,325 --> 00:39:50,420
有非常，非常小。

828
00:39:50,420 --> 00:39:53,820
事实上，家伙知道硬盘的方式
那你没有哈希表。

829
00:39:53,820 --> 00:39:55,000
你不用链表。

830
00:39:55,000 --> 00:39:57,470
如果你想这些，你必须
实现它们自己。

831
00:39:57,470 --> 00:40:00,950
>> PHP的这么一颠倒或任何真正
解释型语言是快速性

832
00:40:00,950 --> 00:40:02,920
使用它可以编写代码。

833
00:40:02,920 --> 00:40:06,660
但不利的一面，我们看到这个的时候我
迅速刮起了miss​​peller

834
00:40:06,660 --> 00:40:11,780
使用PHP在讲座的实施，是
在使用一种解释语言

835
00:40:11,780 --> 00:40:13,570
通常比较慢。

836
00:40:13,570 --> 00:40:18,420
而且我们看到，明确与
0.3秒的时间增加至3

837
00:40:18,420 --> 00:40:24,440
秒，因为该解释，
实际发生的情况。

838
00:40:24,440 --> 00:40:27,060
>> 另一个上攻是你
不必编译。

839
00:40:27,060 --> 00:40:30,130
因此，它也加快了发展
顺便说一句，因为你没有

840
00:40:30,130 --> 00:40:31,360
两个步骤来运行的程序。

841
00:40:31,360 --> 00:40:32,140
你只有一个。

842
00:40:32,140 --> 00:40:35,260
所以这是相当
引人注目的为好。

843
00:40:35,260 --> 00:40:38,450
使用SQL数据库，而不是
CSV文件来存储数据。

844
00:40:38,450 --> 00:40:40,230
因此SQL数据库用于pset7。

845
00:40:40,230 --> 00:40:42,060
CSV文件你没有使用太多。

846
00:40:42,060 --> 00:40:45,960
但是你用它间接pset7为
以及通过交谈雅虎财经。

847
00:40:45,960 --> 00:40:49,330
>> 但CSV就像一个Excel文件，但
超级简单，这里的列

848
00:40:49,330 --> 00:40:54,010
只是划出由内而外逗号
否则一个文本文件中。

849
00:40:54,010 --> 00:40:56,740
并使用SQL数据库
多了几分吸引力。

850
00:40:56,740 --> 00:41:00,060
这是一个颠倒的，因为你得到的东西
像选择并插入和删除。

851
00:41:00,060 --> 00:41:03,790
你会得到，据推测，该索引
MySQL和其他数据库一样，

852
00:41:03,790 --> 00:41:07,510
甲骨文在内存中建立你的，这
意味着你的选择可能是不

853
00:41:07,510 --> 00:41:09,000
将是线性从上到下。

854
00:41:09,000 --> 00:41:11,300
它实际上将是什么
像二进制搜索什么

855
00:41:11,300 --> 00:41:12,520
类似的精神。

856
00:41:12,520 --> 00:41:13,930
所以他们普遍较快。

857
00:41:13,930 --> 00:41:16,040
>> 但缺点是，
它只是更多的工作。

858
00:41:16,040 --> 00:41:16,730
这是更多的努力。

859
00:41:16,730 --> 00:41:18,140
你必须了解数据库。

860
00:41:18,140 --> 00:41:18,940
你必须设置它。

861
00:41:18,940 --> 00:41:20,840
你需要一个服务器来运行
该数据库。

862
00:41:20,840 --> 00:41:22,750
你需要了解
如何配置它。

863
00:41:22,750 --> 00:41:24,930
所以这些都只是这些
各种权衡。

864
00:41:24,930 --> 00:41:27,860
而一个CSV文件，你可以
用gedit创建它。

865
00:41:27,860 --> 00:41:28,770
和你去好。

866
00:41:28,770 --> 00:41:31,550
有没有超出复杂性。

867
00:41:31,550 --> 00:41:34,870
>> 用trie树代替了哈希表
有独立的链接来存储

868
00:41:34,870 --> 00:41:37,490
话让人想起字典
的pset5。

869
00:41:37,490 --> 00:41:42,480
所以试图上攻，在理论上
至少，是什么呢？

870
00:41:42,480 --> 00:41:46,380
固定的时间，至少如果你是
散列上每个单独的

871
00:41:46,380 --> 00:41:48,990
字母词，像你
可能对pset5。

872
00:41:48,990 --> 00:41:52,720
这可能是五哈希，六
哈希值，如果有五六个

873
00:41:52,720 --> 00:41:53,900
字母的单词。

874
00:41:53,900 --> 00:41:54,580
并就不错了。

875
00:41:54,580 --> 00:41:56,910
如果有一个上限如何
长你的话可能是，这是

876
00:41:56,910 --> 00:41:59,320
的确渐近常数时间。

877
00:41:59,320 --> 00:42:05,180
>> 而具有独立的哈希表
链，问题出在那里与

878
00:42:05,180 --> 00:42:09,070
样的数据结构是
你的算法的性能通常

879
00:42:09,070 --> 00:42:12,700
取决于事物的数量
已经在该数据结构中。

880
00:42:12,700 --> 00:42:15,660
而这肯定与案件
链，从而使更多的东西你把

881
00:42:15,660 --> 00:42:18,800
到哈希表中，这些长
链去，这意味着在最坏

882
00:42:18,800 --> 00:42:21,960
情况下，你可能会寻找的东西
是所有的方式在一个的端

883
00:42:21,960 --> 00:42:26,000
那些枷锁，有效的
转予弄成线性的。

884
00:42:26,000 --> 00:42:29,450
>> 现在，在实践中，它可能完全
这样的话，与一个哈希表

885
00:42:29,450 --> 00:42:32,820
链是比相应的快
特里实施。

886
00:42:32,820 --> 00:42:35,570
但是，这是由于各种原因，其中
这是尝试使用了一大堆

887
00:42:35,570 --> 00:42:39,240
内存可以，其实，慢的东西
下来，因为你没有得到很好的

888
00:42:39,240 --> 00:42:42,410
一种叫做缓存的好处，
那里的东西都是靠在一起

889
00:42:42,410 --> 00:42:45,420
在存储器中可被访问。
往往更快。

890
00:42:45,420 --> 00:42:48,180
有时你能想出
一个真正好的哈希函数。

891
00:42:48,180 --> 00:42:51,060
即使你有浪费一点
内存，则可能确实，能够

892
00:42:51,060 --> 00:42:54,430
找东西快速而且效果不
那样糟糕线性。

893
00:42:54,430 --> 00:42:58,410
>> 因此，在短，存在不一定是
与上述任何一种或两种的

894
00:42:58,410 --> 00:43:00,050
我们正在寻找具体的事情。

895
00:43:00,050 --> 00:43:03,080
真的什么说服力
作为上行和下行

896
00:43:03,080 --> 00:43:04,800
一般吸引了我们的眼球。

897
00:43:04,800 --> 00:43:11,840
>> ROB BOWDEN：所以对于上升空间，我们做
不接受它自己的“更快”。您

898
00:43:11,840 --> 00:43:14,540
不得不说一些事情。

899
00:43:14,540 --> 00:43:17,910
即使你更快地从理论上说，
我们知道那种你明白

900
00:43:17,910 --> 00:43:19,470
它的0 1。

901
00:43:19,470 --> 00:43:22,820
及哈希表，从理论上讲，
不为0的1。

902
00:43:22,820 --> 00:43:26,550
提及在运行什么
一般把你的分。

903
00:43:26,550 --> 00:43:32,640
但“快”，大部分的解决方案上
大板，分别是尝试

904
00:43:32,640 --> 00:43:34,990
客观上比慢的解决方案
这是哈希表。

905
00:43:34,990 --> 00:43:37,250
所以更快本身并
是不是真的。

906
00:43:37,250 --> 00:43:41,550

907
00:43:41,550 --> 00:43:44,380
>> DAVID J.马兰：DOM德DOM DOM。

908
00:43:44,380 --> 00:43:46,686
我可能是唯一一个实现
这是怎么说的应该

909
00:43:46,686 --> 00:43:47,500
发音，对不对？

910
00:43:47,500 --> 00:43:50,400
>> ROB BOWDEN：我居然不知道。

911
00:43:50,400 --> 00:43:51,650
>> DAVID J.马兰：这让
感觉在我的头上。

912
00:43:51,650 --> 00:43:53,830

913
00:43:53,830 --> 00:43:57,580
>> ROB BOWDEN：我做这一个。

914
00:43:57,580 --> 00:43:58,020
确定。

915
00:43:58,020 --> 00:44:04,243
因此，这是一个在那里你不得不动用
类似于你的图可能

916
00:44:04,243 --> 00:44:06,040
看到过去的考试。

917
00:44:06,040 --> 00:44:12,200
所以，就让我们看看这个。

918
00:44:12,200 --> 00:44:18,170
所以从HTML节点，我们有两个
儿童的头部和主体。

919
00:44:18,170 --> 00:44:20,570
因此，我们分支 - 头部和身体。

920
00:44:20,570 --> 00:44:22,280
头部有一个标题标签。

921
00:44:22,280 --> 00:44:23,710
因此，我们有一个标题。

922
00:44:23,710 --> 00:44:28,450
>> 现在，有一件事很多人
忘了的是，这些文本节点

923
00:44:28,450 --> 00:44:30,430
此树中的元素。

924
00:44:30,430 --> 00:44:36,260
所以在这里我们碰巧吸引他们为椭圆形
从这些区分它们

925
00:44:36,260 --> 00:44:37,380
类型的节点。

926
00:44:37,380 --> 00:44:41,450
但公告同时在这里我们有顶，
中部和底部最终会被

927
00:44:41,450 --> 00:44:42,560
文本节点。

928
00:44:42,560 --> 00:44:46,250
所以，忘记那些有点
一个常见的​​错误。

929
00:44:46,250 --> 00:44:48,770
>> 人体有三个孩子 - 
这三个div的。

930
00:44:48,770 --> 00:44:53,340
所以格，格，格，然后在文本
这些div的子节点。

931
00:44:53,340 --> 00:44:55,900
这几乎是它
该问题。

932
00:44:55,900 --> 00:44:57,860
>> DAVID J.马兰：而且这是值得注意的，
尽管我们不会对这些纠缠

933
00:44:57,860 --> 00:45:01,040
在我们花费的时间细节
JavaScript中，该命令呢，

934
00:45:01,040 --> 00:45:02,290
事实上，无论在技术上。

935
00:45:02,290 --> 00:45:06,330
所以，如果头自带的身体之前，在
HTML，那么它应该出现在

936
00:45:06,330 --> 00:45:08,860
在实际的DOM离开身体。

937
00:45:08,860 --> 00:45:12,265
他是，在一般情况下，刚刚仅供参考，
一些所谓的文档顺序，其中

938
00:45:12,265 --> 00:45:13,260
这非常重要。

939
00:45:13,260 --> 00:45:17,470
如果你正在实施一个解析器，
一个程序，在建筑读取HTML

940
00:45:17,470 --> 00:45:20,960
在内存中的树，说实话，
这就是直觉可能是你

941
00:45:20,960 --> 00:45:24,720
无论如何做 - 从上到下，
左到右。

942
00:45:24,720 --> 00:45:26,116
>> ROB BOWDEN：该问题？

943
00:45:26,116 --> 00:45:29,080

944
00:45:29,080 --> 00:45:30,000
我应该做的下一个？

945
00:45:30,000 --> 00:45:32,380
>> DAVID J.马兰：当然可以。

946
00:45:32,380 --> 00:45:33,810
>> ROB BOWDEN：确定。

947
00:45:33,810 --> 00:45:39,320
因此，这是缓冲区溢出
攻击的问题。

948
00:45:39,320 --> 00:45:43,740
最主要的是要在这里认识的是，
好了，怎么可能一个对手绝招

949
00:45:43,740 --> 00:45:46,170
这个程序到执行
任意代码？

950
00:45:46,170 --> 00:45:51,860
所以argv1，第一个命令行
参数传递给这个程序，那可以是

951
00:45:51,860 --> 00:45:53,920
任意长。

952
00:45:53,920 --> 00:45:59,160
但在这里，我们用memcpy复制
argv1，在这里是酒吧。

953
00:45:59,160 --> 00:46:00,165
我们把它当作参数。

954
00:46:00,165 --> 00:46:02,050
所以它采取的名字吧。

955
00:46:02,050 --> 00:46:08,040
>> 因此，我们memcpying吧
这个缓冲液C。

956
00:46:08,040 --> 00:46:09,400
我们有多少字节复制？

957
00:46:09,400 --> 00:46:14,040
然而，良好的字节酒吧恰好
可以使用，这样的说法的长度。

958
00:46:14,040 --> 00:46:17,930
但c是只有12个字节宽。

959
00:46:17,930 --> 00:46:22,280
因此，如果我们输入命令行参数
这比12个字节长，我们

960
00:46:22,280 --> 00:46:25,470
将这个溢出
特定的缓冲区。

961
00:46:25,470 --> 00:46:31,000
现在，怎么可能对手的绝招
程序执行任意代码？

962
00:46:31,000 --> 00:46:34,910
>> 所以请记住，在这里
主要是调用foo。

963
00:46:34,910 --> 00:46:37,340
所以当时主要调用foo。

964
00:46:37,340 --> 00:46:40,408
让我们得出这样的。

965
00:46:40,408 --> 00:46:44,720

966
00:46:44,720 --> 00:46:46,990
因此，我们有我们的堆栈。

967
00:46:46,990 --> 00:46:49,090
与主有一个堆栈帧
在底部。

968
00:46:49,090 --> 00:46:51,860

969
00:46:51,860 --> 00:46:53,250
在某些时候，主要调用foo。

970
00:46:53,250 --> 00:46:55,390
好了，马上，主要调用foo。

971
00:46:55,390 --> 00:46:57,130
所以富都有自己的堆栈帧。

972
00:46:57,130 --> 00:46:59,650

973
00:46:59,650 --> 00:47:02,220
>> 现在，在某些时候，富
将要返回。

974
00:47:02,220 --> 00:47:06,810
又走了foo返回了，我们需要知道在
哪些代码主要我们的内线

975
00:47:06,810 --> 00:47:10,610
是为了知道在哪里
我们应该恢复在主。

976
00:47:10,610 --> 00:47:13,100
我们可以从整个调用foo
一堆不同的地方。

977
00:47:13,100 --> 00:47:14,620
我们怎么知道从哪里回来？

978
00:47:14,620 --> 00:47:16,460
好了，我们需要存储在某个地方。

979
00:47:16,460 --> 00:47:23,010
>> 所以，正确的地方在这里，我们存储
在这里我们还是要回到曾经

980
00:47:23,010 --> 00:47:24,070
富回报。

981
00:47:24,070 --> 00:47:26,350
这是返回地址。

982
00:47:26,350 --> 00:47:30,490
因此，如何对手可能利用
的是这样的事实，即

983
00:47:30,490 --> 00:47:37,550
这个缓冲区C存放，让我们
说，就在这里为c。

984
00:47:37,550 --> 00:47:39,690
因此，我们已经有了12个字节对​​于C。

985
00:47:39,690 --> 00:47:40,540
这是C。

986
00:47:40,540 --> 00:47:43,030
这是Foo的堆栈环。

987
00:47:43,030 --> 00:47:49,970
因此，如果恶意用户输入更多
超过12字节或者输入命令

988
00:47:49,970 --> 00:47:54,570
行参数，这比12再
字符，那么我们要

989
00:47:54,570 --> 00:47:57,540
溢出这个缓冲区。

990
00:47:57,540 --> 00:47:59,910
>> 我们可以继续下去。

991
00:47:59,910 --> 00:48:02,220
在某些时候，我们走多远
够了，我们开始

992
00:48:02,220 --> 00:48:05,120
这个覆盖返回地址。

993
00:48:05,120 --> 00:48:08,310
所以一旦我们覆盖返回地址，
这意味着，当富

994
00:48:08,310 --> 00:48:14,220
返回时，我们返回的地方
恶意用户告诉它

995
00:48:14,220 --> 00:48:19,490
任何值它进入，以任何
字符的用户输入。

996
00:48:19,490 --> 00:48:24,320
所以，如果恶意用户正在
特别聪明，他能有这样的

997
00:48:24,320 --> 00:48:29,255
返回到某处printDef
功能或某处的malloc

998
00:48:29,255 --> 00:48:31,830
功能，只要在任何地方随心所欲。

999
00:48:31,830 --> 00:48:38,420
>> 但更巧的是什么，如果他有
用户返回到这里。

1000
00:48:38,420 --> 00:48:41,920
然后你开始执行
由于这些代码行。

1001
00:48:41,920 --> 00:48:46,610
所以在这一点上，用户可以输入
任何他想要进入这一地区。

1002
00:48:46,610 --> 00:48:52,210
他有完全的控制
在你的计划。

1003
00:48:52,210 --> 00:48:53,460
该问题？

1004
00:48:53,460 --> 00:48:56,380

1005
00:48:56,380 --> 00:49:00,970
因此，接下来的问题是完全的
富的以这样的方式重新实现

1006
00:49:00,970 --> 00:49:02,620
它不再是脆弱的。

1007
00:49:02,620 --> 00:49:03,870
>> 因此，有几种方法
你可以这样做。

1008
00:49:03,870 --> 00:49:10,900

1009
00:49:10,900 --> 00:49:13,330
我们还有C只
是长度为12。

1010
00:49:13,330 --> 00:49:16,480
你可以改变这
作为解决方案的一部分。

1011
00:49:16,480 --> 00:49:18,930
我们还增加了一个检查，以
确保酒吧是不是null。

1012
00:49:18,930 --> 00:49:24,460
虽然你并不需要
对于全额贷款。

1013
00:49:24,460 --> 00:49:27,690
因此，我们先检查
酒吧的字符串的长度。

1014
00:49:27,690 --> 00:49:31,650
如果是大于12，则
实际上不做副本。

1015
00:49:31,650 --> 00:49:33,010
所以这就是修复它的方法之一。

1016
00:49:33,010 --> 00:49:36,750
>> 固定它的另一种方式是代替
有C只是长度为12，拥有它

1017
00:49:36,750 --> 00:49:39,310
是长度函数strlen（巴）。

1018
00:49:39,310 --> 00:49:43,370
固定它的另一种方式是
实际上只是返回。

1019
00:49:43,370 --> 00:49:46,690
所以，如果你刚刚摆脱了所有的
这一点，如果你刚刚删除了所有

1020
00:49:46,690 --> 00:49:51,830
行代码，你会得到
全额贷款，因为该功能

1021
00:49:51,830 --> 00:49:54,150
实际上并没有完成任何事情。

1022
00:49:54,150 --> 00:49:57,650
它的复制命令行
参数为一些阵列

1023
00:49:57,650 --> 00:49:59,960
它的栈帧。

1024
00:49:59,960 --> 00:50:01,310
然后事情就是返回。

1025
00:50:01,310 --> 00:50:04,020
此外，无论它成功的走了。

1026
00:50:04,020 --> 00:50:09,740
所以回报也足够
获得全部学分的方式。

1027
00:50:09,740 --> 00:50:13,425
>> DAVID J.马兰：不太精神
这个问题，但每可接受

1028
00:50:13,425 --> 00:50:15,580
规格书号仍然。

1029
00:50:15,580 --> 00:50:18,260
>> ROB BOWDEN：在任何的问题？

1030
00:50:18,260 --> 00:50:22,270
有一件事，你至少
需要已编译代码。

1031
00:50:22,270 --> 00:50:24,810
因此，即使在技术上你是不是
脆弱的，如果您的代码不

1032
00:50:24,810 --> 00:50:29,130
编译，我们不接受。

1033
00:50:29,130 --> 00:50:31,350
没有问题？

1034
00:50:31,350 --> 00:50:33,320
确定。

1035
00:50:33,320 --> 00:50:34,580
>> DAVID J.马兰：你想
说这个称号？

1036
00:50:34,580 --> 00:50:37,230
>> ROB BOWDEN：号

1037
00:50:37,230 --> 00:50:40,470
>> DAVID J.马兰：所以在这一块，这
无论是好消息还是坏消息。

1038
00:50:40,470 --> 00:50:43,870
这是字面上相同的问题
作为第一次测验。

1039
00:50:43,870 --> 00:50:46,140
而且它几乎是相同的
问题是PSET1。

1040
00:50:46,140 --> 00:50:49,980
但它被刻意简化为
一个更简单的金字塔，一个可

1041
00:50:49,980 --> 00:50:52,330
解决了用微
简单的迭代。

1042
00:50:52,330 --> 00:50:55,680
真的，我们都拿到在
这里是没有那么多的逻辑，

1043
00:50:55,680 --> 00:50:58,100
大概是因为，通过这一点，你
比你更舒适

1044
00:50:58,100 --> 00:51:01,850
在一个用for循环或循环为什么一周，
但真正捉弄除了那

1045
00:51:01,850 --> 00:51:04,790
你有点舒服的
概念，PHP是不只是什么

1046
00:51:04,790 --> 00:51:05,290
编程。

1047
00:51:05,290 --> 00:51:07,820
它实际上可以被用来作为一种语言
写命令行程序。

1048
00:51:07,820 --> 00:51:10,060
>> 事实上，这正是我们试图
提请你注意。

1049
00:51:10,060 --> 00:51:12,060
这是一个PHP命令行程序。

1050
00:51:12,060 --> 00:51:16,690
因此，这里的C代码，而正确的
在C中，不正确的PHP。

1051
00:51:16,690 --> 00:51:17,940
但是代码确实是相同的。

1052
00:51:17,940 --> 00:51:21,720
如果你比较对测验的解决方案
0反对测验1，你会发现，

1053
00:51:21,720 --> 00:51:25,630
它几乎是相同的，除了
一些美元符号和对

1054
00:51:25,630 --> 00:51:27,250
缺少数据类型。

1055
00:51:27,250 --> 00:51:31,720
特别是，如果我们看看这里，
你会看到，我们遍历，在这

1056
00:51:31,720 --> 00:51:33,730
情况下，从1到7。

1057
00:51:33,730 --> 00:51:34,910
>> 我们可以做它0指数。

1058
00:51:34,910 --> 00:51:37,320
但有时候，我认为这只是
精神上更容易思考的东西

1059
00:51:37,320 --> 00:51:38,200
从1到7。

1060
00:51:38,200 --> 00:51:40,300
如果你想有一个街区，然后两个
块，然后三，然后

1061
00:51:40,300 --> 00:51:41,770
点，点，点7。

1062
00:51:41,770 --> 00:51:45,960
我们已经j为初始化为1
然后指望达我。

1063
00:51:45,960 --> 00:51:48,150
而这里的一切
否则相同。

1064
00:51:48,150 --> 00:51:49,790
但值得注意的是
一对夫妇的事情。

1065
00:51:49,790 --> 00:51:53,230
我们给你这两条线，这首
1，goofily命名为家当

1066
00:51:53,230 --> 00:51:54,560
对于尖锐的爆炸。

1067
00:51:54,560 --> 00:51:58,770
而这只是指定的路径中，
文件夹，在其中一个程序可以

1068
00:51:58,770 --> 00:52:02,160
发现要使用
解释这个文件。

1069
00:52:02,160 --> 00:52:04,710
>> 和随后的线路之后，
当然，是指进入PHP模式。

1070
00:52:04,710 --> 00:52:07,740
和线在最底层
表示退出PHP模式。

1071
00:52:07,740 --> 00:52:09,740
而这个工程，在一般情况下，与
解释型语言。

1072
00:52:09,740 --> 00:52:14,370
这有点恼人，如果你写了一个
计划在一个名为foo.php文件。

1073
00:52:14,370 --> 00:52:17,320
然后你的用户要的只是
记住，好了，运行这个程序，我

1074
00:52:17,320 --> 00:52:22,320
必须输入“php空间foo.php。”样
恼人的，如果没有别的。

1075
00:52:22,320 --> 00:52:25,270
同时也表明你的程序
是用PHP编写的，这是不是所有的

1076
00:52:25,270 --> 00:52:27,060
该照射的用户。

1077
00:52:27,060 --> 00:52:30,100
>> 这样你就可以完全消除。PHP
从讲座召回。

1078
00:52:30,100 --> 00:52:35,690
而你实际上可以做。/ foo的，如果
你通过使已经chmodded它

1079
00:52:35,690 --> 00:52:36,500
可执行文件。

1080
00:52:36,500 --> 00:52:39,630
因此存取权限chmod a + X富会做的。

1081
00:52:39,630 --> 00:52:41,460
如果你也在这里添加家当。

1082
00:52:41,460 --> 00:52:45,320
不过说真的，这个问题是越来越在
打印出这样的事情。

1083
00:52:45,320 --> 00:52:51,100
没有HTML，没有C代码肯定，
只是一些PHP。

1084
00:52:51,100 --> 00:52:54,100
所以米洛然后在问题25返回。

1085
00:52:54,100 --> 00:52:58,050
而在25日，你被赋予以下
框架代码，这是一个

1086
00:52:58,050 --> 00:52:59,730
很简单的网页。

1087
00:52:59,730 --> 00:53:04,230
而多汁部分的HTML明智下跌
这里，我们有身体的内部

1088
00:53:04,230 --> 00:53:09,160
具有输入唯一ID的形式
其内部是两个输入，一个

1089
00:53:09,160 --> 00:53:11,950
同的名称，1的想法
与按钮的想法。

1090
00:53:11,950 --> 00:53:14,240
>> 第一个是文本类型的
类型的第二提交。

1091
00:53:14,240 --> 00:53:16,930
因此，我们给了你，其实，更
比你需要的，只是这样的成分

1092
00:53:16,930 --> 00:53:19,230
你们有选择与
来解决这个问题。

1093
00:53:19,230 --> 00:53:21,130
你并不需要严格
所有这些ID的。

1094
00:53:21,130 --> 00:53:23,580
但它可以让你解决
它以不同的方式。

1095
00:53:23,580 --> 00:53:27,050
并在顶部，注意
的目的是为了触发

1096
00:53:27,050 --> 00:53:27,960
像这样的窗口 - 

1097
00:53:27,960 --> 00:53:28,780
您好，米洛！ - 

1098
00:53:28,780 --> 00:53:31,270
使用弹出的浏览器
超级简单，如果

1099
00:53:31,270 --> 00:53:33,190
不丑，报警功能。

1100
00:53:33,190 --> 00:53:37,480
所以，最终，这归结
概念以某种方式监听

1101
00:53:37,480 --> 00:53:41,290
表单的客户端提交的材料
，而不是服务器端的，不知何故

1102
00:53:41,290 --> 00:53:45,640
要答复意见书
抓住用户键入的值

1103
00:53:45,640 --> 00:53:50,120
在Name字段，然后
在警告的正文中显示它。

1104
00:53:50,120 --> 00:53:53,460
>> 所以，你可以做到这一点的方法之一是用
jQuery的，看起来有点

1105
00:53:53,460 --> 00:53:56,880
语法傻了眼在第一。

1106
00:53:56,880 --> 00:54:00,760
为此，您可以用纯DOM代码 - 
通过ID document.getelement。

1107
00:54:00,760 --> 00:54:02,530
但是，让我们来看看这个版本。

1108
00:54:02,530 --> 00:54:05,110
我有几个重要的
行第一。

1109
00:54:05,110 --> 00:54:09,460
这么一句，我们这行，这是
相同的你可能已经看到

1110
00:54:09,460 --> 00:54:13,830
在，我相信，form2.html
从类中第9周。

1111
00:54:13,830 --> 00:54:16,960
这只是说，执行
下面的代码时，

1112
00:54:16,960 --> 00:54:18,430
该文件已准备就绪。

1113
00:54:18,430 --> 00:54:21,770
这是重要的，因为只有
HTML页面顶部读

1114
00:54:21,770 --> 00:54:23,280
底，左到右。

1115
00:54:23,280 --> 00:54:27,910
>> 因此，如果你尝试做
东西在这儿代码在一定的DOM

1116
00:54:27,910 --> 00:54:31,560
元素，一些HTML标签，这就是下降
在这里，你这样做为时过早，

1117
00:54:31,560 --> 00:54:34,220
因为这并没有什
被读入内存。

1118
00:54:34,220 --> 00:54:37,740
所以说这样的document.ready
行，我们在说，

1119
00:54:37,740 --> 00:54:39,040
这里的一些代码，浏览器。

1120
00:54:39,040 --> 00:54:42,440
但不执行此操作，直到整个
文档准备好，即在DOM

1121
00:54:42,440 --> 00:54:44,320
树存在于内存中。

1122
00:54:44,320 --> 00:54:47,110
这一个是多一点
直截了当，如果一个语法

1123
00:54:47,110 --> 00:54:51,890
有点不同，这里我说的，抢
在HTML元素，其独特的

1124
00:54:51,890 --> 00:54:53,560
标识符输入。

1125
00:54:53,560 --> 00:54:56,220
这就是散列标签
表示，唯一ID。

1126
00:54:56,220 --> 00:54:58,070
然后我打电话。提交。

1127
00:54:58,070 --> 00:55:01,660
>> 因此，这里提出的是一个函数，否则
已知作为一种方法，这就是

1128
00:55:01,660 --> 00:55:05,850
在左侧的对象的内
一边有，我没有强调。

1129
00:55:05,850 --> 00:55:08,990
所以，如果你想输入作为一个对象
在内存中 - 实际上它是。

1130
00:55:08,990 --> 00:55:10,440
这是在一个树中的节点 - 

1131
00:55:10,440 --> 00:55:16,580
。提交的手段时，这种形式与
这个ID被提交后，执行

1132
00:55:16,580 --> 00:55:17,700
下面的代码。

1133
00:55:17,700 --> 00:55:20,290
我不在乎什么的名字
功能是我执行。

1134
00:55:20,290 --> 00:55:23,760
所以在这里我使用的，和以前一样，有什么
被称为lambda函数或

1135
00:55:23,760 --> 00:55:24,720
匿名函数。

1136
00:55:24,720 --> 00:55:27,640
它不是在所有智力
有趣以外它没有名字，

1137
00:55:27,640 --> 00:55:30,220
这是好的，如果你只
永远要调用它一次。

1138
00:55:30,220 --> 00:55:34,490
里边有我真正处理
提交表单。

1139
00:55:34,490 --> 00:55:36,810
我首先声明一个变量
所谓的价值。

1140
00:55:36,810 --> 00:55:40,610
然后这个是什么效果
这里突出部分吗？

1141
00:55:40,610 --> 00:55:44,755
这是什么做的一
高层给我吗？

1142
00:55:44,755 --> 00:55:48,539
>> 观众：它得到的值的
用户在下面的HTML没有。

1143
00:55:48,539 --> 00:55:50,920
它得到的ID，然后
发现它的价值。

1144
00:55:50,920 --> 00:55:51,590
>> DAVID J.马兰：没错。

1145
00:55:51,590 --> 00:55:54,300
它抓住节点，其独特的
标识符名称。

1146
00:55:54,300 --> 00:55:56,900
它得到了其中的价值，这
是，据推测，什么样的用户

1147
00:55:56,900 --> 00:55:58,190
键入他或她自己。

1148
00:55:58,190 --> 00:56:01,020
然后将其存储在该
变量称为价值。

1149
00:56:01,020 --> 00:56:03,720
顺便说一句，你可以有也
这样做有点不同。

1150
00:56:03,720 --> 00:56:09,250
通过做一些完全可以接受
谎言的VaR值，得到

1151
00:56:09,250 --> 00:56:10,500
的document.getElementById。

1152
00:56:10,500 --> 00:56:12,860

1153
00:56:12,860 --> 00:56:15,460
这就是为什么它是一个小
乏味，不使用jQuery的。

1154
00:56:15,460 --> 00:56:16,710
“名”。值。

1155
00:56:16,710 --> 00:56:18,330

1156
00:56:18,330 --> 00:56:19,620
所以完全可以接受的。

1157
00:56:19,620 --> 00:56:22,770
不同的方法来做到这一点。 jQuery的刚
往往是多了几分简洁和

1158
00:56:22,770 --> 00:56:25,230
肯定更受欢迎
间的程序员。

1159
00:56:25,230 --> 00:56:27,590
>> 现在，我正在做一个有点理智的
检查一下，因为在这个问题

1160
00:56:27,590 --> 00:56:30,820
声明中我们明确地说，如果
用户尚未键入他或她的

1161
00:56:30,820 --> 00:56:32,580
名，不显示一个警报。

1162
00:56:32,580 --> 00:56:35,390
但你可以检查，通过刚
检查一个空字符串

1163
00:56:35,390 --> 00:56:37,850
报价引文结束，如果有
什么居然还有。

1164
00:56:37,850 --> 00:56:40,880
但如果它不等于报价引文结束，
我想打电话报警。

1165
00:56:40,880 --> 00:56:45,610
这里最有趣的部分是，
我们使用加运算符，

1166
00:56:45,610 --> 00:56:48,130
在JavaScript中做什么？

1167
00:56:48,130 --> 00:56:48,740
串连。

1168
00:56:48,740 --> 00:56:50,690
所以它就像PHPS点运算符。

1169
00:56:50,690 --> 00:56:52,820
同样的想法，稍有不同的语法。

1170
00:56:52,820 --> 00:56:55,280
而我只是在创建字符串
你看到了屏幕截图 - 

1171
00:56:55,280 --> 00:56:57,750
您好，某某。

1172
00:56:57,750 --> 00:56:59,200
>> 然后最后的细节是这样的。

1173
00:56:59,200 --> 00:57:04,970
为什么我返回false内
这个匿名函数？

1174
00:57:04,970 --> 00:57:07,420
>> 观众：有没有价值。

1175
00:57:07,420 --> 00:57:09,380
你把它的形式。

1176
00:57:09,380 --> 00:57:12,320

1177
00:57:12,320 --> 00:57:16,730
它只是说，如果值不
等于空白，然后再去做。

1178
00:57:16,730 --> 00:57:20,040

1179
00:57:20,040 --> 00:57:20,940
有在提交的一项空白。

1180
00:57:20,940 --> 00:57:21,170
>> DAVID J.马兰：确定。

1181
00:57:21,170 --> 00:57:21,640
小心，虽然。

1182
00:57:21,640 --> 00:57:22,830
有没有一个人在这里。

1183
00:57:22,830 --> 00:57:25,510
并且返回false是外
的if条件。

1184
00:57:25,510 --> 00:57:29,470
因此，这突出显示的行，返回false，
执行不管是什么时候

1185
00:57:29,470 --> 00:57:32,310
表单被提交。

1186
00:57:32,310 --> 00:57:36,810
什么是回国这里面的假
事件处理程序，因为它叫，

1187
00:57:36,810 --> 00:57:38,450
在有关活动
被提交？

1188
00:57:38,450 --> 00:57:42,350

1189
00:57:42,350 --> 00:57:44,470
>> 观众：因为它
只发生一次。

1190
00:57:44,470 --> 00:57:45,320
>> DAVID J.马兰：只发生一次。

1191
00:57:45,320 --> 00:57:46,821
不完全是。

1192
00:57:46,821 --> 00:57:47,292
是吗？

1193
00:57:47,292 --> 00:57:50,589
>> 观众：它防止表单
提交到默认的行为，

1194
00:57:50,589 --> 00:57:52,480
这样就会使页面重载。

1195
00:57:52,480 --> 00:57:53,110
>> DAVID J.马兰：没错。

1196
00:57:53,110 --> 00:57:56,490
所以我对超载提交一词在这里，
因为我说的，形式是

1197
00:57:56,490 --> 00:57:57,670
提交。

1198
00:57:57,670 --> 00:58:02,240
但如你所说，它实际上不是
在提交的真实的HTTP方法被。

1199
00:58:02,240 --> 00:58:06,870
当您点击提交，因为，我们的
onsubmit处理，我们正在拦截

1200
00:58:06,870 --> 00:58:09,040
该表单提交可以这么说。

1201
00:58:09,040 --> 00:58:11,290
我们然后做我们的事
与JavaScript代码。

1202
00:58:11,290 --> 00:58:14,070
但我故意返回false，
因为我不希望发生的一

1203
00:58:14,070 --> 00:58:18,430
一瞬间之后，是为整个表格
本身提交到网上

1204
00:58:18,430 --> 00:58:22,800
服务器与键值对通过改变
是类似的URL

1205
00:58:22,800 --> 00:58:26,180
Q =猫，或任何我们所做的，
例如，在课堂上。

1206
00:58:26,180 --> 00:58:29,640
我不希望这样的事情发生，因为
有没有这个问题的服务器监听

1207
00:58:29,640 --> 00:58:30,690
表单提交。

1208
00:58:30,690 --> 00:58:32,320
这是纯粹的JavaScript代码完成。

1209
00:58:32,320 --> 00:58:35,760
这就是为什么我什至没有一个
action属性的窗体上，因为我

1210
00:58:35,760 --> 00:58:38,870
没有为这个打算
曾经去到服务器。

1211
00:58:38,870 --> 00:58:40,780
>> 因此，它被提交。

1212
00:58:40,780 --> 00:58:44,340
但是我们截取该表单
提交并防止默认

1213
00:58:44,340 --> 00:58:47,477
的行为，这是实际
走一路到服务器。

1214
00:58:47,477 --> 00:58:48,730
>> 观众：所以保持它的客户端。

1215
00:58:48,730 --> 00:58:49,780
>> DAVID J.马兰：保持
它的客户端。

1216
00:58:49,780 --> 00:58:51,030
完全正确。

1217
00:58:51,030 --> 00:58:53,240

1218
00:58:53,240 --> 00:58:55,757
接下来是我的哦MySQL的。

1219
00:58:55,757 --> 00:59:00,000

1220
00:59:00,000 --> 00:59:00,430
>> ROB BOWDEN：确定。

1221
00:59:00,430 --> 00:59:04,990
所以这第一个问题通常是
粗糙的人。

1222
00:59:04,990 --> 00:59:07,270
虽然后来者去更好。

1223
00:59:07,270 --> 00:59:12,260
所以，你必须选择正确的数据
类型这两个列。

1224
00:59:12,260 --> 00:59:17,750
和这两个有一定
关于他们的事情，

1225
00:59:17,750 --> 00:59:20,620
做出选择很难。

1226
00:59:20,620 --> 00:59:24,430
所以整数是不是一个有效的
键入数字。

1227
00:59:24,430 --> 00:59:29,410
究其原因是一个12位帐号
数，一个int是不是足够大的

1228
00:59:29,410 --> 00:59:31,070
存储总位数。

1229
00:59:31,070 --> 00:59:36,570
因此，一个有效的选择将是一个很大的
如果你碰巧知道INT。

1230
00:59:36,570 --> 00:59:42,090
另一种选择可能是
长度12的字符字段。

1231
00:59:42,090 --> 00:59:44,560
因此，无论是那些会工作。

1232
00:59:44,560 --> 00:59:46,100
诠释不会。

1233
00:59:46,100 --> 00:59:50,170
>> 现在，平衡，回想着pset7。

1234
00:59:50,170 --> 00:59:59,540
所以我们专门用于十进制
储存的股份或价值 - 

1235
00:59:59,540 --> 01:00:00,550
>> DAVID J.马兰：现金。

1236
01:00:00,550 --> 01:00:01,060
>> ROB BOWDEN：现金。

1237
01:00:01,060 --> 01:00:05,710
我们使用十进位存储量
现金用户目前拥有。

1238
01:00:05,710 --> 01:00:10,950
所以我们这样做的原因是
因为，记住，浮在水上。

1239
01:00:10,950 --> 01:00:12,480
有没有在精度浮点。

1240
01:00:12,480 --> 01:00:18,200
它不能精确地存储的现金
像我们想要的值在这里。

1241
01:00:18,200 --> 01:00:23,630
所以，十进制是能够精确地存储
东西，说，小数点后两位。

1242
01:00:23,630 --> 01:00:27,630
这就是为什么平衡，我们希望它
为十进制数，而不是浮动。

1243
01:00:27,630 --> 01:00:30,230
>> DAVID J.马兰：此外，他也一样，虽然
它可能在其他被聪明

1244
01:00:30,230 --> 01:00:32,760
上下文去思考，也许这
是一个int的机会。

1245
01:00:32,760 --> 01:00:34,420
我就继续跟踪
事情便士。

1246
01:00:34,420 --> 01:00:38,670
因为我们明确地显示了默认
的是100.00，值

1247
01:00:38,670 --> 01:00:40,380
意味着它可能仅仅是一个int。

1248
01:00:40,380 --> 01:00:45,310
而另一个微妙过与数
是，这并不意味着

1249
01:00:45,310 --> 01:00:46,180
是一个棘手的问题。

1250
01:00:46,180 --> 01:00:49,860
但记得，在MySQL的一个int，
像在C中，至少在

1251
01:00:49,860 --> 01:00:51,440
家电，是32位的。

1252
01:00:51,440 --> 01:00:53,960
而且即使我们不指望你来
确切地知道有多少位数的

1253
01:00:53,960 --> 01:00:56,910
手段，千万记得最多
你可以代表可能

1254
01:00:56,910 --> 01:01:00,710
一个32位数字大致是怎样的？

1255
01:01:00,710 --> 01:01:02,760
>> 什么号码我们老是说什么？

1256
01:01:02,760 --> 01:01:04,530
2至32，这是大约？

1257
01:01:04,530 --> 01:01:07,492

1258
01:01:07,492 --> 01:01:08,780
你不必知道准确。

1259
01:01:08,780 --> 01:01:10,580
但大致是在生活中有所帮助。

1260
01:01:10,580 --> 01:01:12,200
这是约4十亿。

1261
01:01:12,200 --> 01:01:14,430
因此，我们说了几次。

1262
01:01:14,430 --> 01:01:16,360
我知道我已经说过，几十倍。

1263
01:01:16,360 --> 01:01:17,670
它是约4十亿。

1264
01:01:17,670 --> 01:01:19,710
这就是一个很好的规则
拇指就知道了。

1265
01:01:19,710 --> 01:01:21,880
如果你有8位，256
是一个神奇的数字。

1266
01:01:21,880 --> 01:01:24,160
如果你有32位，4
十亿给予或采取。

1267
01:01:24,160 --> 01:01:27,140
所以，如果你只写下跌4十亿，
你会看到它的位数少于

1268
01:01:27,140 --> 01:01:30,970
12，表示这显然不
够表现来捕获

1269
01:01:30,970 --> 01:01:34,220
12位帐号。

1270
01:01:34,220 --> 01:01:34,940
>> ROB BOWDEN：确定。

1271
01:01:34,940 --> 01:01:38,520
所以其他的人去比较好。

1272
01:01:38,520 --> 01:01:40,900
因此，假设银行
规定了每月20元

1273
01:01:40,900 --> 01:01:42,400
维修收费标准上的所有帐户。

1274
01:01:42,400 --> 01:01:45,506
用什么SQL查询可以在银行
从每一个计数中扣除20元，就算

1275
01:01:45,506 --> 01:01:47,520
它会导致一些负面的余额？

1276
01:01:47,520 --> 01:01:50,380
因此，基本上，有四个
查询的主要类型 - 

1277
01:01:50,380 --> 01:01:52,840
插入，选择，更新和删除。

1278
01:01:52,840 --> 01:01:56,080
那么，我们认为我们
要在这里使用？

1279
01:01:56,080 --> 01:01:57,000
更新。

1280
01:01:57,000 --> 01:01:58,260
>> 因此，让我们一起来看看。

1281
01:01:58,260 --> 01:02:04,290

1282
01:02:04,290 --> 01:02:05,870
所以在这里，我们要更新。

1283
01:02:05,870 --> 01:02:09,900
我们要更新什么表帐户？

1284
01:02:09,900 --> 01:02:11,670
所以更新账户。

1285
01:02:11,670 --> 01:02:15,390
然后语法说什么
帐户被我们更新？

1286
01:02:15,390 --> 01:02:19,520
好了，我们设置的平衡等于
余额减去20的电流值。

1287
01:02:19,520 --> 01:02:22,860
因此，这将更新所有行
帐户，减去

1288
01:02:22,860 --> 01:02:26,250
20美元的余额。

1289
01:02:26,250 --> 01:02:29,260
>> DAVID J.马兰：这里一个常见的​​错误，
即使我们有时会原谅它，

1290
01:02:29,260 --> 01:02:32,990
是实际上这里有PHP代码
调用查询功能，或将

1291
01:02:32,990 --> 01:02:35,460
周围的一切引号的
并不需要在那里。

1292
01:02:35,460 --> 01:02:39,780
>> ROB BOWDEN：请记住，MySQL是
从PHP一个独立的语言。

1293
01:02:39,780 --> 01:02:42,410
我们碰巧在PHP中要编写的MySQL。

1294
01:02:42,410 --> 01:02:46,180
和PHP，然后送它
在MySQL服务器。

1295
01:02:46,180 --> 01:02:51,120
但你不为了需要使用PHP
与MySQL服务器进行通信。

1296
01:02:51,120 --> 01:02:51,730
>> DAVID J.马兰：没错。

1297
01:02:51,730 --> 01:02:54,240
所以没有带美元符号变量
应于该上下文。

1298
01:02:54,240 --> 01:02:59,550
它可以做所有的数学
在数据库本身。

1299
01:02:59,550 --> 01:03:00,080
>> ROB BOWDEN：确定。

1300
01:03:00,080 --> 01:03:01,300
所以，下一个。

1301
01:03:01,300 --> 01:03:02,731
这是下一个？

1302
01:03:02,731 --> 01:03:03,210
是啊。

1303
01:03:03,210 --> 01:03:06,570
所以用什么SQL查询可以在银行
其检索的帐号

1304
01:03:06,570 --> 01:03:09,300
最丰富的客户，那些与
余额大于1,000？

1305
01:03:09,300 --> 01:03:13,280
所以这四个主要类型
我们要在这里想要什么？

1306
01:03:13,280 --> 01:03:14,430
选择。

1307
01:03:14,430 --> 01:03:16,650
所以，我们要选择。

1308
01:03:16,650 --> 01:03:17,610
我们究竟要选择？

1309
01:03:17,610 --> 01:03:19,380
我们想要怎样栏选择？

1310
01:03:19,380 --> 01:03:20,970
我们会特别希望
选择号码。

1311
01:03:20,970 --> 01:03:23,910
但是，如果你说的明星，我们
也接受这一点。

1312
01:03:23,910 --> 01:03:25,820
>> 那么从​​什么表中选择号码？

1313
01:03:25,820 --> 01:03:26,640
帐户。

1314
01:03:26,640 --> 01:03:28,370
然后条件，我们想要的吗？

1315
01:03:28,370 --> 01:03:30,140
凡结余超过1000人。

1316
01:03:30,140 --> 01:03:31,720
我们也接受更大
小于或等于。

1317
01:03:31,720 --> 01:03:35,230

1318
01:03:35,230 --> 01:03:36,190
最后一个。

1319
01:03:36,190 --> 01:03:42,940
用什么SQL查询可以在银行
接近，即删除每一个帐户

1320
01:03:42,940 --> 01:03:44,480
有$ 0的平衡？

1321
01:03:44,480 --> 01:03:47,620
因此，这四个是我们
会想使用？

1322
01:03:47,620 --> 01:03:48,320
删除。

1323
01:03:48,320 --> 01:03:50,180
所以，语法是什么？

1324
01:03:50,180 --> 01:03:51,890
从什么表中删除？

1325
01:03:51,890 --> 01:03:53,550
帐户。

1326
01:03:53,550 --> 01:03:55,790
然后在其上的条件
我们想删除 - 

1327
01:03:55,790 --> 01:03:57,280
其中平衡等于零。

1328
01:03:57,280 --> 01:04:03,050
因此，从账户中删除所有行
当余额为零。

1329
01:04:03,050 --> 01:04:04,300
对上述任何一个问题？

1330
01:04:04,300 --> 01:04:08,840

1331
01:04:08,840 --> 01:04:10,260
要排队？

1332
01:04:10,260 --> 01:04:11,200
>> DAVID J.马兰：队列指南。

1333
01:04:11,200 --> 01:04:17,110
所以在这一块，我们给你一个有点
熟悉的结构，我们探索出了

1334
01:04:17,110 --> 01:04:20,450
在课堂位旁边的结构，
这是一个数据

1335
01:04:20,450 --> 01:04:21,910
结构中的精神有关。

1336
01:04:21,910 --> 01:04:24,670
虽然与队列的区别是
我们必须以某种方式记得是谁

1337
01:04:24,670 --> 01:04:27,900
是在队列的前面，在大
一部分这样我们就可以赚更多

1338
01:04:27,900 --> 01:04:30,530
有效地使用存储器，至少
如果我们用一个数组。

1339
01:04:30,530 --> 01:04:35,460
>> 因为召回，如果我们有一个数组，如果，
举例来说，这是前部

1340
01:04:35,460 --> 01:04:38,470
队列中，如果我进入队列这里，
然后有人得到一致

1341
01:04:38,470 --> 01:04:42,710
我，在我身后，在我身后，后面
一个人走出行，你

1342
01:04:42,710 --> 01:04:45,930
可以，因为我们看到了一些我们人类的
在课堂的志愿者，让每个人都

1343
01:04:45,930 --> 01:04:47,100
转向这种方式。

1344
01:04:47,100 --> 01:04:50,880
但在一般情况下，大家有做
自己是不是时间的最佳利用

1345
01:04:50,880 --> 01:04:54,600
在程序中，因为这意味着你的
算法在运行什么

1346
01:04:54,600 --> 01:04:56,520
渐近运行时间？

1347
01:04:56,520 --> 01:04:57,420
它是线性的。

1348
01:04:57,420 --> 01:04:59,600
>> 我觉得这是种愚蠢的。

1349
01:04:59,600 --> 01:05:02,890
如果下一人行是下一个
人谁的应该进入

1350
01:05:02,890 --> 01:05:04,660
商店，他们不都
一起移动。

1351
01:05:04,660 --> 01:05:08,200
只是让那人被人拔光了
在时机成熟时，例如。

1352
01:05:08,200 --> 01:05:09,870
这样既可以节省一点时间在那里。

1353
01:05:09,870 --> 01:05:14,840
所以要做到这一点，那就是说
该队列的头部或

1354
01:05:14,840 --> 01:05:18,060
该队列的前面是要
逐步移动越陷越深

1355
01:05:18,060 --> 01:05:23,340
到阵列中，并最终可能
实际上环绕，如果我们使用的是

1356
01:05:23,340 --> 01:05:25,790
数组来存储人
在此队列中。

1357
01:05:25,790 --> 01:05:28,390
所以你几乎可以想到的
数组作为循环数据

1358
01:05:28,390 --> 01:05:29,880
结构在这个意义上。

1359
01:05:29,880 --> 01:05:33,970
>> 所以，你无论如何都必须跟踪的
它的大小或它的真正结束

1360
01:05:33,970 --> 01:05:36,250
然后在那里它的开始是。

1361
01:05:36,250 --> 01:05:39,490
因此，我们建议您声明
一个这样的队列，呼叫

1362
01:05:39,490 --> 01:05:41,330
它Q，只是一个字母。

1363
01:05:41,330 --> 01:05:44,570
然后，我们建议把前面是
初始化为零，并且大小

1364
01:05:44,570 --> 01:05:45,470
初始化为零。

1365
01:05:45,470 --> 01:05:47,770
>> 所以现在，没有什么
里面的那个队列。

1366
01:05:47,770 --> 01:05:50,910
我们要求你完成
在下面执行的入队

1367
01:05:50,910 --> 01:05:55,250
这样一种方式，该函数将n到
q的末尾，然后返回true。

1368
01:05:55,250 --> 01:05:58,690
但是，如果q是满的或负的，本
函数应该改为返回false。

1369
01:05:58,690 --> 01:06:01,060
我们给你一对夫妇
假设。

1370
01:06:01,060 --> 01:06:04,320
但他们并不是真正的功能
相关的，刚才那布尔存在，

1371
01:06:04,320 --> 01:06:06,690
因为，从技术上讲，布尔不
存在于C，除非你有一个

1372
01:06:06,690 --> 01:06:07,310
某些头文件。

1373
01:06:07,310 --> 01:06:09,350
所以这只是确保有
没有了这是一招

1374
01:06:09,350 --> 01:06:10,940
问题之类的话。

1375
01:06:10,940 --> 01:06:16,280
>> 所以排队，我们的样本中提出的
解决方案来实现，如下所示。

1376
01:06:16,280 --> 01:06:20,420
一，我们首先检查方便，
低悬的果实。

1377
01:06:20,420 --> 01:06:23,820
如果队列已满或数
你试图插入小于

1378
01:06:23,820 --> 01:06:26,380
大于零，这是我们在所述
规范的问题应

1379
01:06:26,380 --> 01:06:30,320
不会被允许的，因为我们只想要
非负值，那么你应该

1380
01:06:30,320 --> 01:06:31,640
只是立即返回false。

1381
01:06:31,640 --> 01:06:33,820
因此，一些相对容易
错误检查。

1382
01:06:33,820 --> 01:06:38,720
如果你虽然想补充的是，实际
号，你不得不做一点

1383
01:06:38,720 --> 01:06:39,440
想在这里。

1384
01:06:39,440 --> 01:06:41,330
而这正是它是一个有点讨厌
弱智，因为你必须

1385
01:06:41,330 --> 01:06:43,000
弄清楚如何处理环绕。

1386
01:06:43,000 --> 01:06:46,870
>> 但这个想法的萌芽在这里，是的
我们感兴趣的是，环绕

1387
01:06:46,870 --> 01:06:51,480
往往意味着模运算和
mod运算符，百分比方面，

1388
01:06:51,480 --> 01:06:55,140
在那里你可以从一个较大的值
回零，然后一个及两个

1389
01:06:55,140 --> 01:06:58,650
3，然后绕回至零，
1和2和3等

1390
01:06:58,650 --> 01:06:59,380
一遍又一遍。

1391
01:06:59,380 --> 01:07:02,880
因此，我们建议这样做的方法是
那不是我们不想索引到

1392
01:07:02,880 --> 01:07:05,850
阵列被叫号码所在
我们的整数说谎。

1393
01:07:05,850 --> 01:07:10,740
但到那里，我们首先想要做的
无论队列的大小是但

1394
01:07:10,740 --> 01:07:14,080
然后添加到无论
在列表的前面是。

1395
01:07:14,080 --> 01:07:17,880
和其效果是把我们
在队列中合适的位置和

1396
01:07:17,880 --> 01:07:20,970
不要以为在线路的第一人
是在开始时，他或

1397
01:07:20,970 --> 01:07:24,130
她绝对可以，如果我们
也被转移大家。

1398
01:07:24,130 --> 01:07:26,710
但我们只是创建工作
为了我们自己，如果我们把

1399
01:07:26,710 --> 01:07:27,800
该特定路径。

1400
01:07:27,800 --> 01:07:29,330
>> 所以我们可以保持它相对简单。

1401
01:07:29,330 --> 01:07:32,180
我们必须记住，我们只是
添加一个int到队列中。

1402
01:07:32,180 --> 01:07:35,850
然后我们就返回true。

1403
01:07:35,850 --> 01:07:38,560
同时，在出队，我们问
你要做到以下几点。

1404
01:07:38,560 --> 01:07:42,260
实现它以这样一种方式，它
出队，那就是移除并返回，

1405
01:07:42,260 --> 01:07:44,190
整型在队列的前面。

1406
01:07:44,190 --> 01:07:46,410
要取出整数，它满足
忘记它。

1407
01:07:46,410 --> 01:07:47,650
你并不需要覆盖其位。

1408
01:07:47,650 --> 01:07:48,820
因此，它实际上仍然存在。

1409
01:07:48,820 --> 01:07:51,930
就像一个硬盘上的数据，
我们只是忽略了一个事实

1410
01:07:51,930 --> 01:07:52,970
它现在在那里。

1411
01:07:52,970 --> 01:07:55,520
而如果q是空的，我们应该
而不是返回负1。

1412
01:07:55,520 --> 01:07:56,750
所以这种感觉随心所欲。

1413
01:07:56,750 --> 01:08:01,640
为什么返回负1
而不是假的？

1414
01:08:01,640 --> 01:08:02,620
是啊。

1415
01:08:02,620 --> 01:08:05,070
>> 观众：Q被存储
正值。

1416
01:08:05,070 --> 01:08:10,950
既然你只存储正值
在第q，负是一个错误。

1417
01:08:10,950 --> 01:08:11,510
>> DAVID J. MALAN：好，真的。

1418
01:08:11,510 --> 01:08:14,850
所以，因为我们只存储正
值或者为零，那么它的罚款

1419
01:08:14,850 --> 01:08:18,050
返回一个负的值作为定点
值，特殊符号。

1420
01:08:18,050 --> 01:08:21,630
但你重写历史上，
因为我们是唯一的原因

1421
01:08:21,630 --> 01:08:25,890
返回非负值
是因为我们要

1422
01:08:25,890 --> 01:08:27,670
有一个标记值。

1423
01:08:27,670 --> 01:08:32,617
所以，更确切地说，为什么不干脆
在错误的情况下返回假的？

1424
01:08:32,617 --> 01:08:33,099
是啊。

1425
01:08:33,099 --> 01:08:35,510
>> 观众：你已经失败
返回一个整数。

1426
01:08:35,510 --> 01:08:36,630
>> DAVID J.马兰：没错。

1427
01:08:36,630 --> 01:08:38,569
这就是其中C得到
漂亮的制约。

1428
01:08:38,569 --> 01:08:40,590
如果你说你要去
返回一个int，你有

1429
01:08:40,590 --> 01:08:41,279
返回一个int。

1430
01:08:41,279 --> 01:08:43,689
你不能花哨，并开始返回
一个bool或浮或

1431
01:08:43,689 --> 01:08:45,040
字符串或类似的东西。

1432
01:08:45,040 --> 01:08:49,370
现在，与此同时，JavaScript和PHP和
其他一些语言可以，其实，

1433
01:08:49,370 --> 01:08:51,310
你有不同的返回
类型的值。

1434
01:08:51,310 --> 01:08:54,819
而这实际上是有用的，其中
你可以返回正整数，零，

1435
01:08:54,819 --> 01:08:59,439
负整数，或虚假或无效
甚至表示错误。

1436
01:08:59,439 --> 01:09:01,890
但是，我们没有这方面的
多功能性C.

1437
01:09:01,890 --> 01:09:04,569
>> 因此，与出队，我们什么
建议做的是 - 

1438
01:09:04,569 --> 01:09:07,350

1439
01:09:07,350 --> 01:09:09,830
>> ROB BOWDEN：你可以返回false。

1440
01:09:09,830 --> 01:09:13,189
这只是虚假的散列
定义虚假为零。

1441
01:09:13,189 --> 01:09:16,000
所以，如果你返回false，
你返回零。

1442
01:09:16,000 --> 01:09:25,470
零是一个有效的事情在我们的队列中，
而负1是不是如果

1443
01:09:25,470 --> 01:09:27,000
假正好是负1。

1444
01:09:27,000 --> 01:09:29,972
但你应该甚至不
需要知道。

1445
01:09:29,972 --> 01:09:32,399
>> DAVID J.马兰：这是
为什么我没有说出来。

1446
01:09:32,399 --> 01:09:36,450
>> ROB BOWDEN：但它是不是真的
你不能返回false。

1447
01:09:36,450 --> 01:09:37,700
>> DAVID J.马兰：当然可以。

1448
01:09:37,700 --> 01:09:40,920

1449
01:09:40,920 --> 01:09:44,240
所以出队，发现我们接受
丧失作为它的参数。

1450
01:09:44,240 --> 01:09:45,479
那是因为我们不是
递东西英寸

1451
01:09:45,479 --> 01:09:48,359
我们只是要移除的元素
在队列的前面。

1452
01:09:48,359 --> 01:09:49,819
那么我们如何能够去这样做？

1453
01:09:49,819 --> 01:09:51,290
嗯，首先，让我们这样做
快速完整性检查。

1454
01:09:51,290 --> 01:09:53,350
如果队列大小为0，有
没有工作要做。

1455
01:09:53,350 --> 01:09:54,210
返回负1。

1456
01:09:54,210 --> 01:09:54,800
Done（完成）。

1457
01:09:54,800 --> 01:09:56,340
所以这是我的程序几行。

1458
01:09:56,340 --> 01:09:58,180
因此，只有四行依然存在。

1459
01:09:58,180 --> 01:10:01,310
>> 所以在这里我决定递减
的大小。

1460
01:10:01,310 --> 01:10:04,620
并有效地递减的大小
也就是说，我忘了

1461
01:10:04,620 --> 01:10:06,010
东西就在那里。

1462
01:10:06,010 --> 01:10:09,910
但我也有更新的地方
数字的前面是。

1463
01:10:09,910 --> 01:10:11,620
因此，要做到这一点，我需要
做两件事情。

1464
01:10:11,620 --> 01:10:16,390
我首先需要记住的数量
是在该队列的前面，

1465
01:10:16,390 --> 01:10:17,860
因为我需要返回那个东西。

1466
01:10:17,860 --> 01:10:20,910
所以我不想忘记意外
关于它，然后覆盖它。

1467
01:10:20,910 --> 01:10:22,840
我只是要记得在一个int。

1468
01:10:22,840 --> 01:10:27,310
>> 而现在，我要更新
q.front被q.front +1。

1469
01:10:27,310 --> 01:10:30,070
因此，如果这是在第一人称
行，现在，我想要做加1

1470
01:10:30,070 --> 01:10:31,930
指向下一个人行。

1471
01:10:31,930 --> 01:10:33,420
但是，我必须处理回绕。

1472
01:10:33,420 --> 01:10:37,270
如果能力是一个全局常量，
那将让我确定

1473
01:10:37,270 --> 01:10:41,140
当我点到最后的人
线，该模运算将带来

1474
01:10:41,140 --> 01:10:43,840
我回零的
前面的队列。

1475
01:10:43,840 --> 01:10:46,050
而且这里处理环绕。

1476
01:10:46,050 --> 01:10:48,950
然后我继续返回否。

1477
01:10:48,950 --> 01:10:51,530
>> 现在，严格地说，我没有
必须声明ñ。

1478
01:10:51,530 --> 01:10:53,880
我没有抓住它并将其存储
是暂时的，因为该值是

1479
01:10:53,880 --> 01:10:54,740
仍然存在。

1480
01:10:54,740 --> 01:10:57,490
所以我只能做正确的算术
返回前负责人

1481
01:10:57,490 --> 01:10:58,450
队列。

1482
01:10:58,450 --> 01:11:01,850
但我只是觉得这是更清晰
实际上抢整数，把它

1483
01:11:01,850 --> 01:11:04,320
以n，然后返回
为清晰起见，但

1484
01:11:04,320 --> 01:11:05,735
不是严格必要的。

1485
01:11:05,735 --> 01:11:09,313

1486
01:11:09,313 --> 01:11:12,130
嘘。

1487
01:11:12,130 --> 01:11:13,410
他们都是发音的在我的脑海。

1488
01:11:13,410 --> 01:11:15,940

1489
01:11:15,940 --> 01:11:19,110
>> ROB BOWDEN：所以第一个问题
是二叉树的问题。

1490
01:11:19,110 --> 01:11:22,140
所以，第一个问题是，我们是
考虑到这些数字。

1491
01:11:22,140 --> 01:11:27,160
我们希望以某种方式将它们插入到
这些节点，例如，它是一个

1492
01:11:27,160 --> 01:11:30,110
有效的二叉搜索树。

1493
01:11:30,110 --> 01:11:36,260
所以，有一点要记住的
二叉搜索树是它的不

1494
01:11:36,260 --> 01:11:39,800
刚才说的事情向左移
少与事

1495
01:11:39,800 --> 01:11:41,120
右边是更大的。

1496
01:11:41,120 --> 01:11:44,580
它需要整个树
左边是更小，并且在整个树

1497
01:11:44,580 --> 01:11:45,740
向右更大。

1498
01:11:45,740 --> 01:11:55,260
>> 所以，如果我把34在此间举行的顶部，然后
我把20在这里，所以这是有效的，

1499
01:11:55,260 --> 01:11:56,970
到目前为止，因为34在这里。

1500
01:11:56,970 --> 01:11:57,920
20是要在左边。

1501
01:11:57,920 --> 01:11:58,950
所以这是少。

1502
01:11:58,950 --> 01:12:03,640
但我不能再放入59在这里，因为
尽管图59是对20的右侧，

1503
01:12:03,640 --> 01:12:06,140
它仍然在34的左边。

1504
01:12:06,140 --> 01:12:10,760
因此，在这该约束时，
大概解决这个最简单的方法

1505
01:12:10,760 --> 01:12:14,330
问题是，只是排序
这些数字 - 

1506
01:12:14,330 --> 01:12:18,720
所以20，34，36，52，59，106。

1507
01:12:18,720 --> 01:12:21,640
然后将这些
从左至右。

1508
01:12:21,640 --> 01:12:23,390
>> 所以20放在这里。

1509
01:12:23,390 --> 01:12:24,630
34放在这里。

1510
01:12:24,630 --> 01:12:25,830
36放在这里。

1511
01:12:25,830 --> 01:12:29,360
52，59，106。

1512
01:12:29,360 --> 01:12:34,730
你也可以想通了与
有些堵塞和实现，

1513
01:12:34,730 --> 01:12:38,830
哦，等一下，我没有足够的数字
填补这个在在这里。

1514
01:12:38,830 --> 01:12:42,170
所以我需要reshift我什么
路线音符将是。

1515
01:12:42,170 --> 01:12:47,490
但是请注意，在最后三，如果
你读从左至右，它是在

1516
01:12:47,490 --> 01:12:48,740
递增的顺序。

1517
01:12:48,740 --> 01:12:52,150

1518
01:12:52,150 --> 01:12:56,540
>> 所以，现在，我们想声明的是什么
结构将是为

1519
01:12:56,540 --> 01:12:58,300
在这棵树的节点。

1520
01:12:58,300 --> 01:13:02,720
所以，我们需要在一个二叉树是什么？

1521
01:13:02,720 --> 01:13:05,830
因此，我们有类型的值
整型，所以一些int值。

1522
01:13:05,830 --> 01:13:07,220
我不知道我们所谓的
它在溶液中 - 

1523
01:13:07,220 --> 01:13:08,500
INT N。

1524
01:13:08,500 --> 01:13:13,570
我们需要一个指向左边的孩子
和一个指向右边的孩子。

1525
01:13:13,570 --> 01:13:17,540
所以它会看起来像这样。

1526
01:13:17,540 --> 01:13:20,510
它会实际上看前
什么时候的双向链接

1527
01:13:20,510 --> 01:13:25,090
列表的东西，所以通知 - 

1528
01:13:25,090 --> 01:13:27,860
我将不得不滚动所有
方法回落到问题11。

1529
01:13:27,860 --> 01:13:30,980

1530
01:13:30,980 --> 01:13:36,390
>> 所以发现它看起来相同这一点，
除了我们只是碰巧调用这些

1531
01:13:36,390 --> 01:13:38,590
不同的名称。

1532
01:13:38,590 --> 01:13:41,440
我们还有一个整数
值和两个指针。

1533
01:13:41,440 --> 01:13:44,850
它是这样的态度对待这一点的
作为指针指向的下一件事

1534
01:13:44,850 --> 01:13:47,955
和以前的事情，我们正在处理
该指针指向一个左子

1535
01:13:47,955 --> 01:13:49,205
和右孩子。

1536
01:13:49,205 --> 01:13:57,372

1537
01:13:57,372 --> 01:13:57,860
确定。

1538
01:13:57,860 --> 01:13:59,650
所以这是我们的结构节点。

1539
01:13:59,650 --> 01:14:03,920
而现在，唯一的功能，我们需要
实施这是遍历，这

1540
01:14:03,920 --> 01:14:08,320
我们要越过树，印刷
从树上，以便这些值。

1541
01:14:08,320 --> 01:14:15,241
>> 所以在这里看，我们要打印
出20，34，36，52，59，和106。

1542
01:14:15,241 --> 01:14:17,970
我们如何实现这一目标？

1543
01:14:17,970 --> 01:14:18,890
所以这是非常相似的。

1544
01:14:18,890 --> 01:14:22,910
如果你在过去的考试，看到了问题
你想打印出

1545
01:14:22,910 --> 01:14:25,940
整个树用逗号之间
一切，它实际上是连

1546
01:14:25,940 --> 01:14:27,320
比这更容易。

1547
01:14:27,320 --> 01:14:30,950
因此，这里的解决方案。

1548
01:14:30,950 --> 01:14:33,110
这是显著更容易
如果你递归地做到了。

1549
01:14:33,110 --> 01:14:36,650
我不知道是否有人试图
要反复做。

1550
01:14:36,650 --> 01:14:38,340
>> 但首先，我们有我们的基本情况。

1551
01:14:38,340 --> 01:14:39,660
如果哪根是空？

1552
01:14:39,660 --> 01:14:40,610
然后，我们只是要回。

1553
01:14:40,610 --> 01:14:42,300
我们不希望打印出任何东西。

1554
01:14:42,300 --> 01:14:45,940
否则我们将遍历
递归下降。

1555
01:14:45,940 --> 01:14:48,140
打印整个左子树。

1556
01:14:48,140 --> 01:14:51,440
所以打印较少的一切
比我的当前值。

1557
01:14:51,440 --> 01:14:53,930
然后我要打印我自己。

1558
01:14:53,930 --> 01:14:57,310
然后，我要向下递归我
整个右子树，所以一切

1559
01:14:57,310 --> 01:14:58,810
比我的价值更大。

1560
01:14:58,810 --> 01:15:03,870
这是要打印
出一切为了。

1561
01:15:03,870 --> 01:15:05,860
这个实际上是怎样的问题
完成了吗？

1562
01:15:05,860 --> 01:15:09,892

1563
01:15:09,892 --> 01:15:12,545
>> 观众：我有一个问题
在[听不清]。

1564
01:15:12,545 --> 01:15:15,090

1565
01:15:15,090 --> 01:15:23,550
>> ROB BOWDEN：逼近所以单程
任何递归的问题是只是觉得

1566
01:15:23,550 --> 01:15:26,275
它喜欢你不得不思考
所有的角落案件。

1567
01:15:26,275 --> 01:15:32,150

1568
01:15:32,150 --> 01:15:38,110
因此认为，我们要
打印此整个树。

1569
01:15:38,110 --> 01:15:42,030
所以我们要专注于
就是这个特殊的节点 - 

1570
01:15:42,030 --> 01:15:43,740
36。

1571
01:15:43,740 --> 01:15:47,420
递归调用，我们假装
那些只是工作。

1572
01:15:47,420 --> 01:15:54,000
所以在这里，这个递归调用
遍历，我们甚至没有想到

1573
01:15:54,000 --> 01:15:58,640
关于它，只是遍历左
3，假设已经打印20

1574
01:15:58,640 --> 01:16:00,730
34我们。

1575
01:16:00,730 --> 01:16:03,350
然后当我们最终递归
遍历调用的

1576
01:16:03,350 --> 01:16:07,890
右，这将正确打印
52，59，106我们。

1577
01:16:07,890 --> 01:16:13,620
>> 所以考虑到这可以打印20，34，和
另可打印52，59，108，

1578
01:16:13,620 --> 01:16:17,180
所有我们需要能够做的就是打印
我们自己在那中间。

1579
01:16:17,180 --> 01:16:21,250
因此，摆在我们面前打印出来的一切。

1580
01:16:21,250 --> 01:16:27,710
打印我们自己，所以当前节点的打印
36，定期的printf，然后

1581
01:16:27,710 --> 01:16:31,170
之后，我们打印了一切。

1582
01:16:31,170 --> 01:16:32,730
>> DAVID J.马兰：这是递归
变得非常漂亮。

1583
01:16:32,730 --> 01:16:36,270
这是信仰的这个惊人的飞跃，其中
你做的工作哪怕一丁点。

1584
01:16:36,270 --> 01:16:38,460
然后你让别人
别人做休息。

1585
01:16:38,460 --> 01:16:40,180
和别人
是，讽刺的是，你。

1586
01:16:40,180 --> 01:16:44,260

1587
01:16:44,260 --> 01:16:48,360
因此，对于严重的印象分，如果
你向上滚动的问题 - 

1588
01:16:48,360 --> 01:16:50,530
>> ROB BOWDEN：在的问题呢？

1589
01:16:50,530 --> 01:16:53,490
>> DAVID J.马兰：上下了多大
这些数字，有没有人知道在哪里

1590
01:16:53,490 --> 01:16:55,190
这些数字从何而来？

1591
01:16:55,190 --> 01:16:56,610
>> ROB BOWDEN：我简直不知道。

1592
01:16:56,610 --> 01:16:59,794
>> DAVID J.马兰：他们似乎
整个测验。

1593
01:16:59,794 --> 01:17:01,150
>> 观众：他们是相同的号码？

1594
01:17:01,150 --> 01:17:01,910
>> DAVID J.马兰：这些数字。

1595
01:17:01,910 --> 01:17:03,260
有点复活节彩蛋。

1596
01:17:03,260 --> 01:17:08,100
因此，对于那些你在网上看
回家，如果你可以通过电子邮件告诉我们

1597
01:17:08,100 --> 01:17:12,680
heads@CS50.net什么意义
这些反复出现的六个号码是

1598
01:17:12,680 --> 01:17:18,560
整个测验1，我们将沐浴你
以惊人的注意力在最后

1599
01:17:18,560 --> 01:17:21,610
演讲和一个压力球。

1600
01:17:21,610 --> 01:17:25,460

1601
01:17:25,460 --> 01:17:27,790
美观大方，含蓄。

1602
01:17:27,790 --> 01:17:29,570
>> ROB BOWDEN：最后还有什么问题
关于测验什么？

1603
01:17:29,570 --> 01:17:32,608