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