1
00:00:00,000 --> 00:00:11,460

2
00:00:11,460 --> 00:00:12,250
>> 國寶馬蘭所有權利。

3
00:00:12,250 --> 00:00:13,860
歡迎回到CS50。

4
00:00:13,860 --> 00:00:16,190
這是第8週開始。

5
00:00:16,190 --> 00:00:21,320
記得這個問題集5結束
帶著一點點的挑戰。

6
00:00:21,320 --> 00:00:25,210
因此，假如你恢復你所有的
教學研究員和加利福尼亞州的照片

7
00:00:25,210 --> 00:00:30,480
在card.raw文件，你有資格
現在發現所有的那些人，

8
00:00:30,480 --> 00:00:34,510
一個幸運的獲勝者將步行回家與
這些東西，飛躍運動

9
00:00:34,510 --> 00:00:37,450
你可以使用最後的設備
項目，例如。

10
00:00:37,450 --> 00:00:39,860
>> ，每一年，這會導致
有點creepiness。

11
00:00:39,860 --> 00:00:43,480
所以我想我會做什麼是購
與您指出

12
00:00:43,480 --> 00:00:47,370
來回走了過
後期工作人員名單。

13
00:00:47,370 --> 00:00:51,110
舉例來說，就在昨天晚上，報價
引文結束，從一名工作人員

14
00:00:51,110 --> 00:00:55,000
成員，“我只是一個學生敲
我的門，跟我拍一張照片。

15
00:00:55,000 --> 00:00:59,020
潛行者，我告訴你。“開始了
相當的描述，然後我們感動

16
00:00:59,020 --> 00:01:02,830
就到了，一個小時左右後，“我有一個
後部分學生在等著我

17
00:01:02,830 --> 00:01:06,080
他有我們的名字和照片
幾張紙。“所有權利。

18
00:01:06,080 --> 00:01:09,230
所以組織，但不
這一切令人毛骨悚然。

19
00:01:09,230 --> 00:01:12,520
>> 那麼，“我是出城的這個週末，
當我回來的時候，有一個在

20
00:01:12,520 --> 00:01:12,630
我的

21
00:01:12,630 --> 00:01:16,740
臥室裡。“[笑]

22
00:01:16,740 --> 00:01:20,410
國寶的馬蘭：下報價從工作人員
成員，“一個學生來我家

23
00:01:20,410 --> 00:01:25,330
薩默維爾今早凌晨4點“。
工作人員，“我得到了我的酒店在聖

24
00:01:25,330 --> 00:01:30,016
舊金山和一名學生被等待
我在大堂有三個數碼單反相機“。

25
00:01:30,016 --> 00:01:31,510
相機類型。

26
00:01:31,510 --> 00:01:34,980
“我什至不對員工這學期，
但學生闖進我家

27
00:01:34,980 --> 00:01:40,480
早晨和記錄了整個事情
與谷歌的玻璃。“最後，

28
00:01:40,480 --> 00:01:43,650
“至少12人翹首
等待著我，當我離開了我

29
00:01:43,650 --> 00:01:44,800
豪華轎車，然後我

30
00:01:44,800 --> 00:01:46,970
醒了。“所有權利。

31
00:01:46,970 --> 00:01:57,690
因此，在拍攝的照片中，你可能
回想一下，這傢伙在這裡，你是誰

32
00:01:57,690 --> 00:02:01,850
可能知道米洛香蕉，誰住
勞倫·卡瓦略，我們的頭

33
00:02:01,850 --> 00:02:02,905
教學研究員。

34
00:02:02,905 --> 00:02:05,170
米洛，米洛，來這裡的孩子。

35
00:02:05,170 --> 00:02:06,320
米洛。

36
00:02:06,320 --> 00:02:08,650
米洛。

37
00:02:08,650 --> 00:02:12,230
你要知道，他的穿著谷歌的玻璃，所以
我們會告訴你這一切之後。

38
00:02:12,230 --> 00:02:16,190
因此，這是米洛，如果你想
後來與他拍一張照片。

39
00:02:16,190 --> 00:02:18,240
如果你想看看
在那裡的觀眾。

40
00:02:18,240 --> 00:02:19,430
確定。

41
00:02:19,430 --> 00:02:20,200
這是很好的素材。

42
00:02:20,200 --> 00:02:22,556
嗯，香蕉米洛。

43
00:02:22,556 --> 00:02:23,941
哦，不做到這一點。

44
00:02:23,941 --> 00:02:29,020
>> [笑]

45
00:02:29,020 --> 00:02:29,470
>> 確定。

46
00:02:29,470 --> 00:02:34,550
所以一個單詞，然後是什麼樣的未來，
因為當我們開始轉型，

47
00:02:34,550 --> 00:02:38,410
具體而言，這個星期在從C
命令行環境PHP和

48
00:02:38,410 --> 00:02:42,720
JavaScript和SQL，HTML和CSS
一個基於網絡的環境中，我們將

49
00:02:42,720 --> 00:02:44,490
你的所有裝備
更多知識

50
00:02:44,490 --> 00:02:46,010
潛在的最終項目。

51
00:02:46,010 --> 00:02:49,240
為此，當然是有
傳統舉行研討會

52
00:02:49,240 --> 00:02:50,950
上切線主題的
當然。

53
00:02:50,950 --> 00:02:54,330
非常相關的編程和
應用開發等等，但

54
00:02:54,330 --> 00:02:57,010
不一定探索
當然自己的教學大綱。

55
00:02:57,010 --> 00:03:00,250
>> 所以，如果你可能有興趣在一個
今年的研討會，

56
00:03:00,250 --> 00:03:02,530
註冊cs50.net/seminar。

57
00:03:02,530 --> 00:03:06,170
有舊研討會
在cs50.net/seminars。

58
00:03:06,170 --> 00:03:10,620
和今年迄今名冊
驚人的Web應用程序使用Ruby on

59
00:03:10,620 --> 00:03:13,580
導軌，這是一種替代
語言PHP。

60
00:03:13,580 --> 00:03:14,900
計算語言學。

61
00:03:14,900 --> 00:03:18,710
到iOS，這是
平台，用於iPhone和

62
00:03:18,710 --> 00:03:19,850
iPad的發展。

63
00:03:19,850 --> 00:03:22,890
JavaScript的Web應用程序的，我們將討論
，但在本次研討會中，你會去

64
00:03:22,890 --> 00:03:24,070
的更多細節。

65
00:03:24,070 --> 00:03:27,390
>> 蹦蹦運動，所以我們實際上也有
我們的朋友從大躍進運動，

66
00:03:27,390 --> 00:03:29,160
公司本身，加入我們的行列。

67
00:03:29,160 --> 00:03:31,800
明天，其實，為客戶提供
一個動手的研討會，如果

68
00:03:31,800 --> 00:03:33,320
你的興趣。

69
00:03:33,320 --> 00:03:38,770
meteor.js，另一種技術
而不是在瀏覽器中使用JavaScript，

70
00:03:38,770 --> 00:03:39,970
但在服務器上。

71
00:03:39,970 --> 00:03:42,110
Node.js的，這是非常
在該靜脈。

72
00:03:42,110 --> 00:03:43,650
圓滑的Andr​​oid設計。

73
00:03:43,650 --> 00:03:46,990
Android的一個非常受歡迎的替代
的iOS和Windows Phone

74
00:03:46,990 --> 00:03:48,790
和其他移動平台。

75
00:03:48,790 --> 00:03:51,180
和Web安全主動防禦。

76
00:03:51,180 --> 00:03:54,590
>> 因此，事實上，如果你想
搞這個，讓我

77
00:03:54,590 --> 00:03:55,840
注意到這一點。

78
00:03:55,840 --> 00:03:57,790
我們非常高興地說，
我們的朋友在大躍進

79
00:03:57,790 --> 00:03:59,140
運動，這是一個啟動 - 

80
00:03:59,140 --> 00:04:01,300
這個裝置實際上只是來到
出幾個月前 - 

81
00:04:01,300 --> 00:04:05,960
慷慨捐贈30個此類設備
類盡可能多的學生，如果

82
00:04:05,960 --> 00:04:08,670
你想藉硬件
朝學期結束，並用它來

83
00:04:08,670 --> 00:04:10,390
實際的最終項目。

84
00:04:10,390 --> 00:04:11,890
他們支持的語言數量。

85
00:04:11,890 --> 00:04:16,040
他們沒有，他們沒有PHP的，所以
實現一個或多個這些研討會

86
00:04:16,040 --> 00:04:16,899
可能證明的興趣。

87
00:04:16,899 --> 00:04:19,730
和所有的人將被拍攝下來的
倘若你是不是能夠

88
00:04:19,730 --> 00:04:21,380
親自出席。

89
00:04:21,380 --> 00:04:25,000
通過時間表公佈
電子郵件作為我們鞏固客房。

90
00:04:25,000 --> 00:04:28,460
>> 最後，如果你去
projects.cs.50.net，這是一個網站

91
00:04:28,460 --> 00:04:31,450
我們維持每年我們邀請
人們從社會，教師，

92
00:04:31,450 --> 00:04:36,420
部門，人員，並且都
在CS50至外側的

93
00:04:36,420 --> 00:04:37,730
提出項目設想。

94
00:04:37,730 --> 00:04:39,050
學生群體感興趣的東西。

95
00:04:39,050 --> 00:04:40,600
部門關心的事情。

96
00:04:40,600 --> 00:04:43,990
因此，不要打開，如果你在掙扎
與你的不確定性

97
00:04:43,990 --> 00:04:46,700
自己想解決的。

98
00:04:46,700 --> 00:04:51,760
>> 所以我們推出了一個可以說是最後一次
比我們更複雜的數據結構

99
00:04:51,760 --> 00:04:53,300
在過去的幾週裡看到。

100
00:04:53,300 --> 00:04:56,550
我們一直在使用數組漂亮
高興地作為一個有用的，如果

101
00:04:56,550 --> 00:04:58,160
簡單化的數據結構。

102
00:04:58,160 --> 00:05:00,570
然後，我們介紹了這些，
當然鍊錶。

103
00:05:00,570 --> 00:05:05,470
到底是什麼東西的動機之一
引入這個數據結構？

104
00:05:05,470 --> 00:05:06,930
是嗎？

105
00:05:06,930 --> 00:05:07,250
那是什麼？

106
00:05:07,250 --> 00:05:08,080
>> 觀眾：動態大小。

107
00:05:08,080 --> 00:05:09,040
>> 大衛馬蘭：動態尺寸。

108
00:05:09,040 --> 00:05:11,890
因此，而數組中，你必須
知道它的大小時提前

109
00:05:11,890 --> 00:05:12,740
你分配。

110
00:05:12,740 --> 00:05:14,380
鍊錶，你不這樣做
要知道。

111
00:05:14,380 --> 00:05:17,610
你可以只是malloc的，或更普遍的，
增撥

112
00:05:17,610 --> 00:05:20,720
節點，可以這麼說，任何時候，你
要插入更多的數據。

113
00:05:20,720 --> 00:05:22,670
節點沒有預定的意義。

114
00:05:22,670 --> 00:05:25,580
這只是一個普通術語，描述
我們某種容器

115
00:05:25,580 --> 00:05:29,610
使用我們的數據結構存儲
一些感興趣的項目，在這個

116
00:05:29,610 --> 00:05:31,750
情況是整數。

117
00:05:31,750 --> 00:05:33,160
>> 但是總是有一個權衡。

118
00:05:33,160 --> 00:05:38,070
因此，我們得到的數據的大小動態
結構，但我們付出什麼樣的價格？

119
00:05:38,070 --> 00:05:40,040
鍊錶的缺點是什麼？

120
00:05:40,040 --> 00:05:41,006
是嗎？

121
00:05:41,006 --> 00:05:41,980
>> 觀眾：需要更多的內存。

122
00:05:41,980 --> 00:05:44,240
>> 國寶馬蘭：它需要更多的
內存，究竟怎麼了？

123
00:05:44,240 --> 00:05:46,440
>> 觀眾：[聽不清]。

124
00:05:46,440 --> 00:05:47,050
>> DAVID馬蘭：沒錯。

125
00:05:47,050 --> 00:05:50,460
所以，現在我們已經指針
額外的內存，我們以前

126
00:05:50,460 --> 00:05:53,040
並不需要，因為優勢
一個數組，當然是

127
00:05:53,040 --> 00:05:54,860
一切連片，
背靠背，

128
00:05:54,860 --> 00:05:56,380
為您提供了隨機訪問。

129
00:05:56,380 --> 00:06:00,710
因為只需使用方括號
符號，或更技術上的指針

130
00:06:00,710 --> 00:06:03,580
算術，很簡單，此外，
你可以訪問任何

131
00:06:03,580 --> 00:06:05,700
在固定時間內的元素。

132
00:06:05,700 --> 00:06:08,975
而事實上，這是一種暗示
另一個價格，我們正在與支付

133
00:06:08,975 --> 00:06:09,760
鍊錶。

134
00:06:09,760 --> 00:06:13,890
>> 會發生什麼情況的運行時間
像搜索，如果我想

135
00:06:13,890 --> 00:06:17,270
找到一些價值和內部
鍊錶？

136
00:06:17,270 --> 00:06:20,290
成為我的運行時間是什麼？

137
00:06:20,290 --> 00:06:21,560
大O的n。

138
00:06:21,560 --> 00:06:24,060
如果它的排序？

139
00:06:24,060 --> 00:06:25,440
如果數據結構的排序？

140
00:06:25,440 --> 00:06:28,640
我可以做的更好的比大
n為O的搜索？

141
00:06:28,640 --> 00:06:31,700
沒有，因為在最壞的情況下，它可能會
很好地進行排序，但數量

142
00:06:31,700 --> 00:06:32,950
你要找的可能是很大的。

143
00:06:32,950 --> 00:06:35,370
它可能是第100號，
可能發生的事情是所有

144
00:06:35,370 --> 00:06:36,410
在結束的方式。

145
00:06:36,410 --> 00:06:39,950
因為你只能訪問一個鏈接
在本實施的喜愛

146
00:06:39,950 --> 00:06:42,690
其第一個節點的方式，你
依然是那樣的運氣了。

147
00:06:42,690 --> 00:06:47,450
你必須遍歷整個事情
從第一次到最後，為了找到

148
00:06:47,450 --> 00:06:49,150
像100那麼大價值。

149
00:06:49,150 --> 00:06:51,350
或確定，如果它是
甚至沒有。

150
00:06:51,350 --> 00:06:55,960
>> 因此，我們不能做什麼算法在數據
結構看起來像這樣嗎？

151
00:06:55,960 --> 00:06:59,460
我們不能這樣做，因為二進制搜索
二進制搜索需要，我們有

152
00:06:59,460 --> 00:07:00,740
隨機訪問。

153
00:07:00,740 --> 00:07:04,500
我們只能從位置到飛躍
的位置，而無需遵循

154
00:07:04,500 --> 00:07:07,080
這些麵包屑的形式
所有這些指針。

155
00:07:07,080 --> 00:07:08,300
>> 現在，我們怎麼實現呢？

156
00:07:08,300 --> 00:07:12,830
那麼，如果我們到屏幕上，在這裡，如果
我們可以很快地重新實現此數據

157
00:07:12,830 --> 00:07:13,440
結構 - 

158
00:07:13,440 --> 00:07:15,670
我的筆跡不是所有的
在這裡，偉大的，但我們會盡力。

159
00:07:15,670 --> 00:07:22,030
所以typedef結構，什麼我
要調用這個東西在這裡？

160
00:07:22,030 --> 00:07:22,960
節點。

161
00:07:22,960 --> 00:07:24,580
因此，我將讓我們開始。

162
00:07:24,580 --> 00:07:27,860
而現在，需要將裡面的
該單獨的數據結構

163
00:07:27,860 --> 00:07:28,430
鍊錶？

164
00:07:28,430 --> 00:07:29,950
多少個字段？

165
00:07:29,950 --> 00:07:30,450
>> 所以兩個。

166
00:07:30,450 --> 00:07:31,570
一個是很容易的。

167
00:07:31,570 --> 00:07:33,050
所以INT N。

168
00:07:33,050 --> 00:07:35,930
我們可以稱之為ñ我們想要的東西，
但它應該是一個int，如果我們

169
00:07:35,930 --> 00:07:37,660
實現鍊錶為整數。

170
00:07:37,660 --> 00:07:41,920
現在什麼第二
現場有嗎？

171
00:07:41,920 --> 00:07:43,460
結構節點。

172
00:07:43,460 --> 00:07:50,570
所以，如果我做節點，然後我
可以調用這個也是我想做的事情，

173
00:07:50,570 --> 00:07:53,510
但僅僅是明確的，我會打電話
未來，因為我們一直在做的事情。

174
00:07:53,510 --> 00:07:55,270
然後我會關閉我的花括號。

175
00:07:55,270 --> 00:08:00,700
>> 而現在，作為最後一次，
我把節點。

176
00:08:00,700 --> 00:08:03,830
但是，如果我聲明，這是作為一個
節點，我為什麼懶得如此

177
00:08:03,830 --> 00:08:07,320
詳細在這裡宣布結構
節點下，而不是

178
00:08:07,320 --> 00:08:09,210
只是節點*？

179
00:08:09,210 --> 00:08:09,904
是嗎？

180
00:08:09,904 --> 00:08:12,810
>> 觀眾：[聽不清]。

181
00:08:12,810 --> 00:08:14,050
>> DAVID馬蘭：沒錯。

182
00:08:14,050 --> 00:08:14,530
沒錯。

183
00:08:14,530 --> 00:08:18,320
由於C真的需要你從字面上
只看到的定義節點

184
00:08:18,320 --> 00:08:21,230
一路下來這裡，你可以不
是指它在這裡。

185
00:08:21,230 --> 00:08:24,760
因此，我們有這種先發製人
聲明在這裡，這是無可否認

186
00:08:24,760 --> 00:08:25,390
更詳細。

187
00:08:25,390 --> 00:08:27,810
節點結構，這意味著
我們現在可以訪問它

188
00:08:27,810 --> 00:08:29,760
內部的數據結構。

189
00:08:29,760 --> 00:08:33,370
>> 順便說一句，因為這是
現在成為一個更主觀一點，

190
00:08:33,370 --> 00:08:36,230
明星可以在技術上走在這裡，
它可以去這裡，它可以

191
00:08:36,230 --> 00:08:37,179
甚至在中間。

192
00:08:37,179 --> 00:08:39,890
我們已經通過，在風格指南
當然，把公約

193
00:08:39,890 --> 00:08:42,299
星旁邊的數據
型，在這種情況下，

194
00:08:42,299 --> 00:08:43,460
將結構節點。

195
00:08:43,460 --> 00:08:46,620
但實現大量課本
在線參考，事實上，你可能會

196
00:08:46,620 --> 00:08:48,450
看到它的另一側。

197
00:08:48,450 --> 00:08:52,200
但是，僅僅實現這兩個實際上會
工作，你應該僅僅是

198
00:08:52,200 --> 00:08:52,970
一致的。

199
00:08:52,970 --> 00:08:53,580
>> 好的。

200
00:08:53,580 --> 00:08:55,630
所以這是我們的宣言
結構節點。

201
00:08:55,630 --> 00:08:59,430
但後​​來我們開始做更多
複雜的事情。

202
00:08:59,430 --> 00:09:03,410
例如，我們決定引進
如哈希表的東西。

203
00:09:03,410 --> 00:09:08,160
因此，這裡是一個哈希表大小為n，
索引從0到n的左上方

204
00:09:08,160 --> 00:09:09,690
減去1的左下角。

205
00:09:09,690 --> 00:09:11,640
這可能是一個散列
表中的任何東西。

206
00:09:11,640 --> 00:09:15,340
但我們討論了什麼事情
使用一個哈希表怎麼樣？

207
00:09:15,340 --> 00:09:18,370
存儲是什麼？

208
00:09:18,370 --> 00:09:18,800
>> 名稱。

209
00:09:18,800 --> 00:09:20,870
我們可以做名字，如
我們做了最後一次。

210
00:09:20,870 --> 00:09:22,200
真的，你可以存儲任何東西。

211
00:09:22,200 --> 00:09:24,640
我們將再次看到這
PHP和JavaScript中。

212
00:09:24,640 --> 00:09:28,550
哈希表是一個很好的瑞士排序
瑞士軍刀，允許你存儲

213
00:09:28,550 --> 00:09:33,690
幾乎任何你想要的內側
它的關聯值的鍵。

214
00:09:33,690 --> 00:09:34,770
鍵與值。

215
00:09:34,770 --> 00:09:37,800
>> 現在，在這個簡單的情況下，我們的
只是數字鍵。

216
00:09:37,800 --> 00:09:40,380
我們正在實施一個哈希
表中為一個數組。

217
00:09:40,380 --> 00:09:43,500
等鍵是0，
1，2，等等。

218
00:09:43,500 --> 00:09:47,200
因此，我們作為人類，最後決定
本週，你知道嗎，如果我們

219
00:09:47,200 --> 00:09:50,410
去商店名稱，讓我們只是
隨意，但相當合理的，

220
00:09:50,410 --> 00:09:54,680
假設Alice，一個名字，
只是索引為0。

221
00:09:54,680 --> 00:09:58,030
鮑勃，一個B的名字，將被索引
為1，等等。

222
00:09:58,030 --> 00:10:02,490
因此，我們不得不投入之間的映射，
是字符串，和散列

223
00:10:02,490 --> 00:10:04,560
的位置，這是數字的。

224
00:10:04,560 --> 00:10:07,740
>> 因此，該過程通常被稱為
哈希函數，你可以真正

225
00:10:07,740 --> 00:10:09,130
在代碼中實現它。

226
00:10:09,130 --> 00:10:12,080
如果我想實現的哈希函數
這不正是我們

227
00:10:12,080 --> 00:10:17,070
剛剛描述的從去年的時候，我可能會
聲明一個函數，它作為

228
00:10:17,070 --> 00:10:18,330
例如輸入 - 

229
00:10:18,330 --> 00:10:22,190
，讓我們做到這一點在此
屏幕在這裡。

230
00:10:22,190 --> 00:10:26,180
如果我想實現一個哈希
的功能，我可能會說，

231
00:10:26,180 --> 00:10:27,410
這樣的事情。

232
00:10:27,410 --> 00:10:29,030
>> 這將返回一個int。

233
00:10:29,030 --> 00:10:33,600
這將被稱為哈希，它是
要接受的參數是一個

234
00:10:33,600 --> 00:10:38,920
字符串，或者我們可以更恰當，
說的char *，我們會打電話給它s。

235
00:10:38,920 --> 00:10:43,840
然後這一切功能，
最終，返回一個int。

236
00:10:43,840 --> 00:10:45,990
現在，它是如何可能
不那麼清晰。

237
00:10:45,990 --> 00:10:49,510
我要實現這個沒有任何
現在形成的錯誤檢查。

238
00:10:49,510 --> 00:10:55,740
我只是一味地說，返回
無論是在s支架0，減，

239
00:10:55,740 --> 00:10:58,850
比方說，資本用分號。

240
00:10:58,850 --> 00:10:59,960
>> 完全打破。

241
00:10:59,960 --> 00:11:02,620
它並不完美，因為
一，什麼如果s是空？

242
00:11:02,620 --> 00:11:04,000
不好的事情將要發生。

243
00:11:04,000 --> 00:11:07,940
二，如果在此的第一個字母
名字是不是一個大寫字母？

244
00:11:07,940 --> 00:11:09,860
這不會變成
出。

245
00:11:09,860 --> 00:11:11,970
這可能是一個小寫字母
不是一個字母。

246
00:11:11,970 --> 00:11:15,520
所以完全改進的餘地，
但是這是基本的想法。

247
00:11:15,520 --> 00:11:19,010
>> 我們上週口頭
只是一個過程的映射愛麗絲

248
00:11:19,010 --> 00:11:23,360
0和Bob 1可以表示
當然更公式為C

249
00:11:23,360 --> 00:11:24,320
在這裡發揮作用。

250
00:11:24,320 --> 00:11:28,630
再次調用哈希，將一個字符串作為
輸入，然後莫名其妙地做一些事情

251
00:11:28,630 --> 00:11:31,020
與該輸入信號以產生一個輸出。

252
00:11:31,020 --> 00:11:34,130
不像我們的黑箱描述
長期以來，我們已經完成了。

253
00:11:34,130 --> 00:11:36,550
我不知道如何，這可能是
引擎蓋下工作。

254
00:11:36,550 --> 00:11:40,120
>> 對於問題集6，面臨的挑戰之一
是你來決定什麼

255
00:11:40,120 --> 00:11:41,920
您的哈希函數是什麼？

256
00:11:41,920 --> 00:11:45,760
這是怎麼回事，裡面那個黑
框，據推測，它會是一個

257
00:11:45,760 --> 00:11:50,380
比這更有趣一點，
肯定更容易出錯

258
00:11:50,380 --> 00:11:53,180
這個特殊的檢查比
實現。

259
00:11:53,180 --> 00:11:54,580
>> 但可能會出現問題，對不對？

260
00:11:54,580 --> 00:11:57,760
如果我們有一個數據結構，例如
一，什麼是一個問題

261
00:11:57,760 --> 00:12:01,600
你可以運行到隨著時間的推移，當您插入
越來越多的名字進入

262
00:12:01,600 --> 00:12:02,880
哈希表？

263
00:12:02,880 --> 00:12:04,630
你得到的碰撞，對不對？

264
00:12:04,630 --> 00:12:07,560
如果你有愛麗絲和亞倫，
兩個人的名字發生

265
00:12:07,560 --> 00:12:08,190
開始與A？

266
00:12:08,190 --> 00:12:11,660
這引出了一個問題，在那裡你
把第二個這樣的名字？

267
00:12:11,660 --> 00:12:15,050
>> 那麼，你可能天真地把它
鮑勃屬於的地方，但隨後鮑勃是

268
00:12:15,050 --> 00:12:17,300
擰種，如果您嘗試
插入他的名字旁邊，

269
00:12:17,300 --> 00:12:18,240
有沒有他的空間。

270
00:12:18,240 --> 00:12:21,400
所以，你不妨把鮑勃·查理在哪裡，
你能想像這個非常迅速

271
00:12:21,400 --> 00:12:23,020
下放成有點亂。

272
00:12:23,020 --> 00:12:25,600
線性的東西到底是哪裡你
只需要搜索整個事情

273
00:12:25,600 --> 00:12:28,190
尋找Alice或Bob
或亞倫查理。

274
00:12:28,190 --> 00:12:33,230
>> 因此，而不是我們提出的，而不是只
線性開放空間探測的

275
00:12:33,230 --> 00:12:36,450
橫臥在那裡，我們的名字
提出一個票友的方法。

276
00:12:36,450 --> 00:12:41,740
哈希表仍與實現
的索引數組，但數據不同的

277
00:12:41,740 --> 00:12:44,500
現在，這些指數分別為指針。

278
00:12:44,500 --> 00:12:47,360
指點一下嗎？

279
00:12:47,360 --> 00:12:48,730
鍊錶的指針。

280
00:12:48,730 --> 00:12:53,330
>> 因為召回鍊錶是
真的只是一個指針，指向一個節點，

281
00:12:53,330 --> 00:12:57,110
節點具有一個下一個域，該節點
有一個下一個域，等等。

282
00:12:57,110 --> 00:13:00,690
所以，你現在覺得這個數組
作為一個哈希表的左手側

283
00:13:00,690 --> 00:13:01,820
導致一個鍊錶。

284
00:13:01,820 --> 00:13:07,000
如果你得到一個優勢是
Alice和亞倫之間的碰撞，

285
00:13:07,000 --> 00:13:09,300
你是做什麼的
第二個這樣的人嗎？

286
00:13:09,300 --> 00:13:14,150
你只重視他或她的
端，甚至開始

287
00:13:14,150 --> 00:13:15,490
該鍊錶。

288
00:13:15,490 --> 00:13:17,340
>> 而實際上，讓我們只是麵條通過
第二。

289
00:13:17,340 --> 00:13:18,640
哪裡最有意義？

290
00:13:18,640 --> 00:13:22,060
如果我插入愛麗絲和她結束
第一的位置，然後我嘗試

291
00:13:22,060 --> 00:13:25,310
插入亞倫的名字，而且也
顯然是一個碰撞，我應該把

292
00:13:25,310 --> 00:13:27,400
他開始時
鍊錶？

293
00:13:27,400 --> 00:13:30,944
這是在那個第一的位置，
或在結束了嗎？

294
00:13:30,944 --> 00:13:31,440
>> 觀眾：[聽不清]。

295
00:13:31,440 --> 00:13:31,990
>> DAVID馬蘭：OK。

296
00:13:31,990 --> 00:13:32,490
我聽說開始。

297
00:13:32,490 --> 00:13:33,903
為什麼在開始？

298
00:13:33,903 --> 00:13:34,750
>> 觀眾：[聽不清]。

299
00:13:34,750 --> 00:13:34,940
>> DAVID馬蘭：OK。

300
00:13:34,940 --> 00:13:36,520
它是按字母順序排列的，所以這是很好的。

301
00:13:36,520 --> 00:13:37,330
這是一個很好的屬性。

302
00:13:37,330 --> 00:13:39,335
它會來救我的潛在的一段時間。

303
00:13:39,335 --> 00:13:43,290
它不會讓我做二進制搜索，但我
可能至少能夠打出來

304
00:13:43,290 --> 00:13:47,340
一個循環，如果我知道，好了，我的方式
過去亞倫將在此

305
00:13:47,340 --> 00:13:48,310
鍊錶排序。

306
00:13:48,310 --> 00:13:50,360
我沒有浪費我的時間尋找
所有的方式結束。

307
00:13:50,360 --> 00:13:51,530
所以這是合理的。

308
00:13:51,530 --> 00:13:54,710
你為什麼要插入
在碰撞的名字

309
00:13:54,710 --> 00:13:56,660
列表開始？

310
00:13:56,660 --> 00:13:57,397
那是什麼？

311
00:13:57,397 --> 00:13:58,680
>> 觀眾：[聽不清]。

312
00:13:58,680 --> 00:14:00,820
>> 國寶馬蘭：這可能需要很長一段時間
得到的列表末尾。

313
00:14:00,820 --> 00:14:02,490
而事實上，長。

314
00:14:02,490 --> 00:14:04,920
越多的名字你插入
開始，不再

315
00:14:04,920 --> 00:14:06,280
鏈要得到的。

316
00:14:06,280 --> 00:14:07,890
的時間越長，掛鉤
列表會得到什麼。

317
00:14:07,890 --> 00:14:09,420
所以，你真的只是
浪費你的時間。

318
00:14:09,420 --> 00:14:14,070
也許你更好的維護
恆定的插入時間，大O 1，

319
00:14:14,070 --> 00:14:18,470
始終把碰撞名
該鍊錶的開頭，

320
00:14:18,470 --> 00:14:21,230
而不是盡可能多擔心
關於排序。

321
00:14:21,230 --> 00:14:22,600
>> 什麼是最好的答案嗎？

322
00:14:22,600 --> 00:14:23,320
目前還不清楚。

323
00:14:23,320 --> 00:14:26,140
一種取決於什麼
分佈模式是什麼

324
00:14:26,140 --> 00:14:27,850
你的名字插入。

325
00:14:27,850 --> 00:14:29,430
這不一定
一個明顯的答案。

326
00:14:29,430 --> 00:14:33,100
但在這裡，再次
設計的機會。

327
00:14:33,100 --> 00:14:37,220
>> 因此，我們再看著這件事情，
真正的另一大機遇

328
00:14:37,220 --> 00:14:38,180
為對集6。

329
00:14:38,180 --> 00:14:41,770
與實現，如果你還沒有的話，
的Zamyla潛入這兩個哈希

330
00:14:41,770 --> 00:14:43,260
表和嘗試，更詳細。

331
00:14:43,260 --> 00:14:45,630
和視頻演練的是
嵌入在對一套規範。

332
00:14:45,630 --> 00:14:46,590
這是特里 - 

333
00:14:46,590 --> 00:14:51,670
T-R-I-E。什麼是有趣的
這是運行時間

334
00:14:51,670 --> 00:14:59,510
尋找一個名字，像麥克斯韋
最後一次，是大O是什麼？

335
00:14:59,510 --> 00:15:01,040
那是什麼？

336
00:15:01,040 --> 00:15:01,920
>> 觀眾：數字字母。

337
00:15:01,920 --> 00:15:02,550
>> 國寶馬蘭：字母數。

338
00:15:02,550 --> 00:15:03,210
我聽說了兩件事情。

339
00:15:03,210 --> 00:15:04,630
字母和恆定的時間數。

340
00:15:04,630 --> 00:15:05,540
所以，讓我們與第一。

341
00:15:05,540 --> 00:15:06,410
的字母數。

342
00:15:06,410 --> 00:15:10,195
那麼，這樣的數據結構，召回，
像一棵樹，一個家庭樹，每個

343
00:15:10,195 --> 00:15:12,860
的節點組成的數組。

344
00:15:12,860 --> 00:15:16,300
這些數組指針
其他這樣的節點，或其他這樣的

345
00:15:16,300 --> 00:15:17,670
樹中的數組。

346
00:15:17,670 --> 00:15:22,890
>> 因此，如果我們想要再確定
麥克斯韋是否是在這裡，我可能去

347
00:15:22,890 --> 00:15:26,890
第一陣列，在最頂部的
樹中，所謂的根，頂部

348
00:15:26,890 --> 00:15:30,521
特里，然後按照米指針，
然後是一個指針，那麼x，

349
00:15:30,521 --> 00:15:31,710
W，E，L，L。

350
00:15:31,710 --> 00:15:34,910
然後當我看到一些特殊的符號，
在這裡表示為三角形。

351
00:15:34,910 --> 00:15:38,480
在代碼中，你會看到我們建議您
為bool實施，只是說是

352
00:15:38,480 --> 00:15:40,540
或沒有，一個字在這裡停止。

353
00:15:40,540 --> 00:15:45,270
>> 那麼，一旦我們去參加M-à-X-W-E-L-L，
感覺就像七，也許

354
00:15:45,270 --> 00:15:48,910
八，如果我們走過去吧，八
步驟找麥克斯韋。

355
00:15:48,910 --> 00:15:53,050
還是讓我們叫它K.但記得最後
的時候，我認為，如果有

356
00:15:53,050 --> 00:15:57,540
切實的最大長度上
字，像40一些奇怪的字符，

357
00:15:57,540 --> 00:16:00,810
最大長度意味著
一個恆定值。

358
00:16:00,810 --> 00:16:05,770
所以真的，是的，這是技術上的大O
8或7，或真大O K.，但

359
00:16:05,770 --> 00:16:09,420
如果有一個有限的上限是什麼
K表，這是一個常數。

360
00:16:09,420 --> 00:16:12,080
所以它的大O 1
在一天結束時。

361
00:16:12,080 --> 00:16:13,040
>> 不是在現實世界中。

362
00:16:13,040 --> 00:16:15,960
當你真正開始看
時鐘程序的運行。

363
00:16:15,960 --> 00:16:20,690
這絕對是有點
比真正的恆定速度較慢

364
00:16:20,690 --> 00:16:21,840
時間與步驟。

365
00:16:21,840 --> 00:16:25,540
這將是七八步，
但仍然好得多

366
00:16:25,540 --> 00:16:30,080
比大O n表示這樣的算法
的大小取決於什麼

367
00:16:30,080 --> 00:16:31,220
的數據結構。

368
00:16:31,220 --> 00:16:34,970
>> 請注意，這裡的上攻，我們可以插入
百萬名到這個

369
00:16:34,970 --> 00:16:38,170
數據結構，但很多步
它是要帶我們去找到

370
00:16:38,170 --> 00:16:40,480
麥克斯韋在這種情況下？

371
00:16:40,480 --> 00:16:40,780
沒有。

372
00:16:40,780 --> 00:16:41,820
他不受影響。

373
00:16:41,820 --> 00:16:45,480
到今天為止，我不認為我們已經看到了
的一個例子的數據結構或

374
00:16:45,480 --> 00:16:48,560
完全的算法
不受外部

375
00:16:48,560 --> 00:16:50,040
這樣的行為。

376
00:16:50,040 --> 00:16:51,160
但是，這不能是驚人的。

377
00:16:51,160 --> 00:16:52,900
這不能是唯一的解決方案
對於p-集

378
00:16:52,900 --> 00:16:53,570
>> 而事實並非如此。

379
00:16:53,570 --> 00:16:55,980
這不一定是數據
結構應該吸引到，

380
00:16:55,980 --> 00:16:58,220
因為像哈希表，權衡。

381
00:16:58,220 --> 00:17:00,500
你付出的代價是什麼？

382
00:17:00,500 --> 00:17:00,940
內存。

383
00:17:00,940 --> 00:17:02,890
我的意思是，這是一個窮凶極惡
的內存量。

384
00:17:02,890 --> 00:17:05,569
你不能完全看到它，因為這裡
這幅畫的作者

385
00:17:05,569 --> 00:17:09,420
顯然截斷所有陣列
和我們沒有看到很多A的

386
00:17:09,420 --> 00:17:12,700
B的和C和Q和Y
和Z的這些數組中。

387
00:17:12,700 --> 00:17:13,630
但是，他們在那裡。

388
00:17:13,630 --> 00:17:17,660
>> 每個節點是一個整體的陣列
約26或更多的字節，每個字節

389
00:17:17,660 --> 00:17:19,170
這代表一個字母。

390
00:17:19,170 --> 00:17:22,920
在我們的案例中，這樣我們就可以支持27
單引號的問題集。

391
00:17:22,920 --> 00:17:27,030
因此，這個數據結構是真的，
非常密集和廣泛。

392
00:17:27,030 --> 00:17:30,880
這本身最終可能會放緩
下來的東西，或者至少是成本你

393
00:17:30,880 --> 00:17:32,240
更多的空間。

394
00:17:32,240 --> 00:17:34,020
但同樣，我們可以得出
這裡的比較。

395
00:17:34,020 --> 00:17:39,190
>> 回憶了一段時間後，我們取得了很大成就
更令人興奮的運行時間排序

396
00:17:39,190 --> 00:17:42,880
當我們使用歸併排序，但價格
我們實現N個記錄n為合併支付

397
00:17:42,880 --> 00:17:46,930
排序要求，我們花
什麼資源？

398
00:17:46,930 --> 00:17:47,690
更多的空間。

399
00:17:47,690 --> 00:17:50,530
我們需要一個輔助陣列
複製人，就像

400
00:17:50,530 --> 00:17:51,620
我們在這裡做的，在舞台上。

401
00:17:51,620 --> 00:17:55,880
如此反复，沒有明顯的贏家，
只是主觀設計

402
00:17:55,880 --> 00:17:57,710
作出的決定。

403
00:17:57,710 --> 00:17:58,060
>> 好的。

404
00:17:58,060 --> 00:17:59,130
因此，這個怎麼樣？

405
00:17:59,130 --> 00:18:02,050
任何人都承認，D-霍爾？

406
00:18:02,050 --> 00:18:02,440
確定。

407
00:18:02,440 --> 00:18:03,170
所以，我們三個做。

408
00:18:03,170 --> 00:18:03,750
奧美大廈。

409
00:18:03,750 --> 00:18:05,070
因此，這是奧美的餐飲。

410
00:18:05,070 --> 00:18:09,650
我敢打賭，所有食堂
這樣的托盤堆。

411
00:18:09,650 --> 00:18:11,950
這實際上是代表
的東西，我們已經

412
00:18:11,950 --> 00:18:13,050
顯然已經看到。

413
00:18:13,050 --> 00:18:14,850
我們把它稱為名副其實的堆棧。

414
00:18:14,850 --> 00:18:18,970
棧，您
計算機的內存，數據去

415
00:18:18,970 --> 00:18:20,460
當功能被調用。

416
00:18:20,460 --> 00:18:23,410
>> 例如，什麼樣的東西去
相對於在堆棧上

417
00:18:23,410 --> 00:18:27,420
我們已經討論過的內存佈局
在過去的幾週？

418
00:18:27,420 --> 00:18:28,736
那是什麼？

419
00:18:28,736 --> 00:18:29,670
>> 觀眾：函數調用。

420
00:18:29,670 --> 00:18:30,260
>> DAVID馬蘭：對不起。

421
00:18:30,260 --> 00:18:31,210
>> 觀眾：函數調用。

422
00:18:31,210 --> 00:18:33,590
>> DAVID馬蘭：通話功能，但
具體而言，每個裡面有什麼

423
00:18:33,590 --> 00:18:35,340
這些幀？

424
00:18:35,340 --> 00:18:37,220
什麼樣的東西呢？

425
00:18:37,220 --> 00:18:37,460
嗯。

426
00:18:37,460 --> 00:18:38,500
因此，局部變量。

427
00:18:38,500 --> 00:18:43,080
任何時候，我們需要一些本地存儲，
像一個說法，或INT I，或int

428
00:18:43,080 --> 00:18:45,940
溫度，或任何地方
變量，我們已經

429
00:18:45,940 --> 00:18:47,210
將在堆棧上。

430
00:18:47,210 --> 00:18:49,610
我們稱之為堆棧，因為
該分層想法。

431
00:18:49,610 --> 00:18:52,940
的比賽只是一種現實，
其概念。

432
00:18:52,940 --> 00:18:56,650
>> 但事實證明，一摞還可以
被看作是一個數據結構，一個

433
00:18:56,650 --> 00:19:00,110
替代一個數組，另一種
鍊錶。

434
00:19:00,110 --> 00:19:02,770
概念上的東西更有趣
仍然可以

435
00:19:02,770 --> 00:19:06,030
那些採用
的東西，但它是一個不同類型的

436
00:19:06,030 --> 00:19:09,140
數據結構的支持，真的，
只有兩個操作。

437
00:19:09,140 --> 00:19:11,000
但是，您可以添加票友
功能不止這些。

438
00:19:11,000 --> 00:19:12,180
但這些都是基礎知識 - 

439
00:19:12,180 --> 00:19:13,510
push和pop。

440
00:19:13,510 --> 00:19:19,240
>> 用棧的想法是，如果我
這裡有，帶或不帶安南伯格

441
00:19:19,240 --> 00:19:22,880
知道，一個托盤從隔壁
數字9就可以了。

442
00:19:22,880 --> 00:19:23,870
所以只是一個int。

443
00:19:23,870 --> 00:19:26,990
我要推到數據
結構，目前是空的。

444
00:19:26,990 --> 00:19:28,790
考慮這個堆棧的底部。

445
00:19:28,790 --> 00:19:33,150
我會推到9號
堆疊，而現在它就在那裡。

446
00:19:33,150 --> 00:19:36,040
>> 但有趣的關於堆棧
是，如果我現在要推

447
00:19:36,040 --> 00:19:40,210
其他一些值，比如17，我推
入堆棧，我要做的事情

448
00:19:40,210 --> 00:19:43,290
直觀的東西，我只是
說得不對，我們人類

449
00:19:43,290 --> 00:19:45,180
會傾向於把它之上。

450
00:19:45,180 --> 00:19:48,850
但是，什麼是有趣
，我怎麼在9？

451
00:19:48,850 --> 00:19:50,670
你知道，我不是沒有做一些努力。

452
00:19:50,670 --> 00:19:54,070
>> 那麼，什麼是有趣的
堆棧，設計，

453
00:19:54,070 --> 00:19:56,330
這是一個後進先出的數據結構。

454
00:19:56,330 --> 00:19:59,680
傻的方式描述
後進先出。

455
00:19:59,680 --> 00:20:03,280
所以最後一個數字
在這個時候的時間是17。

456
00:20:03,280 --> 00:20:07,540
所以，如果我想流行的東西
棧，它只能是17。

457
00:20:07,540 --> 00:20:11,890
所以這是一個強制性的順序
這裡的操作，其中的最後一個項目

458
00:20:11,890 --> 00:20:14,260
在成為第一個出。

459
00:20:14,260 --> 00:20:16,440
因此，首字母縮寫詞，後進先出法。

460
00:20:16,440 --> 00:20:19,160
>> 那麼，為什麼會這樣有用嗎？

461
00:20:19,160 --> 00:20:22,690
是的語境中，你
我想這樣的一個數據結構？

462
00:20:22,690 --> 00:20:24,810
那麼，它肯定是有用的
內的一台計算機。

463
00:20:24,810 --> 00:20:29,050
所以操作系統顯然使用此
一種數據結構棧。

464
00:20:29,050 --> 00:20:32,800
我們還會看到同樣的想法
當它涉及到網頁。

465
00:20:32,800 --> 00:20:35,890
因此，本週和下週超越，
而當你開始實現Web

466
00:20:35,890 --> 00:20:39,490
稱為HTML頁面的語言，你可以
實際使用的數據結構，如

467
00:20:39,490 --> 00:20:42,690
這是為了確定的頁面
是正確的格式。

468
00:20:42,690 --> 00:20:47,170
因為我們會看到所有的網頁遵循
一種層次，壓痕

469
00:20:47,170 --> 00:20:52,030
在一天結束時，將是
引擎蓋下的樹結構。

470
00:20:52,030 --> 00:20:53,620
所以，更多的只是一點點。

471
00:20:53,620 --> 00:20:56,560
>> 但現在，讓我們提出一個
此刻，我們怎麼可能去

472
00:20:56,560 --> 00:20:58,830
相當於一個堆棧是什麼？

473
00:20:58,830 --> 00:21:03,370
最後，我提議，我們實施
像這樣的代碼堆棧。

474
00:21:03,370 --> 00:21:07,990
因此，堆棧裡面它都將有
兩件事情，一個數組，稱為托盤

475
00:21:07,990 --> 00:21:09,510
只是要符合演示。

476
00:21:09,510 --> 00:21:12,660
和該陣列中的每個項目
將是一個int類型的。

477
00:21:12,660 --> 00:21:14,740
和能力大概是什麼？

478
00:21:14,740 --> 00:21:18,796
因為我沒有寫
這裡完整定義。

479
00:21:18,796 --> 00:21:21,535
>> 這可能是最大的
數組的大小。

480
00:21:21,535 --> 00:21:25,150
而且它可能急劇宣布
上面的文件頂部的定義，一些

481
00:21:25,150 --> 00:21:28,450
所隱含類型的常量
單純的資本。

482
00:21:28,450 --> 00:21:32,250
所以某處容量定義
作為可能的最大尺寸。

483
00:21:32,250 --> 00:21:35,590
同時，內部的數據結構
被稱為一個堆棧將有

484
00:21:35,590 --> 00:21:38,630
只是一個整數
只是作為大小。

485
00:21:38,630 --> 00:21:43,400
>> 所以，如果我現在代表這
形象，讓我們假設，這

486
00:21:43,400 --> 00:21:48,070
全黑方塊代表我的籌碼。

487
00:21:48,070 --> 00:21:50,070
在它的內部有兩個變量。

488
00:21:50,070 --> 00:21:54,780
所以我要畫
第一個作為大小。

489
00:21:54,780 --> 00:21:57,420
第二個我要去
以畫為一個數組。

490
00:21:57,420 --> 00:22:01,060
>> 但只是為了讓事情變得有序，
通常我會畫一個像數組

491
00:22:01,060 --> 00:22:04,910
這一點，但它是一種很好的
如果我們匹配的現實，或

492
00:22:04,910 --> 00:22:06,230
相匹配的心智模式。

493
00:22:06,230 --> 00:22:12,880
所以，讓我來代替數組繪製
垂直，這僅僅是再次，

494
00:22:12,880 --> 00:22:13,840
藝術家的演繹。

495
00:22:13,840 --> 00:22:16,610
並不真正的問題是什麼呢
引擎蓋下。

496
00:22:16,610 --> 00:22:20,350
我們會說，在默認情況下，
容量將是三個。

497
00:22:20,350 --> 00:22:23,480
因此，這將是位置0，這
將位置1，本

498
00:22:23,480 --> 00:22:25,740
將位置2。

499
00:22:25,740 --> 00:22:29,330
>> 如果我賄賂應力球，
有人想拿出並運行

500
00:22:29,330 --> 00:22:30,870
登上這裡只是一瞬間嗎？

501
00:22:30,870 --> 00:22:31,960
OK，首先看到你的手。

502
00:22:31,960 --> 00:22:33,950
上來吧。

503
00:22:33,950 --> 00:22:36,500
好的。

504
00:22:36,500 --> 00:22:38,760
所以我相信這是史蒂芬。

505
00:22:38,760 --> 00:22:40,035
上來吧。

506
00:22:40,035 --> 00:22:40,770
好的。

507
00:22:40,770 --> 00:22:46,760
>> 但是，假定現在我們後退到初始
世界的狀態，我

508
00:22:46,760 --> 00:22:52,180
剛剛宣布堆棧，它是
將是三能力。

509
00:22:52,180 --> 00:22:54,470
但規模尚未確定。

510
00:22:54,470 --> 00:22:56,100
托盤尚未確定。

511
00:22:56,100 --> 00:22:57,300
因此，一對夫婦的問題先。

512
00:22:57,300 --> 00:23:01,310
讓我給你話筒，這樣你就可以
更積極參加。

513
00:23:01,310 --> 00:23:05,190
>> 那麼，什麼是大小裡面在這一刻
如果所有我做過的時間

514
00:23:05,190 --> 00:23:09,340
宣布棧
一行代碼？

515
00:23:09,340 --> 00:23:10,100
>> 史蒂芬：不多。

516
00:23:10,100 --> 00:23:12,080
>> 國寶MALAN：OK，不多。

517
00:23:12,080 --> 00:23:14,410
大家知不知道裡面有什麼大小，
我們不知道裡面有什麼

518
00:23:14,410 --> 00:23:16,330
這個數組在這裡？

519
00:23:16,330 --> 00:23:18,630
>> 史蒂芬：隨機碼，對不對？

520
00:23:18,630 --> 00:23:20,220
只是 - 

521
00:23:20,220 --> 00:23:23,230
>> 國寶馬蘭：是的，我要
調用它的代碼，但隨機 - 

522
00:23:23,230 --> 00:23:23,820
>> 史蒂芬：事情。

523
00:23:23,820 --> 00:23:28,290
>> 國寶馬蘭：就像是隨機的事情

524
00:23:28,290 --> 00:23:28,870
>> 史蒂芬：位。

525
00:23:28,870 --> 00:23:29,530
>> 國寶MALAN：位，對不對？

526
00:23:29,530 --> 00:23:31,190
因此，垃圾值，對不對？

527
00:23:31,190 --> 00:23:33,470
因此，0和1的排列。

528
00:23:33,470 --> 00:23:35,920
以前的慣例遺跡
此內存。

529
00:23:35,920 --> 00:23:38,150
我們真的不知道什麼值
，所以我們通常吸引他們

530
00:23:38,150 --> 00:23:38,930
問號。

531
00:23:38,930 --> 00:23:41,990
>> 所以，首先我們推測
想在這裡做 - 

532
00:23:41,990 --> 00:23:46,630
讓我給這個領域裡面
有一個名字 - 托盤。

533
00:23:46,630 --> 00:23:49,540
我們應該怎麼想必初始化
如果我們想大小

534
00:23:49,540 --> 00:23:51,040
開始使用該協議棧？

535
00:23:51,040 --> 00:23:53,070
>> 史蒂芬：紙盒子3。

536
00:23:53,070 --> 00:23:53,910
>> 國寶馬蘭：那麼，“確定”。

537
00:23:53,910 --> 00:23:56,710
很明顯，容量聲明
其他地方為三個。

538
00:23:56,710 --> 00:23:58,570
而這正是我用過
分配數組。

539
00:23:58,570 --> 00:24:03,535
大小要參閱多少
盤目前在棧上。

540
00:24:03,535 --> 00:24:03,880
>> 史蒂芬：零。

541
00:24:03,880 --> 00:24:04,460
>> DAVID馬蘭，因此，它應該是零。

542
00:24:04,460 --> 00:24:07,760
因此，繼續前進，並與任何手指，
大小繪製一個零。

543
00:24:07,760 --> 00:24:08,440
好的。

544
00:24:08,440 --> 00:24:10,920
所以，現在，這裡面有什麼
在這裡，我們不知道。

545
00:24:10,920 --> 00:24:12,160
這些真的只是垃圾值。

546
00:24:12,160 --> 00:24:14,800
因此，我們可以得出問號，但
讓我們保持板面乾淨

547
00:24:14,800 --> 00:24:16,300
因為它並不重要
那裡有什麼。

548
00:24:16,300 --> 00:24:19,130
我們不需要初始化數組
什麼，因為如果我們知道，

549
00:24:19,130 --> 00:24:23,100
堆棧的大小是零，好，我們
不應被看什麼

550
00:24:23,100 --> 00:24:25,590
反正在這個數組
這個時間點。

551
00:24:25,590 --> 00:24:29,970
>> 所以，現在想我推
數9入堆棧。

552
00:24:29,970 --> 00:24:33,750
我們應該如何更新數據結構
這個黑盒子裡面？

553
00:24:33,750 --> 00:24:35,540
什麼樣的價值觀需要改變嗎？

554
00:24:35,540 --> 00:24:36,200
>> 史蒂芬： - 

555
00:24:36,200 --> 00:24:37,400
大小？

556
00:24:37,400 --> 00:24:37,650
>> DAVID馬蘭：OK。

557
00:24:37,650 --> 00:24:38,770
大小應該變成什麼樣？

558
00:24:38,770 --> 00:24:39,580
>> 史蒂芬：大小將是一個。

559
00:24:39,580 --> 00:24:39,870
>> DAVID馬蘭：OK。

560
00:24:39,870 --> 00:24:41,110
因此，大小應成為一體。

561
00:24:41,110 --> 00:24:42,540
所以你可以在一對夫婦的方式做到這一點。

562
00:24:42,540 --> 00:24:46,920
讓我給你，現在你的
手指是一個橡皮擦。

563
00:24:46,920 --> 00:24:47,260
好的。

564
00:24:47,260 --> 00:24:49,960
那麼現在你的手指一刷。

565
00:24:49,960 --> 00:24:50,330
好的。

566
00:24:50,330 --> 00:24:52,820
現在有什麼改變，
很明顯，在數據結構中？

567
00:24:52,820 --> 00:24:57,060
>> 史蒂芬：我們打算從
底部9。

568
00:24:57,060 --> 00:24:57,760
>> 國寶馬蘭：9。

569
00:24:57,760 --> 00:24:58,420
好，好。

570
00:24:58,420 --> 00:25:01,550
所以還是什麼都無所謂的
一個或兩個位置，因為他們是

571
00:25:01,550 --> 00:25:04,520
垃圾值，但我們不應該打擾
因為大小是尋找

572
00:25:04,520 --> 00:25:07,540
告訴我們，只有第一個元素
實際上是合法的。

573
00:25:07,540 --> 00:25:10,400
所以現在我推17到列表中。

574
00:25:10,400 --> 00:25:11,830
這個畫面會發生什麼事？

575
00:25:11,830 --> 00:25:14,720
>> 史蒂芬：那麼大小是要去兩個。

576
00:25:14,720 --> 00:25:15,300
>> DAVID馬蘭：OK。

577
00:25:15,300 --> 00:25:16,070
你橡皮擦 - 

578
00:25:16,070 --> 00:25:16,810
哎呀。

579
00:25:16,810 --> 00:25:18,026
你是一個橡皮擦。

580
00:25:18,026 --> 00:25:18,840
>> 史蒂芬：橡皮擦。

581
00:25:18,840 --> 00:25:19,720
>> DAVID馬蘭：你刷。

582
00:25:19,720 --> 00:25:20,560
>> 史蒂芬：刷機。

583
00:25:20,560 --> 00:25:20,920
>> DAVID馬蘭：OK。

584
00:25:20,920 --> 00:25:21,600
還有什麼？

585
00:25:21,600 --> 00:25:22,600
>> 史蒂芬：那麼，我們 - 

586
00:25:22,600 --> 00:25:22,915
>> 國寶馬蘭：我們推17。

587
00:25:22,915 --> 00:25:24,760
>> 史蒂芬：我們堅持17之上，所以 - 

588
00:25:24,760 --> 00:25:25,710
>> 國寶馬蘭：OK，好。

589
00:25:25,710 --> 00:25:27,040
>> 史蒂芬 - 砸下來。

590
00:25:27,040 --> 00:25:27,530
>> 國寶馬蘭所有權利。

591
00:25:27,530 --> 00:25:27,940
它變得容易。

592
00:25:27,940 --> 00:25:29,300
我不會幫你這個時候。

593
00:25:29,300 --> 00:25:30,510
推22。

594
00:25:30,510 --> 00:25:31,720
>> 史蒂芬：完成。

595
00:25:31,720 --> 00:25:34,870
成為一個橡皮擦。

596
00:25:34,870 --> 00:25:37,340
我成為一刷。

597
00:25:37,340 --> 00:25:39,340
然後我把22。

598
00:25:39,340 --> 00:25:40,100
>> 國寶馬蘭：22。

599
00:25:40,100 --> 00:25:40,620
優秀的。

600
00:25:40,620 --> 00:25:41,380
所以有更多的時間。

601
00:25:41,380 --> 00:25:44,280
我現在要推
入堆棧26。

602
00:25:44,280 --> 00:25:46,350
>> 史蒂芬：哦。

603
00:25:46,350 --> 00:25:50,278
噢，天哪。

604
00:25:50,278 --> 00:25:52,520
你真的讓我猝不及防。

605
00:25:52,520 --> 00:25:53,703
>> 國寶馬蘭：你也沒
看到這一切嗎？

606
00:25:53,703 --> 00:25:55,930
>> 史蒂芬：我沒有看到這一切。

607
00:25:55,930 --> 00:25:58,756
我們可以重新初始容量？

608
00:25:58,756 --> 00:25:59,790
>> DAVID馬蘭：這是一個很好的問題。

609
00:25:59,790 --> 00:26:02,360
所以我們自己畫
這裡的一個角落裡。

610
00:26:02,360 --> 00:26:06,740
史蒂芬真的是沒有利好出盡
因為我們這個數組分配

611
00:26:06,740 --> 00:26:09,130
靜態的，可以這麼說，裡面
的數據結構。

612
00:26:09,130 --> 00:26:12,170
我們已經基本上硬編碼
它是大小為3。

613
00:26:12,170 --> 00:26:14,170
因此，我們不能真的重新分配。

614
00:26:14,170 --> 00:26:20,020
>> 我們可以，如果我們回去，我們
重新定義托盤是一個指針，

615
00:26:20,020 --> 00:26:22,300
然後，我們使用malloc手的內存。

616
00:26:22,300 --> 00:26:25,050
因為如果我們得到了內存
通過malloc堆，

617
00:26:25,050 --> 00:26:26,430
然後釋放它。

618
00:26:26,430 --> 00:26:29,630
但在此之前，我們可以釋放它
重新分配一個更大的內存塊，

619
00:26:29,630 --> 00:26:31,330
更新指針，等等。

620
00:26:31,330 --> 00:26:33,500
但現在，這是真的
最好的，我們能做到。

621
00:26:33,500 --> 00:26:36,360
push和pop大概是
有一些錯誤的信號。

622
00:26:36,360 --> 00:26:40,270
>> 因此，舉例來說，我們實施
推可以返回一個布爾值

623
00:26:40,270 --> 00:26:42,390
以前返回真實的，真實的，真實的。

624
00:26:42,390 --> 00:26:48,390
但第四次，這將有
返回false，例如。

625
00:26:48,390 --> 00:26:48,540
好的。

626
00:26:48,540 --> 00:26:49,540
非常出色。

627
00:26:49,540 --> 00:26:50,060
恭喜。

628
00:26:50,060 --> 00:26:52,160
你賺你的壓力，今天的球。

629
00:26:52,160 --> 00:26:53,110
>> [掌聲]

630
00:26:53,110 --> 00:26:54,382
>> 史蒂芬：謝謝。

631
00:26:54,382 --> 00:26:55,680
>> DAVID馬蘭：謝謝你。

632
00:26:55,680 --> 00:26:59,740
OK，所以這似乎是沒有太大的
向前邁進了一步，對不對？

633
00:26:59,740 --> 00:27:01,410
我們描述的數據結構。

634
00:27:01,410 --> 00:27:02,320
這是令人信服的，對不對？

635
00:27:02,320 --> 00:27:03,200
操作系統喜歡它。

636
00:27:03,200 --> 00:27:06,360
顯然，網絡可以利用這個
和其他應用程序依舊。

637
00:27:06,360 --> 00:27:10,870
但是我們是一個愚蠢的限制
備份排序本週二的限制

638
00:27:10,870 --> 00:27:12,880
我們有固定大小的數組。

639
00:27:12,880 --> 00:27:15,010
>> 所以，確實有一對夫婦
方法我們可以解決這個問題。

640
00:27:15,010 --> 00:27:18,750
我們可以動態分配的數組，
不是由硬編碼我

641
00:27:18,750 --> 00:27:22,600
在這裡完成的，而是重新申報
這一點，只是很清楚，

642
00:27:22,600 --> 00:27:23,830
這樣的事情。

643
00:27:23,830 --> 00:27:29,040
詮釋*托盤，而不是決定
尚未容量。

644
00:27:29,040 --> 00:27:35,460
但是，當我宣布堆棧別處
在我的代碼，然後，我可以調用malloc，

645
00:27:35,460 --> 00:27:38,250
得到一個塊的地址
內存和I可以分配

646
00:27:38,250 --> 00:27:39,980
該地址托盤。

647
00:27:39,980 --> 00:27:43,340
>> 然後，因為它只是一大塊
的記憶，我可以繼續使用方

648
00:27:43,340 --> 00:27:45,450
括號表示法在通常的方式。

649
00:27:45,450 --> 00:27:49,020
這還是因為同樣的原因，有此排序
陣列和功能上等同於

650
00:27:49,020 --> 00:27:50,820
的內存塊來
從malloc。

651
00:27:50,820 --> 00:27:53,090
我們可以把一個像其他
使用指針運算或

652
00:27:53,090 --> 00:27:54,440
方括號。

653
00:27:54,440 --> 00:27:55,660
所以這是一種方法。

654
00:27:55,660 --> 00:28:00,120
>> 但是，是怎麼回事，我們可能會實現這個
相同的數據結構，有可能？

655
00:28:00,120 --> 00:28:00,280
對嗎？

656
00:28:00,280 --> 00:28:04,530
我覺得像我們剛剛解決了這個
一個星期前的問題。

657
00:28:04,530 --> 00:28:08,860
這是解決這個問題的
史蒂芬跑進？

658
00:28:08,860 --> 00:28:10,370
所以，鍊錶，對吧。

659
00:28:10,370 --> 00:28:13,410
>> 問題是，如果我們畫
自己分配到一個角落裡

660
00:28:13,410 --> 00:28:17,580
提前內存太少，我們
然後以某種方式處理，很好，

661
00:28:17,580 --> 00:28:19,880
為什麼不乾脆避免這種情況
共發出？

662
00:28:19,880 --> 00:28:26,170
為什麼不乾脆宣布托盤是一個
指針指向一個節點，因此一個鍊錶，

663
00:28:26,170 --> 00:28:30,740
然後簡單地分配新的節點
每次史蒂芬需要，以適應

664
00:28:30,740 --> 00:28:32,400
成的數據結構的數目。

665
00:28:32,400 --> 00:28:34,200
>> 所以畫面將不得不改變。

666
00:28:34,200 --> 00:28:38,220
它不會是清潔和
簡單，只是三個整數的數組。

667
00:28:38,220 --> 00:28:42,970
現在，它的將是一個指針，指向
結構，該結構是要

668
00:28:42,970 --> 00:28:44,830
有一個int和一個next指針。

669
00:28:44,830 --> 00:28:47,670
這將導致通過該指針
另一個這樣的結構

670
00:28:47,670 --> 00:28:48,600
另一個這樣的結構。

671
00:28:48,600 --> 00:28:50,560
所以圖片實際上會
得到一個有些混亂。

672
00:28:50,560 --> 00:28:52,950
我們早就箭頭搭售
一切融合在一起。

673
00:28:52,950 --> 00:28:55,280
>> 但是，這是罰款，正確的，因為
我們已經看到了如何做到這一點。

674
00:28:55,280 --> 00:28:58,180
一旦你得到舒適
實施類似一個鏈接

675
00:28:58,180 --> 00:29:01,450
列表，你就必須做，如果你
選擇實現一個哈希表

676
00:29:01,450 --> 00:29:05,120
單獨鏈接的p組6，你可以
使用它作為一個構建塊，或

677
00:29:05,120 --> 00:29:08,870
成分，或在Scratch說話，
程序的東西，你說，你

678
00:29:08,870 --> 00:29:12,560
創建了自己的一塊拼圖
然後，你可以重複使用。

679
00:29:12,560 --> 00:29:17,090
所以權衡，但潛在的解決方案
我們實際上已經看到過。

680
00:29:17,090 --> 00:29:20,560
>> 所以很多時候，你看到每
一年或兩年，當蘋果發布

681
00:29:20,560 --> 00:29:23,060
一些新的東西，所有的瘋狂的人
外面排隊的蘋果

682
00:29:23,060 --> 00:29:27,050
商店買他們的邊際
在硬件升級。

683
00:29:27,050 --> 00:29:30,420
我這樣說，這是確定的，因為
我的那些人之一。

684
00:29:30,420 --> 00:29:35,140
那麼什麼樣的數據結構
可能代表這個現實嗎？

685
00:29:35,140 --> 00:29:36,980
>> 好吧，我們姑且稱之為一個隊列，一條線。

686
00:29:36,980 --> 00:29:40,270
因此，英國會調用它通常是
反正排隊，所以這是一個好聽的名字。

687
00:29:40,270 --> 00:29:44,960
而且，這兩個操作，一個隊列
應支持，我們會叫排隊

688
00:29:44,960 --> 00:29:48,900
操作和出隊操作，
這兩種相近的

689
00:29:48,900 --> 00:29:50,120
push和pop的精神。

690
00:29:50,120 --> 00:29:54,060
這只是形式的不同
慣例，我們調用這些。

691
00:29:54,060 --> 00:29:57,680
但排隊的東西意味著添加
或插入的數據結構。

692
00:29:57,680 --> 00:29:59,570
出列意味著將其刪除。

693
00:29:59,570 --> 00:30:05,170
但是，而堆棧是一個後進先出的數據
結構，隊列是先入

694
00:30:05,170 --> 00:30:06,740
先出的數據結構。

695
00:30:06,740 --> 00:30:10,050
>> 如果你是行的第一人，
你將是第一人獲得

696
00:30:10,050 --> 00:30:12,420
脫節和購買新設備。

697
00:30:12,420 --> 00:30:18,070
試想一下，這些人會如何心煩
如果蘋果，而不是用一個堆棧，

698
00:30:18,070 --> 00:30:21,250
比如，實行採摘
組成你的新玩具。

699
00:30:21,250 --> 00:30:24,310
所以隊列有意義，當然，
我們能想到的各種

700
00:30:24,310 --> 00:30:27,480
應用程序，想必，隊列，
尤其是當你要公平。

701
00:30:27,480 --> 00:30:30,040
那麼，我們怎麼可能實現這些
作為一個數據結構？

702
00:30:30,040 --> 00:30:33,680
>> 好吧，我建議，我們可能
需要做的是這種方式。

703
00:30:33,680 --> 00:30:35,225
所以我打算到現在已經有數字。

704
00:30:35,225 --> 00:30:38,190
因此，我們將保持它的簡單，而不是
不一定談托盤。

705
00:30:38,190 --> 00:30:40,220
只是數字，人們得到。

706
00:30:40,220 --> 00:30:43,760
容量是怎麼回事，再次修復
人的總數，可以在

707
00:30:43,760 --> 00:30:46,900
這條線，三個或
任何其他值。

708
00:30:46,900 --> 00:30:50,760
>> 不過，我建議，我需要跟踪
的大小不僅

709
00:30:50,760 --> 00:30:52,370
隊列中，有多少東西都在裡面了。

710
00:30:52,370 --> 00:30:56,310
因此，大小是電流大小，容量
是的最大尺寸。

711
00:30:56,310 --> 00:30:58,540
又一次的，命名
按照慣例。

712
00:30:58,540 --> 00:31:03,680
為什麼我需要一個額外的int裡面
隊列來跟踪誰在

713
00:31:03,680 --> 00:31:05,365
前面的行嗎？

714
00:31:05,365 --> 00:31:07,930

715
00:31:07,930 --> 00:31:10,910
為什麼我需要做的，在這種情況呢？

716
00:31:10,910 --> 00:31:14,750

717
00:31:14,750 --> 00:31:16,190
>> 好了，這是怎麼圖片
要改變呢？

718
00:31:16,190 --> 00:31:19,280
我也許可以重用
這張圖片。

719
00:31:19,280 --> 00:31:21,480
讓我繼續前進，抹去了這裡。

720
00:31:21,480 --> 00:31:24,580
我們會給這個稍微
不同的名字在這裡。

721
00:31:24,580 --> 00:31:28,930
讓我們擺脫了17，讓我們擺脫
9，讓我們擺脫了3。

722
00:31:28,930 --> 00:31:30,410
讓的添加另一件事。

723
00:31:30,410 --> 00:31:34,710
我提議由我需要跟踪
列表的前面，這僅僅是

724
00:31:34,710 --> 00:31:35,570
將是一個int。

725
00:31:35,570 --> 00:31:36,550
我們要保持它的簡單。

726
00:31:36,550 --> 00:31:37,740
現在沒有鍊錶。

727
00:31:37,740 --> 00:31:40,900
>> 我們得承認，我們要
顛簸起來反對這個限制。

728
00:31:40,900 --> 00:31:43,720
但什麼我想看看
發生這個時間呢？

729
00:31:43,720 --> 00:31:47,240
因此，假設我繼續前進，第一
人來了線，

730
00:31:47,240 --> 00:31:48,560
它是9號。

731
00:31:48,560 --> 00:31:49,680
我們確實有壓力球。

732
00:31:49,680 --> 00:31:51,330
我可以說，偷兩三人？

733
00:31:51,330 --> 00:31:52,690
一，二，三？

734
00:31:52,690 --> 00:31:53,120
上來吧。

735
00:31:53,120 --> 00:31:56,022
從正面看，由於
我們會讓這個快。

736
00:31:56,022 --> 00:31:59,415
>> 現在你們每個人將要
線蘋果的風扇男孩。

737
00:31:59,415 --> 00:32:03,970

738
00:32:03,970 --> 00:32:06,210
你會不會接受蘋果的硬件
這雖然結束。

739
00:32:06,210 --> 00:32:06,500
好的。

740
00:32:06,500 --> 00:32:09,430
所以，你是9號，你
17號，22號。

741
00:32:09,430 --> 00:32:12,130
這些都是任意數字，如
學生ID或諸如此類的東西。

742
00:32:12,130 --> 00:32:14,550
在短短的時刻，讓我們開始
開始添加的東西。

743
00:32:14,550 --> 00:32:16,000
我要跑董事會這次在這裡。

744
00:32:16,000 --> 00:32:19,570
>> 因此，在這種情況下，我已經初始化
前面是 - 

745
00:32:19,570 --> 00:32:22,380
其實，我真的不關心什麼
前面，因為大小為零。

746
00:32:22,380 --> 00:32:24,480
因此，這可能也只是
是一個問號。

747
00:32:24,480 --> 00:32:26,170
這些都是問號。

748
00:32:26,170 --> 00:32:29,880
所以，現在我們將開始看到一些
排隊的人在店裡。

749
00:32:29,880 --> 00:32:33,320
>> 9號，所以如果你是第一個
凌晨5點，提前去排隊，

750
00:32:33,320 --> 00:32:34,210
或前一天晚上。

751
00:32:34,210 --> 00:32:34,580
確定。

752
00:32:34,580 --> 00:32:35,940
所以，現在9號是在這裡。

753
00:32:35,940 --> 00:32:37,940
因此，圖9是列表的前面。

754
00:32:37,940 --> 00:32:41,440
所以我要繼續前進，並更新
這個電流的大小的數據

755
00:32:41,440 --> 00:32:44,740
結構不能為0了，
但為1。

756
00:32:44,740 --> 00:32:47,630
我打算把9日
列表的前面。

757
00:32:47,630 --> 00:32:51,020
讓我繼續前進，切換屏幕
所以我們可以看到過去我們在這裡。

758
00:32:51,020 --> 00:32:53,220
>> 現在，我想要什麼
放在前面？

759
00:32:53,220 --> 00:32:56,240
我要跟踪
現在前面的隊列

760
00:32:56,240 --> 00:32:58,570
是在位置0。

761
00:32:58,570 --> 00:33:00,510
因為接下來會發生什麼呢？

762
00:33:00,510 --> 00:33:03,000
好吧，我想現在排隊
17。

763
00:33:03,000 --> 00:33:04,510
因此第一跳有線。

764
00:33:04,510 --> 00:33:07,060
再次，那種門
店會到這裡來。

765
00:33:07,060 --> 00:33:08,700
所以，現在我已經增加了17。

766
00:33:08,700 --> 00:33:10,810
即使這些傢伙堵
在屏幕上，這是確定的，

767
00:33:10,810 --> 00:33:12,300
因為我們可以看到它在這裡。

768
00:33:12,300 --> 00:33:12,910
抱歉。

769
00:33:12,910 --> 00:33:13,810
>> 觀眾：我們可以移動 - 

770
00:33:13,810 --> 00:33:14,660
>> 國寶馬蘭：沒有，這是確定的。

771
00:33:14,660 --> 00:33:16,000
在那裡，這是巨大的。

772
00:33:16,000 --> 00:33:18,580
因此，圖17是內部的隊列。

773
00:33:18,580 --> 00:33:21,332
我需要更新哪些
現在雖然領域呢？

774
00:33:21,332 --> 00:33:23,210
OK，絕對大小。

775
00:33:23,210 --> 00:33:26,430
關於前呢？

776
00:33:26,430 --> 00:33:27,040
OK，沒。

777
00:33:27,040 --> 00:33:30,200
前不應該改變，因為
不同的堆棧，我們

778
00:33:30,200 --> 00:33:31,370
要維護公平。

779
00:33:31,370 --> 00:33:35,150
因此，如果9排在第一，我們希望9
成為第一個出列

780
00:33:35,150 --> 00:33:36,420
進店。

781
00:33:36,420 --> 00:33:37,220
>> 事實上，讓我們看到。

782
00:33:37,220 --> 00:33:42,235
之前，我們插入22，讓我們
繼續前進，出隊9。

783
00:33:42,235 --> 00:33:42,970
你叫什麼名字呢？

784
00:33:42,970 --> 00:33:43,680
>> 觀眾：傑克。

785
00:33:43,680 --> 00:33:45,440
>> 國寶馬蘭：傑克是怎麼回事
現在被出列。

786
00:33:45,440 --> 00:33:48,050
所以你走進商店。

787
00:33:48,050 --> 00:33:49,880
並假裝商店
在那邊。

788
00:33:49,880 --> 00:33:51,970
所以，現在需要什麼 - 二叔DIT-dit的！

789
00:33:51,970 --> 00:33:53,400
什麼需要現在發生？

790
00:33:53,400 --> 00:33:54,490
設計決定。

791
00:33:54,490 --> 00:33:56,825
所以不是一個壞的本能，但 - 
你叫什麼名字呢？

792
00:33:56,825 --> 00:33:57,090
>> 觀眾：大衛。

793
00:33:57,090 --> 00:33:57,500
>> 大衛DAVID馬蘭。

794
00:33:57,500 --> 00:33:58,810
所以，大衛做了什麼？

795
00:33:58,810 --> 00:34:02,590
他試圖修復數據排序
從他的位置的結構和移動

796
00:34:02,590 --> 00:34:04,100
進入Jake的前位置。

797
00:34:04,100 --> 00:34:06,740
這很好，如果我們願意
接受，作為一個

798
00:34:06,740 --> 00:34:08,199
實施細節。

799
00:34:08,199 --> 00:34:11,100
但首先，讓我們來更新數據
結構之前，我們做到這一點。

800
00:34:11,100 --> 00:34:14,139
因為我不喜歡的想法
人在這條線轉移。

801
00:34:14,139 --> 00:34:17,360
>> 這沒什麼大不了的，如果大衛它
一步到位，但再次，想回

802
00:34:17,360 --> 00:34:20,360
當我們已經有8名志願者在
階段，我們所做的一樣插入

803
00:34:20,360 --> 00:34:22,600
排序，我們不得不開始
感動身邊的每一個人。

804
00:34:22,600 --> 00:34:23,790
這引起了昂貴的，對不對？

805
00:34:23,790 --> 00:34:28,330
這讓我畏縮關於大O
大O N，n的平方了。

806
00:34:28,330 --> 00:34:30,650
這不是感覺像
一個理想的結果。

807
00:34:30,650 --> 00:34:32,080
>> 因此，讓我們剛剛更新。

808
00:34:32,080 --> 00:34:35,120
因此，該隊列的大小
不再是2。

809
00:34:35,120 --> 00:34:37,090
現在只需1。

810
00:34:37,090 --> 00:34:40,360
但是我現在可以更新的東西
我沒有更新之前，

811
00:34:40,360 --> 00:34:41,130
列表的前面。

812
00:34:41,130 --> 00:34:45,420
我可以這樣說，是位置1？

813
00:34:45,420 --> 00:34:49,770
所以，現在我們這裡的垃圾值，
垃圾價值在這裡，大衛在

814
00:34:49,770 --> 00:34:51,469
這個垃圾中間。

815
00:34:51,469 --> 00:34:54,980
但是，該數據結構
仍是完好的。

816
00:34:54,980 --> 00:34:58,540
>> 事實上，我不甚至需要
改變Jake的前數

817
00:34:58,540 --> 00:35:00,460
9，因為誰在乎。

818
00:35:00,460 --> 00:35:04,470
我有足夠的信息，現在在
大小，我知道有一個人在

819
00:35:04,470 --> 00:35:05,030
此隊列。

820
00:35:05,030 --> 00:35:08,340
我知道那個人
在位置1，而不是0。

821
00:35:08,340 --> 00:35:09,760
我不計數。

822
00:35:09,760 --> 00:35:11,300
所以1。

823
00:35:11,300 --> 00:35:13,410
因此，數據結構還OK。

824
00:35:13,410 --> 00:35:14,330
>> 那麼，接下來會發生什麼呢？

825
00:35:14,330 --> 00:35:15,010
讓我們排隊 - 

826
00:35:15,010 --> 00:35:15,370
你叫什麼名字？

827
00:35:15,370 --> 00:35:16,160
>> 觀眾：Callen先生。

828
00:35:16,160 --> 00:35:16,580
>> 國寶馬蘭：Callen先生。

829
00:35:16,580 --> 00:35:20,770
讓我們排隊Callen先生，
圖22是在隊列中。

830
00:35:20,770 --> 00:35:22,300
所以，現在這裡有什麼改變嗎？

831
00:35:22,300 --> 00:35:24,380
前不會
改變，很明顯。

832
00:35:24,380 --> 00:35:27,160
尺寸要改變再次2。

833
00:35:27,160 --> 00:35:31,590
和22結束在這裡，圖9是仍然存在，
但它實際上是一個

834
00:35:31,590 --> 00:35:32,600
現在垃圾值。

835
00:35:32,600 --> 00:35:35,910
這只是傑克過去的殘餘。

836
00:35:35,910 --> 00:35:39,200
>> 所以，現在發生什麼，如果
我隊列中取出大衛？

837
00:35:39,200 --> 00:35:41,560
最後一個操作，出隊的大衛。

838
00:35:41,560 --> 00:35:46,070
我們可能會改變，但我提議，讓我們
做盡可能小的工作。

839
00:35:46,070 --> 00:35:50,280
現在我的數據結構去
備份的大小從2到1。

840
00:35:50,280 --> 00:35:53,730
但是，隊列前面的
現在變成2。

841
00:35:53,730 --> 00:35:56,640
我不需要改變這些數字
只是還沒有，因為他們是

842
00:35:56,640 --> 00:35:58,230
只是垃圾值。

843
00:35:58,230 --> 00:35:59,720
>> 但現在發生了什麼？

844
00:35:59,720 --> 00:36:03,280
假設我自己排隊，26？

845
00:36:03,280 --> 00:36:05,890
我覺得我屬於這裡。

846
00:36:05,890 --> 00:36:06,890
所以，我正在排隊。

847
00:36:06,890 --> 00:36:08,760
所以我屬於這裡。

848
00:36:08,760 --> 00:36:11,300
而且，即使你做的不是很
欣賞這視覺在舞台上，

849
00:36:11,300 --> 00:36:15,075
因為我們有足夠的空間，我應該
不會站在這裡，為什麼呢？

850
00:36:15,075 --> 00:36:16,290
>> 觀眾：你出界。

851
00:36:16,290 --> 00:36:16,370
>> 國寶馬蘭：右。

852
00:36:16,370 --> 00:36:16,940
我是出界。

853
00:36:16,940 --> 00:36:19,330
我已經超越索引的
此陣列的界限。

854
00:36:19,330 --> 00:36:23,420
我真的應該於一體的
三個可能的位置。

855
00:36:23,420 --> 00:36:25,150
現在，在最自然的去嗎？

856
00:36:25,150 --> 00:36:27,760
我建議，我們的槓桿
每週一招。

857
00:36:27,760 --> 00:36:30,150
mod運算符，百分比。

858
00:36:30,150 --> 00:36:36,850
因為我在技術上站在
位置3，但我做的3模能力，

859
00:36:36,850 --> 00:36:40,250
SO 3，百分號，3  - 

860
00:36:40,250 --> 00:36:40,970
容量3。

861
00:36:40,970 --> 00:36:41,720
那是什麼？

862
00:36:41,720 --> 00:36:43,700
什麼是餘
3除以3？

863
00:36:43,700 --> 00:36:44,070
0。

864
00:36:44,070 --> 00:36:48,140
>> 所以，把我傑克是，
這實際上是不錯的。

865
00:36:48,140 --> 00:36:50,370
所以，現在的實施
這個東西要

866
00:36:50,370 --> 00:36:51,250
是有點頭疼。

867
00:36:51,250 --> 00:36:53,740
這真的只是一條線
頭痛，代碼。

868
00:36:53,740 --> 00:36:56,580
但至少現在有垃圾
這裡的價值，但有兩個

869
00:36:56,580 --> 00:36:57,910
這裡正當整數。

870
00:36:57,910 --> 00:37:04,160
我要求，現在我們已經做了
這正是我們需要做的，只要

871
00:37:04,160 --> 00:37:08,600
我們改變了傑克的
的值是26。

872
00:37:08,600 --> 00:37:12,110
>> 我們現在有足夠的信息仍然
保持完整

873
00:37:12,110 --> 00:37:13,060
這樣的數據結構。

874
00:37:13,060 --> 00:37:17,160
我們依然是那樣的運氣，當我們
要插入四個或更多的總

875
00:37:17,160 --> 00:37:20,740
元素，但我至少可以做出漂亮
有效地利用這個常數

876
00:37:20,740 --> 00:37:21,740
時間，其實。

877
00:37:21,740 --> 00:37:27,150
我不必擔心轉移
大家作為大衛的傾向是。

878
00:37:27,150 --> 00:37:30,816
>> 堆棧上的任何問題，
此隊列？

879
00:37:30,816 --> 00:37:32,184
>> 觀眾：是的原因
你需要的大小，以便你知道

880
00:37:32,184 --> 00:37:34,010
在那裡有一個人？

881
00:37:34,010 --> 00:37:34,770
>> DAVID馬蘭：沒錯。

882
00:37:34,770 --> 00:37:38,230
我需要知道數組的大小
因為我需要確切地知道如何

883
00:37:38,230 --> 00:37:41,940
許多這些值都是合法的，
所以，我可以找到放在哪裡

884
00:37:41,940 --> 00:37:42,800
旁邊的人。

885
00:37:42,800 --> 00:37:43,300
沒錯。

886
00:37:43,300 --> 00:37:44,580
大小是 - 

887
00:37:44,580 --> 00:37:46,360
其實，我們並沒有更新。

888
00:37:46,360 --> 00:37:48,380
我自己在26加入。

889
00:37:48,380 --> 00:37:51,760
大小，而不是1，而是2。

890
00:37:51,760 --> 00:37:57,780
所以，現在這的確有助於我找到
列表頭，這是不為0，不

891
00:37:57,780 --> 00:37:59,250
1，但為2。

892
00:37:59,250 --> 00:38:01,665
列表的前面
確實是22號。

893
00:38:01,665 --> 00:38:05,120
因為他排在第一，所以他應該
被允許進入商店我面前，

894
00:38:05,120 --> 00:38:08,780
儘管在視覺上，我站在
靠近商店。

895
00:38:08,780 --> 00:38:09,220
>> 沒事吧？

896
00:38:09,220 --> 00:38:12,410
這些傢伙的掌聲鼓勵
我們會讓他們離開那裡。

897
00:38:12,410 --> 00:38:17,090
>> [掌聲]

898
00:38:17,090 --> 00:38:18,150
>> 國寶馬蘭：我可以讓
你守托盤。

899
00:38:18,150 --> 00:38:20,760
我們可以看到發生什麼，如果
你想要的，但也許不會。

900
00:38:20,760 --> 00:38:21,590
好的。

901
00:38:21,590 --> 00:38:25,380
所以，現在沒有什麼離開我們？

902
00:38:25,380 --> 00:38:28,900
好吧，讓我建議，有一個
其他一些數據結構，我們可以

903
00:38:28,900 --> 00:38:33,810
開始加入到我們的工具包，將
實際上是非常非常相關，因為

904
00:38:33,810 --> 00:38:35,270
我們潛入網絡的東西。

905
00:38:35,270 --> 00:38:38,150
這再次有某種聯繫
樹的形式

906
00:38:38,150 --> 00:38:40,550
一種叫DOM，文件
對象模型。

907
00:38:40,550 --> 00:38:42,370
但是，我們會看到更多的
用不了多久。

908
00:38:42,370 --> 00:38:46,260
>> 讓我提出的確定性
現在你可能知道什麼叫樹

909
00:38:46,260 --> 00:38:48,820
更多的家庭樹，在那裡你
在有一些祖先

910
00:38:48,820 --> 00:38:49,790
樹根。

911
00:38:49,790 --> 00:38:54,480
重男輕女或女家長
樹的最頂端。

912
00:38:54,480 --> 00:38:56,700
沒有他們的配偶，在這種情況下。

913
00:38:56,700 --> 00:39:00,940
但是，現在我們有什麼，我們會打電話給
孩子，這是掛的節點

914
00:39:00,940 --> 00:39:05,480
關閉左子或右的孩子，
這裡所描述的箭頭。

915
00:39:05,480 --> 00:39:10,490
>> 換句話說，在樹的數據結構
電腦，一棵樹零

916
00:39:10,490 --> 00:39:11,480
或多個節點。

917
00:39:11,480 --> 00:39:13,500
如果它有至少一個節點，
這就是所謂的根。

918
00:39:13,500 --> 00:39:15,700
這是視覺上的東西
我們在上面畫。

919
00:39:15,700 --> 00:39:20,280
該節點，像任何其他節點，
具有零個，一個或兩個，或三個，

920
00:39:20,280 --> 00:39:23,600
然而，許多孩子
數據結構支持。

921
00:39:23,600 --> 00:39:29,150
在這種情況下，根存儲
值，有兩個孩子，2和3，

922
00:39:29,150 --> 00:39:33,020
所以我們一般稱之為左
兒童和3的右孩子。

923
00:39:33,020 --> 00:39:36,940
>> 然後當我們得到下降到5，6，
7，6可能被稱為中間的孩子。

924
00:39:36,940 --> 00:39:38,940
如果你有四個孩子，
它變得撲朔迷離。

925
00:39:38,940 --> 00:39:42,260
因此，我們停止使用那種
口頭上的快捷方式。

926
00:39:42,260 --> 00:39:44,580
但它確實只是一個家族樹。

927
00:39:44,580 --> 00:39:48,880
和這裡的葉子的節點
自己有沒有孩子。

928
00:39:48,880 --> 00:39:52,540
他們掛在樹的底部。

929
00:39:52,540 --> 00:39:56,940
>> 那麼，我們怎麼可能實現的樹
具有最大限度僅有的兩個孩子嗎？

930
00:39:56,940 --> 00:39:58,410
我們會打電話給它一個二叉樹。

931
00:39:58,410 --> 00:40:00,960
畢再次意思是兩個，在該
的情況下，像二進制。

932
00:40:00,960 --> 00:40:04,830
因此，它可以具有零個，一個
兩個孩子最大限度。

933
00:40:04,830 --> 00:40:08,650
>> 我會建議我們實行節點
該結構與一個整數n，

934
00:40:08,650 --> 00:40:11,910
然後兩個三分球，一個叫
離開後，一個叫權。

935
00:40:11,910 --> 00:40:14,830
但這些都是剛剛好
任意約定。

936
00:40:14,830 --> 00:40:18,170
，什麼是現在不錯的，特別是如果你
樣的掙扎概念

937
00:40:18,170 --> 00:40:21,300
遞歸，或認為這是不
一個真正的解決方案，任何東西，

938
00:40:21,300 --> 00:40:23,120
特別是如果你能
耗盡內存。

939
00:40:23,120 --> 00:40:26,600
現在，我們正在談論數據
結構和算法，使

940
00:40:26,600 --> 00:40:31,030
我們遍歷和操作，
事實證明，遞歸回來

941
00:40:31,030 --> 00:40:34,240
一個更引人注目
如果沒有美麗的方式。

942
00:40:34,240 --> 00:40:38,670
>> 所以我的建議是實施
搜索功能。

943
00:40:38,670 --> 00:40:39,870
鑑於兩個輸入 - 

944
00:40:39,870 --> 00:40:41,570
所以認為這是一個黑盒子。

945
00:40:41,570 --> 00:40:46,560
鑑於兩個輸入，正和一個int
一棵樹的指針，一個指向一個

946
00:40:46,560 --> 00:40:50,020
節點，還是真的一棵樹的根，我
聲稱，該函數可以返回

947
00:40:50,020 --> 00:40:53,530
真的還是假的，值n
是這種樹內。

948
00:40:53,530 --> 00:40:55,210
>> 這個黑盒子裡面有什麼？

949
00:40:55,210 --> 00:40:57,440
那麼，四分支。

950
00:40:57,440 --> 00:40:58,385
起初只是檢查。

951
00:40:58,385 --> 00:41:00,490
如果樹是空的，只是返回false。

952
00:41:00,490 --> 00:41:04,580
如果沒有節點，有沒有N，
有沒有多少，只是返回false。

953
00:41:04,580 --> 00:41:12,330
如果你正在尋找的價值，N，雖然
，不到樹箭頭N，

954
00:41:12,330 --> 00:41:15,180
只是要清楚，這是什麼意思時，
我寫的樹，然後箭頭

955
00:41:15,180 --> 00:41:18,150
符號，N？

956
00:41:18,150 --> 00:41:18,690
沒錯。

957
00:41:18,690 --> 00:41:21,970
這意味著取消引用
指針稱為樹。

958
00:41:21,970 --> 00:41:26,750
去那裡，然後拿到裡面的
節點並獲取其字段名為N。

959
00:41:26,750 --> 00:41:30,810
然後比較實際n表示
通過搜索反對。

960
00:41:30,810 --> 00:41:35,390
>> 因此，如果n是小於n的值
在樹節點本身，好了，

961
00:41:35,390 --> 00:41:36,720
這是什麼意思？

962
00:41:36,720 --> 00:41:40,690
這乍一看沒什麼意思。

963
00:41:40,690 --> 00:41:40,900
對嗎？

964
00:41:40,900 --> 00:41:45,560
就像當你有一個數組
值，你可能喜歡的應用二進制

965
00:41:45,560 --> 00:41:48,290
作為一種形式的分搜索
而治之。

966
00:41:48,290 --> 00:41:51,790
但假設沒有什麼我們需要做
二進制搜索在所有的工作

967
00:41:51,790 --> 00:41:54,510
在電話簿和
前面的例子嗎？

968
00:41:54,510 --> 00:41:55,530
>> 如何進行排序。

969
00:41:55,530 --> 00:41:59,490
因此，讓我們細化的定義樹
這裡不只是一棵樹，它可以

970
00:41:59,490 --> 00:42:00,880
有任意數量的兒童。

971
00:42:00,880 --> 00:42:04,700
不只是一個二叉樹，它可以
最大限度有0，1，或2。

972
00:42:04,700 --> 00:42:09,700
但是，作為一個二叉搜索樹，或BST，
這僅僅是一個奇特的方式說一個

973
00:42:09,700 --> 00:42:15,430
二叉樹每個節點的
左子節點，如果存在，是

974
00:42:15,430 --> 00:42:16,830
小於該節點。

975
00:42:16,830 --> 00:42:20,170
而每一個節點的右子，
如果存在，是更大的

976
00:42:20,170 --> 00:42:21,740
比該節點本身。

977
00:42:21,740 --> 00:42:25,200
>> 所以，換句話說，如果你是畫
樹出來，所有的數字都

978
00:42:25,200 --> 00:42:30,620
這樣精心平衡，這樣，如果
你有55根，33可以去

979
00:42:30,620 --> 00:42:33,090
在它的左邊，因為它是小於55。

980
00:42:33,090 --> 00:42:36,430
77可以去其正確的，因為
它是大於55。

981
00:42:36,430 --> 00:42:40,750
但是現在注意到，相同的定義，
這是一個遞歸定義口頭，

982
00:42:40,750 --> 00:42:42,600
已申請33。

983
00:42:42,600 --> 00:42:47,610
33的左子必須比它少，
和33的右子，44歲，必須

984
00:42:47,610 --> 00:42:48,580
大於它。

985
00:42:48,580 --> 00:42:51,670
>> 所以這是一個二叉搜索樹，
我建議，使用一點點

986
00:42:51,670 --> 00:42:53,910
遞歸，我們現在能夠找到N。

987
00:42:53,910 --> 00:42:59,160
因此，如果n是小於值n的
當前節點，我要去

988
00:42:59,160 --> 00:43:04,090
進取，撐船，所以說話，只是
返回任何回答是的

989
00:43:04,090 --> 00:43:08,470
為n
樹的左子。

990
00:43:08,470 --> 00:43:11,370
再次注意，這個函數只是
預計節點明星，

991
00:43:11,370 --> 00:43:12,780
到一個節點的指針。

992
00:43:12,780 --> 00:43:17,360
所以，我一定可以做樹
左箭頭，這將導致

993
00:43:17,360 --> 00:43:18,400
去到另一個節點。

994
00:43:18,400 --> 00:43:19,480
但是，該節點是什麼？

995
00:43:19,480 --> 00:43:22,820
>> 那麼，根據這個聲明，
剩下的只是一個指針，所以，僅僅

996
00:43:22,820 --> 00:43:27,090
意味著我通過搜索功能
不同的指針，即

997
00:43:27,090 --> 00:43:30,750
就是代表
我的左子樹。

998
00:43:30,750 --> 00:43:36,040
因此，在這種情況下，指針33，如果
同時，如果是我們的樣本輸入

999
00:43:36,040 --> 00:43:40,740
n是大於上面的n值
當前樹中的節點，那麼我

1000
00:43:40,740 --> 00:43:43,370
要繼續前進，平底船在其他
方向，只是說，我不

1001
00:43:43,370 --> 00:43:47,280
知道此值n是樹中，
但我知道，如果它是，它是我的

1002
00:43:47,280 --> 00:43:49,090
右分支，可以這麼說。

1003
00:43:49,090 --> 00:43:53,120
因此，讓我叫遞歸搜索，
再通過一個n，但在傳遞

1004
00:43:53,120 --> 00:43:54,580
我的右孩子指針。

1005
00:43:54,580 --> 00:44:00,020
>> 換句話說，如果我目前在55
，我知道我在尋找99 99

1006
00:44:00,020 --> 00:44:04,270
大於55，所以就像我撕毀
電話簿星期前，我們

1007
00:44:04,270 --> 00:44:07,140
去正確的，同樣是我們
要去這裡。

1008
00:44:07,140 --> 00:44:11,960
我不知道，如果它是在我的右
孩子，它不是，77是有，但

1009
00:44:11,960 --> 00:44:13,210
我知道這是在那個方向。

1010
00:44:13,210 --> 00:44:18,770
因此，我呼籲搜索在我的右孩子，
77，讓搜索身影從

1011
00:44:18,770 --> 00:44:24,950
如果99本任意
例如實際上是存在的。

1012
00:44:24,950 --> 00:44:26,900
>> 否則，什麼是最終的情況？

1013
00:44:26,900 --> 00:44:28,620
如果樹是空是一個案例。

1014
00:44:28,620 --> 00:44:31,890
如果n小於當前節點的
值是另一種情況。

1015
00:44:31,890 --> 00:44:35,120
如果n為大於當前
節點的值是第三種情況。

1016
00:44:35,120 --> 00:44:38,250
第四和最後的情況是什麼？

1017
00:44:38,250 --> 00:44:39,480
我認為我們的情況下，對不對？

1018
00:44:39,480 --> 00:44:44,690
它必須是n在
當前節點我。

1019
00:44:44,690 --> 00:44:49,640
>> 所以，如果我在尋找55在這一點上
在故事中，那支

1020
00:44:49,640 --> 00:44:51,780
樹將返回true。

1021
00:44:51,780 --> 00:44:55,380
那麼，什麼有趣的是，我們
實際上，不像週過去，我們種

1022
00:44:55,380 --> 00:44:56,740
有兩個基例。

1023
00:44:56,740 --> 00:44:58,300
，他們不必
所有在頂部。

1024
00:44:58,300 --> 00:45:01,390
頂部是一個基本情況，因為如果
樹是空的，有沒有什麼關係。

1025
00:45:01,390 --> 00:45:03,410
只是返回一個硬編碼
值false。

1026
00:45:03,410 --> 00:45:07,400
>> 底部分支排序
默認情況下，如果我們檢查

1027
00:45:07,400 --> 00:45:11,550
空，我們已經檢查了，如果它應該是
離開了，但是它不應該是，我們已經

1028
00:45:11,550 --> 00:45:14,640
檢查，如果它應該是正確的，但它
不應該的，清楚地，它必須是

1029
00:45:14,640 --> 00:45:15,870
右邊我們在哪裡。

1030
00:45:15,870 --> 00:45:16,780
這是一個基本情況。

1031
00:45:16,780 --> 00:45:19,920
因此，有兩個遞歸例
夾在中間。

1032
00:45:19,920 --> 00:45:21,630
但我可以寫
這在任何順序。

1033
00:45:21,630 --> 00:45:24,520
我只是認為這樣的感覺自然
首先檢查可能的錯誤，

1034
00:45:24,520 --> 00:45:28,340
然後檢查左，右檢查，然後
假設你是在節點

1035
00:45:28,340 --> 00:45:30,630
你實際上是在尋找。

1036
00:45:30,630 --> 00:45:36,240
>> 那麼，為什麼會這樣有用嗎？

1037
00:45:36,240 --> 00:45:37,910
因此，原來 - 

1038
00:45:37,910 --> 00:45:42,110
讓我跳一個傳情
在這裡，在網上。

1039
00:45:42,110 --> 00:45:44,920
我們將開始使用不是一個
在第一編程語言，但

1040
00:45:44,920 --> 00:45:46,030
標記語言。

1041
00:45:46,030 --> 00:45:48,740
一種標記語言，是一個
類似的精神編程

1042
00:45:48,740 --> 00:45:51,715
語言，但它不會給你的
能夠表達自己的邏輯。

1043
00:45:51,715 --> 00:45:55,070
它只是給你的能力，
表達自己的結構。

1044
00:45:55,070 --> 00:45:57,960
>> 你想放的東西在哪裡
在頁面上，網頁？

1045
00:45:57,960 --> 00:45:59,200
你想讓它是什麼顏色的？

1046
00:45:59,200 --> 00:46:00,950
你想讓它什麼字體大小？

1047
00:46:00,950 --> 00:46:02,970
什麼話你實際上
想在網頁上嗎？

1048
00:46:02,970 --> 00:46:04,060
所以這是一種標記語言。

1049
00:46:04,060 --> 00:46:07,690
但然後我們會很迅速推出
JavaScript中，這是一個完全成熟的

1050
00:46:07,690 --> 00:46:08,560
編程語言。

1051
00:46:08,560 --> 00:46:12,530
在語法上非常相似的外觀
C，但還會有一些

1052
00:46:12,530 --> 00:46:15,200
不錯，功能更強大，更
用戶友好的功能。

1053
00:46:15,200 --> 00:46:18,050
>> 和挫折
在本學期，我們會點

1054
00:46:18,050 --> 00:46:22,065
即將實施的拼寫少得多
使用其他語言的代碼行

1055
00:46:22,065 --> 00:46:25,580
比C本身允許的，但對於原因
我們很快就會明白。

1056
00:46:25,580 --> 00:46:27,750
這將是第一個這樣的網頁。

1057
00:46:27,750 --> 00:46:30,120
這將是完全給人留下深刻印象，
我們的第一個。

1058
00:46:30,120 --> 00:46:31,400
簡單地說，你好世界。

1059
00:46:31,400 --> 00:46:34,010
但是，如果你從來沒有見過它
之前，這是HTML，

1060
00:46:34,010 --> 00:46:35,670
超文本標記語言。

1061
00:46:35,670 --> 00:46:39,310
>> 如果你去某些菜單選項
任何瀏覽器，在任何網頁上

1062
00:46:39,310 --> 00:46:43,160
在互聯網上，你可以看到的HTML
一些人寫信給

1063
00:46:43,160 --> 00:46:44,400
創建該網頁。

1064
00:46:44,400 --> 00:46:47,850
它可能看起來並不
短暫或整齊。

1065
00:46:47,850 --> 00:46:51,400
但它會按照這些模式
開放式支架和斜線

1066
00:46:51,400 --> 00:46:53,660
字母和潛在的數字。

1067
00:46:53,660 --> 00:46:56,770
>> 我想我給你傳情
你就可以做什麼

1068
00:46:56,770 --> 00:46:57,950
後服用CS50。

1069
00:46:57,950 --> 00:47:02,620
讓我去到cs.harvard.edu /搶劫，
我們自己的羅布·鮑登的主頁。

1070
00:47:02,620 --> 00:47:06,080
他給我們看。

1071
00:47:06,080 --> 00:47:07,490
所以你很快就能夠做到這一點。

1072
00:47:07,490 --> 00:47:10,660
此外，你聽到什麼
今天上午 - 

1073
00:47:10,660 --> 00:47:12,480
你今早 - 

1074
00:47:12,480 --> 00:47:13,780
>> [倉鼠跳舞音樂]

1075
00:47:13,780 --> 00:47:15,702
>>  - 你將能作出這種。

1076
00:47:15,702 --> 00:47:16,790
等待著我們在週三。

1077
00:47:16,790 --> 00:47:17,791
然後我們會看到你。

1078
00:47:17,791 --> 00:47:22,950
>> [倉鼠跳舞音樂]

1079
00:47:22,950 --> 00:47:24,300
國寶馬蘭：在未來CS50  - 

1080
00:47:24,300 --> 00:47:31,670