1
00:00:00,000 --> 00:00:04,074

2
00:00:04,074 --> 00:00:05,990
DOUG LLOYD：好吧，
所以通过这点你

3
00:00:05,990 --> 00:00:09,020
可能很熟悉
数组和链表

4
00:00:09,020 --> 00:00:10,950
这是两个主要
我们已经数据结构

5
00:00:10,950 --> 00:00:16,810
谈到保持套
类似的数据类型的数据组织的。

6
00:00:16,810 --> 00:00:19,080
>> 现在我们要谈
约上几个变化

7
00:00:19,080 --> 00:00:20,330
对数组和链表。

8
00:00:20,330 --> 00:00:22,362
在这个视频中，我们要去
谈栈。

9
00:00:22,362 --> 00:00:25,320
具体来说，我们要谈
有关的数据结构称为堆叠。

10
00:00:25,320 --> 00:00:28,510
从前面的讨论召回
关于指针和内存，

11
00:00:28,510 --> 00:00:32,060
堆栈也是
命名为的存储器段

12
00:00:32,060 --> 00:00:34,980
其中，静态声明
memory--内存，你

13
00:00:34,980 --> 00:00:38,730
名称，命名变量，等
等等和功能框架，我们也

14
00:00:38,730 --> 00:00:41,000
调用堆栈帧的存在。

15
00:00:41,000 --> 00:00:45,421
所以这是一个堆栈数据结构
记忆不是一个堆栈段。

16
00:00:45,421 --> 00:00:45,920
好。

17
00:00:45,920 --> 00:00:46,890
>> 但什么是栈？

18
00:00:46,890 --> 00:00:49,220
所以这是非常简单，只是一个
特殊的结构

19
00:00:49,220 --> 00:00:51,190
在一个有组织的方式保持数据。

20
00:00:51,190 --> 00:00:53,760
而且还有两个很
常见的方式来实现

21
00:00:53,760 --> 00:00:57,380
栈使用两个数据结构
我们已经很熟悉了，

22
00:00:57,380 --> 00:01:00,340
数组和链表。

23
00:01:00,340 --> 00:01:04,430
是什么让一个堆栈特别是
以何种方式，我们把信息

24
00:01:04,430 --> 00:01:08,200
入堆栈，这样我们的方式
请从堆栈信息。

25
00:01:08,200 --> 00:01:11,600
尤其是对于栈
规则是只有最

26
00:01:11,600 --> 00:01:15,830
最近添加的元素可以被删除。

27
00:01:15,830 --> 00:01:17,660
>> 这样想来，好像它是一个堆栈。

28
00:01:17,660 --> 00:01:21,170
我们正在打桩信息
其本身上，

29
00:01:21,170 --> 00:01:24,271
只有东西在顶部
桩的可以去掉。

30
00:01:24,271 --> 00:01:27,020
我们不能下删除的东西
因为一切会

31
00:01:27,020 --> 00:01:28,020
折叠和翻倒。

32
00:01:28,020 --> 00:01:32,580
所以，我们真的正在建设一个栈
然后，我们必须逐件除去件。

33
00:01:32,580 --> 00:01:36,590
正因为如此，我们通常所指
到堆栈作为LIFO结构，

34
00:01:36,590 --> 00:01:38,940
后进先出。

35
00:01:38,940 --> 00:01:42,290
后进先出法，后进先出。

36
00:01:42,290 --> 00:01:45,635
>> 所以这个限制的，因为
信息如何可以被添加到

37
00:01:45,635 --> 00:01:49,080
而从堆栈中删除，没什么
只有两件事情，我们可以用堆栈来。

38
00:01:49,080 --> 00:01:52,010
我们可以推动，这是
我们长期使用的添加

39
00:01:52,010 --> 00:01:55,130
一个新元素的顶部
叠，或者如果栈不存在

40
00:01:55,130 --> 00:01:58,550
我们正在从头开始创建它，
创建堆栈摆在首位

41
00:01:58,550 --> 00:02:00,110
将推动。

42
00:02:00,110 --> 00:02:04,990
然后弹出，这是CS的那种
长期我们用它来删除最近

43
00:02:04,990 --> 00:02:08,330
从堆栈的顶部添加元素。

44
00:02:08,330 --> 00:02:11,130
>> 因此，我们要看看这两个
实现，无论是基于阵列的

45
00:02:11,130 --> 00:02:13,120
和链表为主。

46
00:02:13,120 --> 00:02:14,870
而且我们要
开始的数组。

47
00:02:14,870 --> 00:02:19,990
因此，这里的基本想法是什么
在基于阵列的堆栈数据结构

48
00:02:19,990 --> 00:02:21,140
会是什么样子。

49
00:02:21,140 --> 00:02:23,740
我们在这里有一个类型的定义。

50
00:02:23,740 --> 00:02:27,790
里面的，我们有两个成员
结构或字段。

51
00:02:27,790 --> 00:02:29,880
我们有一个数组。

52
00:02:29,880 --> 00:02:32,400
又一次我使用的
任意数据类型的值。

53
00:02:32,400 --> 00:02:35,180
>> 因此，这可以是任何类型的数据，
INT char或其他一些数据

54
00:02:35,180 --> 00:02:37,080
你以前创建的类型。

55
00:02:37,080 --> 00:02:39,861
因此，我们有大小容量的阵列。

56
00:02:39,861 --> 00:02:44,010
容量正在一斤定义的常量，
也许别人在我们的文件的地方。

57
00:02:44,010 --> 00:02:47,550
因此，与这个特定的已通知
实现我们的边界

58
00:02:47,550 --> 00:02:49,800
自己作为是典型的
数组的情况下，

59
00:02:49,800 --> 00:02:53,170
这是我们无法动态调整，
那里有一定数量

60
00:02:53,170 --> 00:02:55,450
最大元素
我们可以把我们的堆栈。

61
00:02:55,450 --> 00:02:57,930
在这种情况下，它的电容元件。

62
00:02:57,930 --> 00:03:00,310
>> 我们也跟踪
堆栈的顶部。

63
00:03:00,310 --> 00:03:04,350
什么元素最重要的是
最近添加到栈？

64
00:03:04,350 --> 00:03:07,470
因此，我们持续跟踪
在一个变量被称为顶端。

65
00:03:07,470 --> 00:03:11,692
而所有这一切都被包裹起来
成称为栈一个新的数据类型。

66
00:03:11,692 --> 00:03:13,400
而一旦我们创建
这个新的数据类型

67
00:03:13,400 --> 00:03:15,410
我们可以把它像
任何其它数据类型。

68
00:03:15,410 --> 00:03:20,970
我们可以声明堆栈S，就像
我们可以做INT x或字符年。

69
00:03:20,970 --> 00:03:22,990
而当我们说堆栈
S，以及会发生什么

70
00:03:22,990 --> 00:03:26,420
是我们得到了一组
内存预留了我们。

71
00:03:26,420 --> 00:03:28,770
>> 在这种情况下，容量
我显然决定

72
00:03:28,770 --> 00:03:33,470
是10，因为我有一个
型堆的单可变

73
00:03:33,470 --> 00:03:35,320
其中包含两个字段回忆。

74
00:03:35,320 --> 00:03:38,330
的阵列，在这种情况下，会
是一个整数数组

75
00:03:38,330 --> 00:03:40,440
因为在我的大部分例子的情况。

76
00:03:40,440 --> 00:03:43,996
而另一位整型变量
能够存储的顶部，

77
00:03:43,996 --> 00:03:45,870
最近添加
元件到堆栈中。

78
00:03:45,870 --> 00:03:50,290
因此，一个单一的堆栈我们
刚刚定义看起来像这样。

79
00:03:50,290 --> 00:03:53,190
它包含一个盒子
的10的阵列什么

80
00:03:53,190 --> 00:03:57,280
将在这种情况下，整数和
在绿色的另一个整型变量有

81
00:03:57,280 --> 00:04:00,010
以指示堆栈的顶部。

82
00:04:00,010 --> 00:04:02,600
>> 要设置的顶部
堆栈，我们只是说s.top。

83
00:04:02,600 --> 00:04:04,890
这就是我们访问
场的结构召回。

84
00:04:04,890 --> 00:04:10,460
s.top有效等于0
这样做是为了我们的堆栈。

85
00:04:10,460 --> 00:04:12,960
所以，再一次，我们有两个操作
我们现在可以执行。

86
00:04:12,960 --> 00:04:14,270
我们可以把我们可以弹出。

87
00:04:14,270 --> 00:04:15,635
让我们先从推动。

88
00:04:15,635 --> 00:04:18,260
再次，推是添加了新的
元素添加到堆栈的顶部。

89
00:04:18,260 --> 00:04:21,460
>> 那么，我们需要做的
这种基于阵列的实现？

90
00:04:21,460 --> 00:04:23,210
那么一般
推送功能会

91
00:04:23,210 --> 00:04:26,160
到需要接受
指针到堆栈。

92
00:04:26,160 --> 00:04:28,610
现在，花一秒钟想想。

93
00:04:28,610 --> 00:04:32,840
为什么我们要接受
指针堆栈？

94
00:04:32,840 --> 00:04:36,830
从以往的视频回忆
变量的作用域和指针，

95
00:04:36,830 --> 00:04:42,350
如果我们只是派会发生什么
堆栈，S而作为一个参数？

96
00:04:42,350 --> 00:04:45,770
但实际在那里被传递？

97
00:04:45,770 --> 00:04:49,430
请记住，我们正在创建一个副本
当我们把它传递给函数

98
00:04:49,430 --> 00:04:51,160
除非我们使用指针。

99
00:04:51,160 --> 00:04:55,380
所以这个功能推动需求
以接受的指针堆栈

100
00:04:55,380 --> 00:04:59,160
让我们实际上改变
堆栈，我们打算改变。

101
00:04:59,160 --> 00:05:03,060
>> 另一件事推可能要
接受的类型值的数据元素。

102
00:05:03,060 --> 00:05:06,970
在这种情况下，再次，一个整数，
我们要添加到堆栈的顶部。

103
00:05:06,970 --> 00:05:08,680
因此，我们有我们的两个参数。

104
00:05:08,680 --> 00:05:11,310
什么是我们要
现在做俯卧撑里面？

105
00:05:11,310 --> 00:05:14,860
好了，简单地说，我们只是要添加
该元素到堆栈的顶部

106
00:05:14,860 --> 00:05:22,860
然后更改的，其中的顶部
堆栈，使得S点顶部的值。

107
00:05:22,860 --> 00:05:25,639
因此，这是一个函数
声明推

108
00:05:25,639 --> 00:05:27,680
可能看起来像在
基于数组的实现。

109
00:05:27,680 --> 00:05:30,967
>> 同样，这不是一个硬性规定
你可以改变这一点，有

110
00:05:30,967 --> 00:05:32,050
它以不同的方式而变化。

111
00:05:32,050 --> 00:05:33,840
也许s的全局声明。

112
00:05:33,840 --> 00:05:36,180
所以你甚至不需要
通过它是作为一个参数。

113
00:05:36,180 --> 00:05:39,125
这又是只是一个
一般情况下推动。

114
00:05:39,125 --> 00:05:41,000
也有不同
的方式来实现它。

115
00:05:41,000 --> 00:05:42,810
但在这种情况下，我们
推是要采取

116
00:05:42,810 --> 00:05:48,540
两个参数，一个指向一个堆栈和
类型值，整数的数据元素

117
00:05:48,540 --> 00:05:49,840
在这种情况下。

118
00:05:49,840 --> 00:05:52,100
>> 因此，我们宣布S，我们
说s.top等于0。

119
00:05:52,100 --> 00:05:55,969
现在让我们来推
28号到堆栈中。

120
00:05:55,969 --> 00:05:57,010
那么这是什么意思？

121
00:05:57,010 --> 00:05:59,600
那么目前
栈顶部是0。

122
00:05:59,600 --> 00:06:01,350
所以，什么是基本
事情发生是

123
00:06:01,350 --> 00:06:05,820
我们要坚持数
28到数组的位置0。

124
00:06:05,820 --> 00:06:09,540
很简单，对了，那
是顶部，现在我们是好去。

125
00:06:09,540 --> 00:06:12,910
然后，我们需要改变什么
堆栈的顶部会。

126
00:06:12,910 --> 00:06:15,130
因此，下一次
我们推入一个元素，

127
00:06:15,130 --> 00:06:18,017
我们将其存储在
阵列位置，可能不是0。

128
00:06:18,017 --> 00:06:20,100
我们不希望覆盖
我们刚才放在那里。

129
00:06:20,100 --> 00:06:23,510
所以我们只将顶到1。

130
00:06:23,510 --> 00:06:24,890
这可能是有道理的。

131
00:06:24,890 --> 00:06:28,940
>> 现在，如果我们想要把另一个元素
压入堆栈，说我们要推33，

132
00:06:28,940 --> 00:06:33,190
现在好了，我们只是将采取33
并把它在数组位置数

133
00:06:33,190 --> 00:06:37,580
1，然后更改的顶部我们
堆栈是数组位置排名第二。

134
00:06:37,580 --> 00:06:40,650
因此，如果在下一次我们要
推一个元素入栈中，

135
00:06:40,650 --> 00:06:43,087
它会被放在数组位置2。

136
00:06:43,087 --> 00:06:44,420
而让我们做一个更多的时间。

137
00:06:44,420 --> 00:06:45,753
我们将推动19关栈。

138
00:06:45,753 --> 00:06:48,940
我们将投入19阵列的位置2
和改变我们的堆栈的顶部

139
00:06:48,940 --> 00:06:51,220
要阵列的位置3
所以如果下一次我们

140
00:06:51,220 --> 00:06:54,780
需要做一个推，我们是好去。

141
00:06:54,780 --> 00:06:56,980
>> OK，所以这是推动概括地说。

142
00:06:56,980 --> 00:06:57,830
什么大跌眼镜？

143
00:06:57,830 --> 00:07:00,240
所以大跌眼镜的是排序
对口推。

144
00:07:00,240 --> 00:07:02,720
这是我们如何从堆栈中删除数据。

145
00:07:02,720 --> 00:07:04,610
而在一般流行音乐的需求
做到以下几点。

146
00:07:04,610 --> 00:07:07,600
它需要接受的指针
叠，再在一般情况下。

147
00:07:07,600 --> 00:07:10,480
在其他一些情况下，你可能
已宣布在全球范围堆栈，

148
00:07:10,480 --> 00:07:13,910
在这种情况下，你不需要将它传递
在因为它已经访问了它

149
00:07:13,910 --> 00:07:15,541
作为全局变量。

150
00:07:15,541 --> 00:07:17,040
但随后还有什么需要我们做什么？

151
00:07:17,040 --> 00:07:21,000
嗯，我们都递增
叠推的顶部，

152
00:07:21,000 --> 00:07:24,050
所以我们可能会想
递减堆栈的顶部

153
00:07:24,050 --> 00:07:25,009
在流行音乐，对不对？

154
00:07:25,009 --> 00:07:26,800
然后当然
我们也将要

155
00:07:26,800 --> 00:07:29,240
回到我们删除值。

156
00:07:29,240 --> 00:07:32,125
如果我们要添加的元素，我们希望
得到的元素出来以后，

157
00:07:32,125 --> 00:07:34,000
我们可能实际上
要存储他们，所以我们

158
00:07:34,000 --> 00:07:36,490
不只是从删除
堆栈中，然后什么也不做他们。

159
00:07:36,490 --> 00:07:38,500
一般来说，如果我们
推和弹出在这里

160
00:07:38,500 --> 00:07:41,250
我们要存储此
以有意义的方式信息

161
00:07:41,250 --> 00:07:43,250
因此它不会使
感觉只是丢弃它。

162
00:07:43,250 --> 00:07:46,380
所以这个功能应该
可能返回一个值给我们。

163
00:07:46,380 --> 00:07:51,040
>> 因此，这是一个多么声明流行
可能看起来像有在左上角。

164
00:07:51,040 --> 00:07:53,870
该函数返回
类型值的数据。

165
00:07:53,870 --> 00:07:56,320
我们再次使用已经
整数贯穿始终。

166
00:07:56,320 --> 00:08:01,916
和它接受一个指向一个堆栈
其唯一的参数或唯一的参数。

167
00:08:01,916 --> 00:08:03,040
那么，什么是流行音乐该怎么办？

168
00:08:03,040 --> 00:08:07,990
比方说，我们希望现在
流行元素断号第

169
00:08:07,990 --> 00:08:14,000
所以请记住我说的堆栈是最后一个
先出，后进先出的数据结构。

170
00:08:14,000 --> 00:08:17,855
该元件是要
从栈中删除？

171
00:08:17,855 --> 00:08:21,780

172
00:08:21,780 --> 00:08:24,150
你猜19？

173
00:08:24,150 --> 00:08:25,290
因为你是对的。

174
00:08:25,290 --> 00:08:28,836
19是我们加入的最后一个元素
当我们在推动元件堆叠，

175
00:08:28,836 --> 00:08:31,210
所以它会第一
元素被删除。

176
00:08:31,210 --> 00:08:34,780
这是因为如果我们说28，和
然后我们把33在它的上面，

177
00:08:34,780 --> 00:08:36,659
我们把19最重要的是。

178
00:08:36,659 --> 00:08:40,650
我们可以脱下唯一的元素是19。

179
00:08:40,650 --> 00:08:45,019
>> 现在，这里的图中我做了什么
是那种从阵列中删除19。

180
00:08:45,019 --> 00:08:46,810
这实际上不是
我们要做的。

181
00:08:46,810 --> 00:08:48,934
我们只是来样
中假装它不存在。

182
00:08:48,934 --> 00:08:51,441
它仍然存在于
该内存位置，

183
00:08:51,441 --> 00:08:54,190
但我们只是要忽略它
通过改变我们的堆栈的顶部

184
00:08:54,190 --> 00:08:56,080
从为3至2。

185
00:08:56,080 --> 00:08:58,720
所以，如果我们现在推
另一元件压入堆栈，

186
00:08:58,720 --> 00:09:00,720
它会在写19。

187
00:09:00,720 --> 00:09:03,990
>> 但是，我们不要经历的麻烦
中删除19从堆栈中。

188
00:09:03,990 --> 00:09:05,830
我们可以假装它不存在。

189
00:09:05,830 --> 00:09:11,107
为了堆栈就不见了，如果
我们改变顶端是2而不是3。

190
00:09:11,107 --> 00:09:12,690
好了，所以这是相当多了。

191
00:09:12,690 --> 00:09:15,080
这就是我们需要做的
流行元素了。

192
00:09:15,080 --> 00:09:16,090
让我们再来一次。

193
00:09:16,090 --> 00:09:18,610
所以，我已经强调了它在红色这里
表明我们正在做另一个电话。

194
00:09:18,610 --> 00:09:19,720
我们将做同样的事情。

195
00:09:19,720 --> 00:09:20,803
>> 那么，什么会发生？

196
00:09:20,803 --> 00:09:23,670
好了，我们要保存
33 x和我们要去

197
00:09:23,670 --> 00:09:26,217
到堆栈的顶部改变到1。

198
00:09:26,217 --> 00:09:29,050
所以，如果我们现在推的
元素进栈，我们是

199
00:09:29,050 --> 00:09:31,610
要做的事情，现在，
什么会发生

200
00:09:31,610 --> 00:09:36,367
是我们要覆盖
阵列位置号码1。

201
00:09:36,367 --> 00:09:38,950
所以这33类中所剩下的
后面，我们只是假装

202
00:09:38,950 --> 00:09:44,390
不存在了，我们只是
要破坏它，并把40同去。

203
00:09:44,390 --> 00:09:46,290
然后，当然，
因为我们做了一个推，

204
00:09:46,290 --> 00:09:48,780
我们要递增
栈顶部1〜2

205
00:09:48,780 --> 00:09:50,950
这样，如果我们现在添加
另一种元素，它会

206
00:09:50,950 --> 00:09:54,700
进入阵列的位置排名第二。

207
00:09:54,700 --> 00:09:57,590
>> 现在链表是另一种
方法来实现堆栈。

208
00:09:57,590 --> 00:10:01,210
而如果在这个定义
屏幕这里看起来很熟悉你，

209
00:10:01,210 --> 00:10:04,260
这是因为它看起来几乎
完全相同的，事实上，

210
00:10:04,260 --> 00:10:07,790
它几乎是完全
同一个单向链表，

211
00:10:07,790 --> 00:10:11,990
如果你从我们的讨论召回
在另一个视频单链表。

212
00:10:11,990 --> 00:10:15,510
这里的唯一限制
对我们来说是程序员，

213
00:10:15,510 --> 00:10:17,900
我们不允许
插入或删除随机

214
00:10:17,900 --> 00:10:20,620
从单向链表
这是我们可以做以前。

215
00:10:20,620 --> 00:10:25,820
只是现在我们可以插入和删除从
前面或的连接的顶端

216
00:10:25,820 --> 00:10:26,320
名单。

217
00:10:26,320 --> 00:10:28,028
这真的是唯一的
区别不过。

218
00:10:28,028 --> 00:10:29,700
这是否则单链表。

219
00:10:29,700 --> 00:10:32,060
这是唯一的限制
替换上自己

220
00:10:32,060 --> 00:10:35,770
作为程序员
改变成一个堆栈。

221
00:10:35,770 --> 00:10:39,280
>> 这里的规则是始终保持
指针的一个链表的头部。

222
00:10:39,280 --> 00:10:41,520
当然，这是一个通常
第一个重要的规则。

223
00:10:41,520 --> 00:10:44,260
对于单向链表，反正你
只需要一个指向头部

224
00:10:44,260 --> 00:10:46,160
为了有
链能够参考

225
00:10:46,160 --> 00:10:48,596
至所有其他元素
在链表。

226
00:10:48,596 --> 00:10:50,470
但它是特别
重要用栈。

227
00:10:50,470 --> 00:10:52,386
所以一般你
要真正想要的

228
00:10:52,386 --> 00:10:54,090
这个指针是一个全局变量。

229
00:10:54,090 --> 00:10:56,574
它可能会
可以更容易的方式。

230
00:10:56,574 --> 00:10:58,240
那么什么是push和pop的类似物？

231
00:10:58,240 --> 00:10:58,740
对。

232
00:10:58,740 --> 00:11:01,812
所以推再次增加
一个新的元素到堆栈。

233
00:11:01,812 --> 00:11:03,770
在一个链表
意味着我们将有

234
00:11:03,770 --> 00:11:07,770
创建一个新的节点，我们是
将添加入链表，

235
00:11:07,770 --> 00:11:10,500
然后按照谨慎的步骤
我们先前已经介绍

236
00:11:10,500 --> 00:11:16,050
在单链表将其添加到
不破坏链的链

237
00:11:16,050 --> 00:11:18,900
和丢失或成为孤儿的任何
链表元素。

238
00:11:18,900 --> 00:11:21,820
而这基本上是什么
文本的小斑点有总结。

239
00:11:21,820 --> 00:11:23,740
让我们一起来看看
它作为一个图。

240
00:11:23,740 --> 00:11:24,823
>> 因此，这里是我们的链表。

241
00:11:24,823 --> 00:11:26,620
它同时包含四个要素。

242
00:11:26,620 --> 00:11:30,420
而更加完美地在这里是我们的
堆栈包含四个元素。

243
00:11:30,420 --> 00:11:36,030
而且，我们说，我们现在要
推新项目到这个堆栈中。

244
00:11:36,030 --> 00:11:39,792
我们要推新
其数据的价值产品12。

245
00:11:39,792 --> 00:11:41,000
那么我们怎么办呢？

246
00:11:41,000 --> 00:11:43,420
那么首先我们要
malloc的空间，动态

247
00:11:43,420 --> 00:11:45,411
分配空间用于新的节点。

248
00:11:45,411 --> 00:11:48,160
当然，紧接着又
我们打​​电话到我们的malloc始终

249
00:11:48,160 --> 00:11:52,989
一定要检查空，
因为如果我们得到了空回

250
00:11:52,989 --> 00:11:54,280
有某种问题。

251
00:11:54,280 --> 00:11:57,570
我们不希望取消引用的空
指针，否则就惨了赛格故障。

252
00:11:57,570 --> 00:11:58,510
这不好。

253
00:11:58,510 --> 00:11:59,760
因此，我们已经malloced节点。

254
00:11:59,760 --> 00:12:01,260
我们假设，我们已经在这里取得了成功。

255
00:12:01,260 --> 00:12:06,090
我们打​​算把12进
该节点的数据字段。

256
00:12:06,090 --> 00:12:11,570
现在，你还记得，我们的指针
移动下一个，所以我们不打破链？

257
00:12:11,570 --> 00:12:15,100
我们有几个选项，在这里，但
是唯一一个将是安全的

258
00:12:15,100 --> 00:12:19,330
是集新闻下一指针
指向老首长名单

259
00:12:19,330 --> 00:12:21,360
或者是不久将成为
老首长的名单。

260
00:12:21,360 --> 00:12:23,610
而现在，我们所有的
元素链接在一起，

261
00:12:23,610 --> 00:12:27,370
我们只要将名单指向
那个新不一样的地方。

262
00:12:27,370 --> 00:12:33,550
现在我们已经有效地推了
新元件压入堆栈的前面。

263
00:12:33,550 --> 00:12:36,420
>> 要跳出我们只是想
删除第一个元素。

264
00:12:36,420 --> 00:12:38,150
所以基本上是什么
我们要在这里做，

265
00:12:38,150 --> 00:12:40,050
同时，我们必须找到第二个元素。

266
00:12:40,050 --> 00:12:43,540
最终，这将成为新的
头后，我们删除了第一个。

267
00:12:43,540 --> 00:12:47,300
所以，我们只需要从开始
开始的时候，移动一个前锋。

268
00:12:47,300 --> 00:12:50,340
一旦我们已经有了一个保持在一个
在那里，我们期待目前

269
00:12:50,340 --> 00:12:53,850
是我们可以安全地删除第一个
然后我们就可以将头

270
00:12:53,850 --> 00:12:57,150
指向究竟是什么
第二项，然后现

271
00:12:57,150 --> 00:12:59,170
是之后，第一
节点已被删除。

272
00:12:59,170 --> 00:13:01,160
>> 如此反复，考虑看看
它作为一个图，我们

273
00:13:01,160 --> 00:13:05,022
希望现在流行的
元素关闭该堆栈。

274
00:13:05,022 --> 00:13:05,730
那么我们该怎么办？

275
00:13:05,730 --> 00:13:08,188
那么我们首先要创建
一个新的指针是怎么回事

276
00:13:08,188 --> 00:13:10,940
为指向相同的位置为头。

277
00:13:10,940 --> 00:13:13,790
我们要移动一个位置
向前说TRAV等号

278
00:13:13,790 --> 00:13:17,510
TRAV接下来为例，它
将推进TRAV指针1

279
00:13:17,510 --> 00:13:19,324
位置前移。

280
00:13:19,324 --> 00:13:21,240
现在，我们已经有了一个
保持第一元件上

281
00:13:21,240 --> 00:13:24,573
通过该指针叫列表，以及
通过指针称为第二元件

282
00:13:24,573 --> 00:13:28,692
TRAV，我们可以安全地删除
从栈第一元件

283
00:13:28,692 --> 00:13:30,650
不失休息
链，因为我们

284
00:13:30,650 --> 00:13:32,358
有办法参考
到第二元件

285
00:13:32,358 --> 00:13:34,780
由前进的道路
指针称为TRAV。

286
00:13:34,780 --> 00:13:37,100
>> 所以，现在我们可以免费在该节点。

287
00:13:37,100 --> 00:13:38,404
我们可以免费列表。

288
00:13:38,404 --> 00:13:41,320
然后将所有我们现在需要做的是
移动列表指向同一个地方

289
00:13:41,320 --> 00:13:44,482
这TRAV做，而且我们的排序回
我们开始的地方，我们推12日前

290
00:13:44,482 --> 00:13:45,690
在第一地点，合适。

291
00:13:45,690 --> 00:13:46,940
这正是我们在那里。

292
00:13:46,940 --> 00:13:48,840
我们有这四款元素堆栈。

293
00:13:48,840 --> 00:13:49,690
我们增加了五分之一。

294
00:13:49,690 --> 00:13:51,910
我们推第五
元素，然后我们

295
00:13:51,910 --> 00:13:55,980
杀出，以最近
加元回退。

296
00:13:55,980 --> 00:13:58,816
>> 这真是非常
所有有栈。

297
00:13:58,816 --> 00:14:00,190
您可以实施他们作为阵列。

298
00:14:00,190 --> 00:14:01,815
您可以执行这些链表。

299
00:14:01,815 --> 00:14:04,810
还有，当然，其他
方法来实现它们。

300
00:14:04,810 --> 00:14:09,060
基本上，我们将使用的原因
栈是维持在这样的方式的数据

301
00:14:09,060 --> 00:14:12,090
该最近添加
元素是我们的第一件事情

302
00:14:12,090 --> 00:14:14,980
会想回去。

303
00:14:14,980 --> 00:14:17,900
我是道格·劳埃德，这是CS50。

304
00:14:17,900 --> 00:14:19,926