1
00:00:00,000 --> 00:00:05,204

2
00:00:05,204 --> 00:00:07,370
道格·勞埃德：所以如果你
看著堆棧的視頻，

3
00:00:07,370 --> 00:00:09,870
這大概會感覺
像似曾相識的一點點。

4
00:00:09,870 --> 00:00:13,850
這將非常相似的概念，
剛上有一個輕微的扭曲。

5
00:00:13,850 --> 00:00:15,530
我們現在要談的隊列。

6
00:00:15,530 --> 00:00:19,350
這樣一個隊列，類似於一個棧，
是另一種數據結構的

7
00:00:19,350 --> 00:00:22,412
我們可以用它來保持
有組織地數據。

8
00:00:22,412 --> 00:00:24,120
類似於一個堆棧，
它可以實現

9
00:00:24,120 --> 00:00:27,000
作為陣列或鍊錶。

10
00:00:27,000 --> 00:00:30,320
不像堆疊時，規則
我們用它來確定

11
00:00:30,320 --> 00:00:34,210
當事情被添加或者刪除
隊列中有一點點不同。

12
00:00:34,210 --> 00:00:36,590
>> 不像堆棧，它
為LIFO結構，

13
00:00:36,590 --> 00:00:45,610
後進先出，隊列是FIFO
結構，FIFO，先入先出。

14
00:00:45,610 --> 00:00:49,320
現在排隊，你可能
有一個比喻隊列。

15
00:00:49,320 --> 00:00:52,820
如果你在曾經在行
遊樂園或在銀行，

16
00:00:52,820 --> 00:00:56,430
有一個排序的公平
實施結構。

17
00:00:56,430 --> 00:00:59,160
行中的第一人，在
銀行是第一人

18
00:00:59,160 --> 00:01:00,760
誰得到發言的出納員。

19
00:01:00,760 --> 00:01:03,522
>> 這將是形式的比賽
至底部，如果唯一的方式

20
00:01:03,522 --> 00:01:06,730
你有發言的出納員
銀行是成為最後一個人在網上。

21
00:01:06,730 --> 00:01:09,146
每個人總是希望
成為最後一個人在網上，

22
00:01:09,146 --> 00:01:12,580
而該人誰在那裡第一次
誰一直在等待了一段時間，

23
00:01:12,580 --> 00:01:14,715
可能是那裡幾個小時，
和小時，和小時

24
00:01:14,715 --> 00:01:17,590
他們有機會真正前
提取任何款項在銀行。

25
00:01:17,590 --> 00:01:22,510
所以隊列排序
公平實現結構。

26
00:01:22,510 --> 00:01:25,780
但是，這並不一定意味著
該協議棧是一件壞事，只是

27
00:01:25,780 --> 00:01:28,160
該隊列是另一種方式來做到這一點。

28
00:01:28,160 --> 00:01:32,420
如此反复隊列是先入先
出來，對一疊這持續的，

29
00:01:32,420 --> 00:01:34,440
先出。

30
00:01:34,440 --> 00:01:36,190
類似於一個堆棧，
我們有兩個操作

31
00:01:36,190 --> 00:01:38,470
我們可以在隊列表演。

32
00:01:38,470 --> 00:01:43,910
的名稱是排隊，這是添加
一個新元素添加到隊列的末尾，

33
00:01:43,910 --> 00:01:47,330
和出隊，這是
以除去最老的

34
00:01:47,330 --> 00:01:49,670
元件從隊列的前部。

35
00:01:49,670 --> 00:01:53,600
因此，我們要添加的元素
到隊列的末尾，

36
00:01:53,600 --> 00:01:57,220
而且我們要刪除元素
從隊列的前部。

37
00:01:57,220 --> 00:02:00,790
再次，與堆棧，我們加入
元素添加到堆棧的頂部

38
00:02:00,790 --> 00:02:03,380
和刪除元素
從堆棧的頂部。

39
00:02:03,380 --> 00:02:07,570
因此，與排隊，它增加了
結束時，從正面除去。

40
00:02:07,570 --> 00:02:10,639
因此，有最古老的東西
永遠是未來的事情

41
00:02:10,639 --> 00:02:13,620
出來，如果我們試圖
和出列的東西。

42
00:02:13,620 --> 00:02:18,330
>> 如此反复，與隊列，我們可以
基於陣列的實現

43
00:02:18,330 --> 00:02:20,110
和鍊錶基於實現。

44
00:02:20,110 --> 00:02:24,620
我們將與重新開始
基於陣列的實現。

45
00:02:24,620 --> 00:02:27,070
該結構定義
看起來很相似。

46
00:02:27,070 --> 00:02:30,720
我們有另一個數組
數據類型值的出現，

47
00:02:30,720 --> 00:02:32,690
因此它可以容納任意類型的數據。

48
00:02:32,690 --> 00:02:35,570
我們再次將使用
整數在本實施例。

49
00:02:35,570 --> 00:02:39,830
>> 就如同我們
基於陣列的堆棧實現，

50
00:02:39,830 --> 00:02:42,340
因為我們使用的
陣列，我們一定

51
00:02:42,340 --> 00:02:46,850
有一個限制，即C類
的實施對我們來說，這是我們

52
00:02:46,850 --> 00:02:51,670
沒有在任何活力我們的
能力增長和收縮的陣列。

53
00:02:51,670 --> 00:02:55,710
我們必須決定在開始
什麼是物聯網的最大數量

54
00:02:55,710 --> 00:02:59,300
我們可以把這個
隊列，並且在這種情況下，

55
00:02:59,300 --> 00:03:02,070
容量為一些英鎊
定義我們的代碼不變。

56
00:03:02,070 --> 00:03:05,430
並為這個目的
視頻，容量將是10。

57
00:03:05,430 --> 00:03:07,690
>> 我們需要保持跟踪
隊列的前面

58
00:03:07,690 --> 00:03:11,160
所以我們知道哪些元素
我們要出列，

59
00:03:11,160 --> 00:03:15,070
而且我們也需要保持跟踪
東西else--元件的數目

60
00:03:15,070 --> 00:03:16,690
我們已經在我們的隊列中。

61
00:03:16,690 --> 00:03:19,360
請注意，我們不是在跟踪
隊列的末尾的，只是

62
00:03:19,360 --> 00:03:21,150
隊列的大小。

63
00:03:21,150 --> 00:03:24,310
而其中的原因將有希望
成為一時有點清晰。

64
00:03:24,310 --> 00:03:26,143
一旦我們完成了
這種類型的定義，

65
00:03:26,143 --> 00:03:29,080
我們有一個新的數據類型
所謂的隊列，現在我們可以

66
00:03:29,080 --> 00:03:30,630
聲明的數據類型的變量。

67
00:03:30,630 --> 00:03:35,350
而且有點混亂，我決定
調用此隊列Q，信

68
00:03:35,350 --> 00:03:38,090
的q代替數據鍵入q。

69
00:03:38,090 --> 00:03:39,600
>> 因此，這裡就是我們的隊列。

70
00:03:39,600 --> 00:03:40,700
它是一個結構。

71
00:03:40,700 --> 00:03:45,730
它包含三個成員，三
字段大小的容納的陣列。

72
00:03:45,730 --> 00:03:47,340
在這種情況下，容量為10。

73
00:03:47,340 --> 00:03:49,580
而這個數組
將要舉辦的整數。

74
00:03:49,580 --> 00:03:55,240
在綠色環保是我們的隊列前面的
要移除下一個元素，並以紅色

75
00:03:55,240 --> 00:03:58,610
將是隊列的大小，
多少個元素是目前

76
00:03:58,610 --> 00:04:01,190
現有在隊列中。

77
00:04:01,190 --> 00:04:05,300
所以，如果我們說q.front平等
0，和q.size大小等於0--

78
00:04:05,300 --> 00:04:07,120
我們把0到這些領域。

79
00:04:07,120 --> 00:04:11,070
而在這一點上，我們是非常
準備開始我們的隊列中的工作。

80
00:04:11,070 --> 00:04:14,140
>> 因此，第一個操作，我們可以
執行是要排隊的東西，

81
00:04:14,140 --> 00:04:16,860
一個新的元素添加到
的隊列的末尾。

82
00:04:16,860 --> 00:04:19,089
那麼我們怎麼需要
這樣做在一般情況下？

83
00:04:19,089 --> 00:04:23,690
那麼這個功能需要排隊
以接受的指針我們的隊列。

84
00:04:23,690 --> 00:04:26,370
同樣，如果我們宣布
我們在全球範圍的隊列，

85
00:04:26,370 --> 00:04:29,490
我們不會需要做到這一點
必需的，但在一般情況下，我們

86
00:04:29,490 --> 00:04:32,330
需要接受指針
到數據結構

87
00:04:32,330 --> 00:04:35,040
像這樣，否則，
我們經過value--我們

88
00:04:35,040 --> 00:04:38,140
傳入隊列的副本，
所以我們實際上並沒有改變

89
00:04:38,140 --> 00:04:41,050
我們打算改變隊列。

90
00:04:41,050 --> 00:04:44,860
>> 它需要做的另一件事是接受
適當類型的數據元素。

91
00:04:44,860 --> 00:04:46,818
再次，在這種情況下，它的
將是整數，

92
00:04:46,818 --> 00:04:49,330
但你可以隨意
聲明數據類型值

93
00:04:49,330 --> 00:04:51,160
和使用這種更普遍。

94
00:04:51,160 --> 00:04:56,030
這就是我們要排隊的元素，
我們要添加到所述隊列的末端。

95
00:04:56,030 --> 00:04:58,573
然後，我們其實想
放置該數據隊列中。

96
00:04:58,573 --> 00:05:01,490
在這種情況下，將其放置在
我們的數組的正確位置，

97
00:05:01,490 --> 00:05:05,040
然後我們要改變大小
隊列中，有多少我們的元素

98
00:05:05,040 --> 00:05:07,050
目前擁有。

99
00:05:07,050 --> 00:05:07,990
>> 所以，讓我們開始吧。

100
00:05:07,990 --> 00:05:10,890
這是，同樣，這一般
表函數聲明

101
00:05:10,890 --> 00:05:13,980
什麼排隊可能看起來像。

102
00:05:13,980 --> 00:05:14,910
在這裡，我們走了。

103
00:05:14,910 --> 00:05:18,335
讓我們排隊數
28到隊列。

104
00:05:18,335 --> 00:05:19,460
那麼，我們該怎麼辦？

105
00:05:19,460 --> 00:05:23,390
好了，我們的隊列的前面
在0，而我們的隊列的大小

106
00:05:23,390 --> 00:05:29,680
為0，所以我們可能要放
數28在數組編號

107
00:05:29,680 --> 00:05:31,124
0，對不對？

108
00:05:31,124 --> 00:05:32,540
所以，我們現在已經擺在那裡。

109
00:05:32,540 --> 00:05:34,820
所以，現在我們需要什麼改變？

110
00:05:34,820 --> 00:05:37,090
我們不希望改變
在隊列的前面，

111
00:05:37,090 --> 00:05:40,850
因為我們想知道哪些因素
我們可能需要在以後出列。

112
00:05:40,850 --> 00:05:44,020
因此，我們之所以有前面有
是那種什麼是指標

113
00:05:44,020 --> 00:05:46,439
最古老的東西到數組中。

114
00:05:46,439 --> 00:05:49,730
那麼最古老的東西在array--中
事實上，在數組中的唯一正確的

115
00:05:49,730 --> 00:05:53,540
now--是28，這是
在數組位置0。

116
00:05:53,540 --> 00:05:56,160
因此，我們不希望
改變這種綠色的數量，

117
00:05:56,160 --> 00:05:57,910
因為這是最古老的元素。

118
00:05:57,910 --> 00:06:00,510
相反，我們要改變大小。

119
00:06:00,510 --> 00:06:04,110
因此，在這種情況下，我們將
增量大小設置為1。

120
00:06:04,110 --> 00:06:08,430
>> 那裡的想法，現在一般的排序
下一個元素是要去一個隊列

121
00:06:08,430 --> 00:06:12,310
是添加這兩個數字
一起，前部和大小，

122
00:06:12,310 --> 00:06:16,390
並會告訴你在哪裡下
在隊列元件是要去​​。

123
00:06:16,390 --> 00:06:18,130
所以，現在讓我們來排隊另一個號碼。

124
00:06:18,130 --> 00:06:20,250
讓我們排隊33。

125
00:06:20,250 --> 00:06:24,480
所以33是要進入
陣列位置0加1。

126
00:06:24,480 --> 00:06:26,840
所以在這種情況下，它將會
進入陣列的位置1，

127
00:06:26,840 --> 00:06:29,500
現在我們隊列的大小為2。

128
00:06:29,500 --> 00:06:31,840
>> 同樣，我們不會改變
我們的隊列的前面，

129
00:06:31,840 --> 00:06:34,730
因為28仍是
最古老的元素，我們

130
00:06:34,730 --> 00:06:38,220
希望用於：當我們最終得到
要出列，刪除元素

131
00:06:38,220 --> 00:06:43,300
從這個隊列中，我們想知道
其中最古老的元素。

132
00:06:43,300 --> 00:06:48,620
因此，我們總是需要保持
那裡的一些指標。

133
00:06:48,620 --> 00:06:50,410
所以這是0就是那裡。

134
00:06:50,410 --> 00:06:52,910
這就是前面就是那裡。

135
00:06:52,910 --> 00:06:55,022
>> 讓我們在排隊一個更多元，19。

136
00:06:55,022 --> 00:06:56,980
我敢肯定，你能猜到
其中，19是要去。

137
00:06:56,980 --> 00:06:59,860
它打算進入
陣列位置號碼2。

138
00:06:59,860 --> 00:07:01,570
這就是0加2。

139
00:07:01,570 --> 00:07:03,199
而現在我們的隊列的大小為3。

140
00:07:03,199 --> 00:07:04,240
我們在這3個元素。

141
00:07:04,240 --> 00:07:08,490
所以，如果我們要和我們不會
到現在，排隊的另一個元素，

142
00:07:08,490 --> 00:07:11,370
它將進入陣列的位置
號3，和我們的隊列的大小

143
00:07:11,370 --> 00:07:13,160
將是4。

144
00:07:13,160 --> 00:07:15,279
所以，我們現在已經入隊的幾個要素。

145
00:07:15,279 --> 00:07:16,570
現在，讓我們開始將其刪除。

146
00:07:16,570 --> 00:07:19,450
讓我們從隊列中出列他們。

147
00:07:19,450 --> 00:07:23,340
>> 因此，類似的流行，這是排序
這個模擬為堆棧，

148
00:07:23,340 --> 00:07:26,180
出隊需要接受
指針queue--再次，

149
00:07:26,180 --> 00:07:28,140
除非它的全局聲明。

150
00:07:28,140 --> 00:07:31,610
現在我們要改變位置
在隊列前面的。

151
00:07:31,610 --> 00:07:35,050
這有點從何而來
發揮作用，這一方面的變量，

152
00:07:35,050 --> 00:07:37,310
因為一旦我們刪除
一個元素，我們希望

153
00:07:37,310 --> 00:07:40,720
將其移動到下一個最古老的元素。

154
00:07:40,720 --> 00:07:44,180
>> 然後，我們要減少
的隊列的大小，

155
00:07:44,180 --> 00:07:47,130
然後我們要返回的值
被從隊列中刪除。

156
00:07:47,130 --> 00:07:48,921
同樣，我們不希望只是將其丟棄。

157
00:07:48,921 --> 00:07:51,170
我們大概是提取
從我們的queue--

158
00:07:51,170 --> 00:07:54,170
出列，因為我們關心它。

159
00:07:54,170 --> 00:08:01,080
因此，我們希望這個函數返回
型值的數據元素。

160
00:08:01,080 --> 00:08:04,360
再次，在這種情況下，值是整數。

161
00:08:04,360 --> 00:08:05,670
>> 所以，現在，讓我們出列的東西。

162
00:08:05,670 --> 00:08:09,310
讓我們從隊列中刪除的元素。

163
00:08:09,310 --> 00:08:15,970
如果說INT x等於＆Q，符號q--
再次，這是一個指針，這個Q數據

164
00:08:15,970 --> 00:08:20,177
結構 - 哪些因素
將被出列？

165
00:08:20,177 --> 00:08:23,840

166
00:08:23,840 --> 00:08:29,480
在這種情況下，因為它是一個第一
入先出的數據結構，FIFO

167
00:08:29,480 --> 00:08:33,690
我們把這個第一件事
隊列為28，因此在這種情況下，

168
00:08:33,690 --> 00:08:37,245
我們要採取28出
隊列中，不19，這是什麼

169
00:08:37,245 --> 00:08:38,870
我們會做，如果這是一個堆棧。

170
00:08:38,870 --> 00:08:42,220
我們將採取28個隊列。

171
00:08:42,220 --> 00:08:44,960
>> 類似於我們用做
堆棧，我們實際上沒有

172
00:08:44,960 --> 00:08:47,345
要刪除28
從隊列本身

173
00:08:47,345 --> 00:08:49,470
我們只是來樣
中假裝它不存在。

174
00:08:49,470 --> 00:08:51,678
因此，它會呆在那裡
在內存中，但我們只是

175
00:08:51,678 --> 00:08:57,820
要通過移動那種忽略它
我們的Q數據的其他兩個場

176
00:08:57,820 --> 00:08:58,830
結構。

177
00:08:58,830 --> 00:09:00,230
我們要改變前。

178
00:09:00,230 --> 00:09:04,290
Q.front現在要
是1，因為這是現

179
00:09:04,290 --> 00:09:07,740
我們有最古老的元素我們
隊列，因為我們已經刪除28，

180
00:09:07,740 --> 00:09:10,460
這是以前最古老的元素。

181
00:09:10,460 --> 00:09:13,540
>> 而現在，我們要改變
隊列的大小

182
00:09:13,540 --> 00:09:15,780
至兩個元素，而不是三個。

183
00:09:15,780 --> 00:09:20,450
早前現在還記得我說過，當我們
要元素添加到隊列中，

184
00:09:20,450 --> 00:09:26,000
我們把它放在一個數組位置
這是前部和大小的總和。

185
00:09:26,000 --> 00:09:29,050
因此，在這種情況下，我們仍然把
它，在隊列中的下一個元素，

186
00:09:29,050 --> 00:09:33,360
進入陣列的位置3，和
我們會看到，在一秒鐘。

187
00:09:33,360 --> 00:09:35,730
>> 所以，我們現在已經離隊了
從隊列中第一個元素。

188
00:09:35,730 --> 00:09:36,480
讓我們再次做到這一點。

189
00:09:36,480 --> 00:09:38,696
讓我們刪除其它
元件從隊列。

190
00:09:38,696 --> 00:09:42,400
在該情況下，當前最舊的
元素是數組位置1。

191
00:09:42,400 --> 00:09:44,220
這就是q.front告訴我們。

192
00:09:44,220 --> 00:09:46,980
這個綠色的盒子告訴我們，
這是最古老的元素。

193
00:09:46,980 --> 00:09:49,310
因此，x將成為33。

194
00:09:49,310 --> 00:09:52,130
那種我們會就忘
該33存在於數組中，

195
00:09:52,130 --> 00:09:55,100
我們將現在的說，
隊列中的新的最古老的元素

196
00:09:55,100 --> 00:09:58,900
是在陣列的位置2，並且大小
元素的隊列，數

197
00:09:58,900 --> 00:10:02,152
我們已經在隊列，是1。

198
00:10:02,152 --> 00:10:05,110
現在，讓我們排隊的東西，和我
那種一秒鐘前給送人了，

199
00:10:05,110 --> 00:10:10,340
但是如果我們想要把40進
隊列，哪來的40要去？

200
00:10:10,340 --> 00:10:12,880

201
00:10:12,880 --> 00:10:17,730
好了，我們已經把它
在q.front加隊列的大小，

202
00:10:17,730 --> 00:10:20,850
因此它是有道理的
居然把40在這裡。

203
00:10:20,850 --> 00:10:22,840
現在請注意，在
某些時候，我們要去

204
00:10:22,840 --> 00:10:27,980
去的端
我們陣問：裡面，

205
00:10:27,980 --> 00:10:32,010
但淡出28和33--
它們實際上是在技術上

206
00:10:32,010 --> 00:10:33,300
開放的空間，對不對？

207
00:10:33,300 --> 00:10:36,040
因此，我們可以eventually--
加入該規則

208
00:10:36,040 --> 00:10:40,390
這兩個together--我們最終可能
需要通過MOD容量的大小

209
00:10:40,390 --> 00:10:41,410
所以我們可以環繞。

210
00:10:41,410 --> 00:10:43,620
>> 因此，如果我們得到的元素
10號，如果我們

211
00:10:43,620 --> 00:10:48,790
取代它的單元號10，我們最好
其實把它放在數組位置0。

212
00:10:48,790 --> 00:10:50,997
如果我們打算
陣列location--原諒我，

213
00:10:50,997 --> 00:10:53,080
如果我們加入他們在一起，
我們得到了一些

214
00:10:53,080 --> 00:10:56,330
11人是在這裡，我們將不得不把
它，這並不在此array--存在

215
00:10:56,330 --> 00:10:58,200
它會去出界。

216
00:10:58,200 --> 00:11:03,367
我們可以通過10 MOD和放
它在陣列位置1。

217
00:11:03,367 --> 00:11:04,450
所以這是如何工作的隊列。

218
00:11:04,450 --> 00:11:08,540
他們總是會從左邊走
向右並可能環繞。

219
00:11:08,540 --> 00:11:11,280
你知道，他們是
全尺寸的話，那紅色的框，

220
00:11:11,280 --> 00:11:13,710
變得等於容量。

221
00:11:13,710 --> 00:11:16,720
而且我們添加40到打完
隊列，還有什麼我們需要做什麼？

222
00:11:16,720 --> 00:11:19,890
那麼，最古老的元素
在隊列中仍然是19，

223
00:11:19,890 --> 00:11:21,990
所以我們不希望改變
在隊列的前面，

224
00:11:21,990 --> 00:11:23,820
但現在我們有兩個
在隊列中的元素，

225
00:11:23,820 --> 00:11:28,710
所以我們要增加
我們的規模從1到2。

226
00:11:28,710 --> 00:11:31,820
>> 這幾乎是它與
基於陣列的隊列的工作，

227
00:11:31,820 --> 00:11:33,630
和類似的堆疊，
還有一種方式

228
00:11:33,630 --> 00:11:36,450
實現一個隊列作為一個鍊錶。

229
00:11:36,450 --> 00:11:40,150
現在，如果該數據結構類型
看起來很熟悉你，那是。

230
00:11:40,150 --> 00:11:43,780
這不是一個單向鍊錶，
這是一個雙向鍊錶。

231
00:11:43,780 --> 00:11:46,790
而現在，順便說一句，這是
實際上可以實現

232
00:11:46,790 --> 00:11:50,160
隊列作為一個單向鍊錶，但
我認為，在可視化方面，

233
00:11:50,160 --> 00:11:53,350
它實際上可能有助於查看
這是一個雙向鍊錶。

234
00:11:53,350 --> 00:11:56,850
但絕對是可能的
做到這一點作為一個單向鍊錶。

235
00:11:56,850 --> 00:12:00,110
>> 因此，讓我們來看看
這是什麼可能看起來像。

236
00:12:00,110 --> 00:12:02,750
如果我們想enquue--
所以現在，我們再次是

237
00:12:02,750 --> 00:12:05,360
切換到一個連接表
在此基礎的模式。

238
00:12:05,360 --> 00:12:08,420
如果我們要排隊，我們要
以添加新的元件，以及

239
00:12:08,420 --> 00:12:09,730
我們需要什麼做的？

240
00:12:09,730 --> 00:12:12,770
好吧，首先，由於
我們要添加到結束

241
00:12:12,770 --> 00:12:15,520
從除去
開始，我們可能

242
00:12:15,520 --> 00:12:20,050
要保持指針都
頭和鍊錶的尾部？

243
00:12:20,050 --> 00:12:22,660
尾部是另一個術語
鍊錶的末尾，

244
00:12:22,660 --> 00:12:24,496
在該鏈接的表的最後一個元素。

245
00:12:24,496 --> 00:12:26,620
而這些大概會，
再次，是對我們有利

246
00:12:26,620 --> 00:12:28,477
如果他們是全局變量。

247
00:12:28,477 --> 00:12:31,060
但是現在，如果我們想添加一個新的
元素我們有什麼做的？

248
00:12:31,060 --> 00:12:35,262
我們只是[？馬拉克？]或動態
分配我們的新的節點，我們自己。

249
00:12:35,262 --> 00:12:38,220
然後，就像當我們增加任何
元素雙向鍊錶我們，

250
00:12:38,220 --> 00:12:40,410
只需要排序of--
那些過去三年在這裡步驟

251
00:12:40,410 --> 00:12:43,330
只是所有關於移動
正確的方法指針

252
00:12:43,330 --> 00:12:46,710
使得元件被添加到
不破壞鏈的鏈

253
00:12:46,710 --> 00:12:49,580
或使某種錯誤
或有某種意外

254
00:12:49,580 --> 00:12:54,505
發生由此我們意外
孤立我們的隊列中的某些元素。

255
00:12:54,505 --> 00:12:55,880
以下是這可能看起來像。

256
00:12:55,880 --> 00:13:00,980
我們要添加的元素
10到該隊列的末尾。

257
00:13:00,980 --> 00:13:03,380
因此，這裡最古老的元素
由頭表示。

258
00:13:03,380 --> 00:13:06,800
這是我們把第一件事情
到這裡這個假設的隊列。

259
00:13:06,800 --> 00:13:10,430
和尾，13，是最
最近添加的元素。

260
00:13:10,430 --> 00:13:17,030
所以，如果我們要排隊10到
這個隊列，我們希望13後把它。

261
00:13:17,030 --> 00:13:19,860
所以，我們要動態地
分配空間用於新的節點

262
00:13:19,860 --> 00:13:23,280
並檢查空，以確保
我們沒有內存故障。

263
00:13:23,280 --> 00:13:27,040
然後，我們將
放置10到該節點，

264
00:13:27,040 --> 00:13:30,030
現在我們必須要小心
我們如何組織指針

265
00:13:30,030 --> 00:13:32,180
所以我們不打破鏈。

266
00:13:32,180 --> 00:13:38,910
>> 我們可以設置10的先前場
指向回到老尾巴，

267
00:13:38,910 --> 00:13:41,620
並且由於'10將是
在某些時候新的尾巴

268
00:13:41,620 --> 00:13:44,459
由時間所有這些
鏈連接，

269
00:13:44,459 --> 00:13:46,250
沒有什麼會來
10後現在。

270
00:13:46,250 --> 00:13:49,880
所以10的下一個指針
將指向空，

271
00:13:49,880 --> 00:13:53,580
然後當我們做到這一點，我們已經經過
連接10向後鏈，

272
00:13:53,580 --> 00:13:57,780
我們可以採取的老臉，或藉口
我，排隊的老尾巴。

273
00:13:57,780 --> 00:14:02,980
隊列的舊端，
13，並使其指向10。

274
00:14:02,980 --> 00:14:08,220
現在，在這一點上，我們有
入隊的10號到這個隊列中。

275
00:14:08,220 --> 00:14:14,740
現在我們需要做的僅僅是移動
尾指向10，而不是到13。

276
00:14:14,740 --> 00:14:17,630
>> 出隊實際上是
非常相似的彈出

277
00:14:17,630 --> 00:14:21,710
從一個堆棧的
實施為一個鏈接列表

278
00:14:21,710 --> 00:14:24,040
如果你看過堆視頻。

279
00:14:24,040 --> 00:14:27,280
所有我們需要做的就是開始在
開始，找到第二個元素，

280
00:14:27,280 --> 00:14:30,480
釋放第一元件，
然後將頭

281
00:14:30,480 --> 00:14:32,930
為指向第二元件。

282
00:14:32,930 --> 00:14:37,920
可能更好地進行可視化
只是要格外清楚的。

283
00:14:37,920 --> 00:14:39,230
因此，這裡又是我們的隊列中。

284
00:14:39,230 --> 00:14:42,600
12是最古老的元件
在我們的隊列，頭部。

285
00:14:42,600 --> 00:14:46,210
10是最新的元件
在我們的隊列中，我們的尾巴。

286
00:14:46,210 --> 00:14:49,310
>> 所以，當我們要
出列的元素，

287
00:14:49,310 --> 00:14:52,202
我們要刪除的最古老的元素。

288
00:14:52,202 --> 00:14:52,910
那麼我們該怎麼辦？

289
00:14:52,910 --> 00:14:55,243
嗯，我們設置了遍歷指針
即開始於頭部，

290
00:14:55,243 --> 00:14:57,840
我們移動它，使它
指向第二元件

291
00:14:57,840 --> 00:15:02,290
這說TRAV queue--東西
等於TRAV箭頭下，例如，

292
00:15:02,290 --> 00:15:07,170
將移動TRAV有指向
15，其中，當我們出列12，

293
00:15:07,170 --> 00:15:13,030
或之後我們刪除12，將
成為當時最古老的元素。

294
00:15:13,030 --> 00:15:16,360
>> 現在，我們已經有了一個保持在第一
通過指針head元素

295
00:15:16,360 --> 00:15:19,440
和第二元件
通過指針TRAV。

296
00:15:19,440 --> 00:15:25,170
我們現在可以免費的頭，然後我們就可以
說沒有一樣是15前了。

297
00:15:25,170 --> 00:15:29,990
因此，我們可以改變15以前
指針指向空，

298
00:15:29,990 --> 00:15:31,874
我們只是將頭以上。

299
00:15:31,874 --> 00:15:32,540
還有，我們走了。

300
00:15:32,540 --> 00:15:35,840
現在，我們已經成功地
出列12，現在我們

301
00:15:35,840 --> 00:15:39,180
有4個元素另一個隊列。

302
00:15:39,180 --> 00:15:41,700
這幾乎是所有
還有就是排隊，

303
00:15:41,700 --> 00:15:45,810
既基於陣列和鍊錶為主。

304
00:15:45,810 --> 00:15:46,860
我是道格·勞埃德。

305
00:15:46,860 --> 00:15:49,100
這是CS 50。

306
00:15:49,100 --> 00:15:50,763