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
做服務器端驗證是
大多數人現身CS​​50都知道

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
通過做一些完全可以接受
謊言無功值變

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