前面咱们讲解了数组，数组更多的是用来进行数据的存储，纯粹用来存储数据的数据结构，咱们指望的是插入、删除和查找性能都比较好。对于无序数组，插入快，可是删除和查找都很慢，为了解决这些问题，后面咱们会讲解好比二叉树、哈希表的数据结构。java
而本篇博客讲解的数据结构和算法更可能是用做程序员的工具，它们做为构思算法的辅助工具，而不是彻底的数据存储工具。这些数据结构的生命周期比数据库类型的结构要短得多，在程序执行期间它们才被建立，一般用它们去执行某项特殊的业务，执行完成以后，它们就被销毁。这里的它们就是——栈和队列。本篇博客咱们先介绍栈。程序员
一、栈的基本概念
栈（英语：stack）又称为堆栈或堆叠，栈做为一种数据结构，是一种只能在一端进行插入和删除操做的特殊线性表。它按照先进后出的原则存储数据，先进入的数据被压入栈底，最后的数据在栈顶，须要读数据的时候从栈顶开始弹出数据（最后一个数据被第一个读出来）。栈具备记忆做用，对栈的插入与删除操做中，不须要改变栈底指针。算法
栈是容许在同一端进行插入和删除操做的特殊线性表。容许进行插入和删除操做的一端称为栈顶(top)，另外一端为栈底(bottom)；栈底固定，而栈顶浮动；栈中元素个数为零时称为空栈。插入通常称为进栈（PUSH），删除则称为退栈（POP）。数据库
因为堆叠数据结构只容许在一端进行操做，于是按照后进先出（LIFO, Last In First Out）的原理运做。栈也称为后进先出表。数组
这里以羽毛球筒为例，羽毛球筒就是一个栈，刚开始羽毛球筒是空的，也就是空栈，而后咱们一个一个放入羽毛球，也就是一个一个push进栈，当咱们须要使用羽毛球的时候，从筒里面拿，也就是pop出栈，可是第一个拿到的羽毛球是咱们最后放进去的。数据结构
二、Java模拟简单的顺序栈实现
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
|
package
com.ys.datastructure;
public
class
MyStack {
private
int
[] array;
private
int
maxSize;
private
int
top;
public
MyStack(
int
size){
this
.maxSize = size;
array =
new
int
[size];
top = -
1
;
}
//压入数据
public
void
push(
int
value){
if
(top < maxSize-
1
){
array[++top] = value;
}
}
//弹出栈顶数据
public
int
pop(){
return
array[top--];
}
//访问栈顶数据
public
int
peek(){
return
array[top];
}
//判断栈是否为空
public
boolean
isEmpty(){
return
(top == -
1
);
}
//判断栈是否满了
public
boolean
isFull(){
return
(top == maxSize-
1
);
}
}
|
测试：数据结构和算法
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
package
com.ys.test;
import
com.ys.datastructure.MyStack;
public
class
MyStackTest {
public
static
void
main(String[] args) {
MyStack stack =
new
MyStack(
3
);
stack.push(
1
);
stack.push(
2
);
stack.push(
3
);
System.out.println(stack.peek());
while
(!stack.isEmpty()){
System.out.println(stack.pop());
}
}
}
|
结果：工具
这个栈是用数组实现的，内部定义了一个数组，一个表示最大容量的值以及一个指向栈顶元素的top变量。构造方法根据参数规定的容量建立一个新栈，push()方法是向栈中压入元素，指向栈顶的变量top加一，使它指向原顶端数据项上面的一个位置，并在这个位置上存储一个数据。pop()方法返回top变量指向的元素，而后将top变量减一，便移除了数据项。要知道 top 变量指向的始终是栈顶的元素。post
产生的问题：
①、上面栈的实现初始化容量以后，后面是不能进行扩容的（虽然栈不是用来存储大量数据的），若是说后期数据量超过初始容量以后怎么办？（自动扩容）
②、咱们是用数组实现栈，在定义数组类型的时候，也就规定了存储在栈中的数据类型，那么同一个栈能不能存储不一样类型的数据呢？（声明为Object）
③、栈须要初始化容量，并且数组实现的栈元素都是连续存储的，那么能不能不初始化容量呢？（改成由链表实现）
三、加强功能版栈
对于上面出现的问题，第一个能自动扩容，第二个能存储各类不一样类型的数据，解决办法以下：（第三个在讲链表的时候在介绍）
这个模拟的栈在JDK源码中，你们能够参考 Stack 类的实现。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
|
package
com.ys.datastructure;
import
java.util.Arrays;
import
java.util.EmptyStackException;
public
class
ArrayStack {
//存储元素的数组,声明为Object类型能存储任意类型的数据
private
Object[] elementData;
//指向栈顶的指针
private
int
top;
//栈的总容量
private
int
size;
//默认构造一个容量为10的栈
public
ArrayStack(){
this
.elementData =
new
Object[
10
];
this
.top = -
1
;
this
.size =
10
;
}
public
ArrayStack(
int
initialCapacity){
if
(initialCapacity <
0
){
throw
new
IllegalArgumentException(
"栈初始容量不能小于0: "
+initialCapacity);
}
this
.elementData =
new
Object[initialCapacity];
this
.top = -
1
;
this
.size = initialCapacity;
}
//压入元素
public
Object push(Object item){
//是否须要扩容
isGrow(top+
1
);
elementData[++top] = item;
return
item;
}
//弹出栈顶元素
public
Object pop(){
Object obj = peek();
remove(top);
return
obj;
}
//获取栈顶元素
public
Object peek(){
if
(top == -
1
){
throw
new
EmptyStackException();
}
return
elementData[top];
}
//判断栈是否为空
public
boolean
isEmpty(){
return
(top == -
1
);
}
//删除栈顶元素
public
void
remove(
int
top){
//栈顶元素置为null
elementData[top] =
null
;
this
.top--;
}
/**
* 是否须要扩容，若是须要，则扩大一倍并返回true，不须要则返回false
* @param minCapacity
* @return
*/
public
boolean
isGrow(
int
minCapacity){
int
oldCapacity = size;
//若是当前元素压入栈以后总容量大于前面定义的容量，则须要扩容
if
(minCapacity >= oldCapacity){
//定义扩大以后栈的总容量
int
newCapacity =
0
;
//栈容量扩大两倍(左移一位)看是否超过int类型所表示的最大范围
if
((oldCapacity<<
1
) - Integer.MAX_VALUE >
0
){
newCapacity = Integer.MAX_VALUE;
}
else
{
newCapacity = (oldCapacity<<
1
);
//左移一位，至关于*2
}
this
.size = newCapacity;
int
[] newArray =
new
int
[size];
elementData = Arrays.copyOf(elementData, size);
return
true
;
}
else
{
return
false
;
}
}
}
|
测试：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
//测试自定义栈类 ArrayStack
//建立容量为3的栈，而后添加4个元素，3个int，1个String.
@Test
public
void
testArrayStack(){
ArrayStack stack =
new
ArrayStack(
3
);
stack.push(
1
);
//System.out.println(stack.peek());
stack.push(
2
);
stack.push(
3
);
stack.push(
"abc"
);
System.out.println(stack.peek());
stack.pop();
stack.pop();
stack.pop();
System.out.println(stack.peek());
}
|
结果：
四、利用栈实现字符串逆序
咱们知道栈是后进先出，咱们能够将一个字符串分隔为单个的字符，而后将字符一个一个push()进栈，在一个一个pop()出栈就是逆序显示了。以下：
将 字符串“how are you” 反转！！！
ps：这里咱们是用上面自定的栈来实现的，你们能够将ArrayStack替换为JDK自带的栈类Stack试试
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
//进行字符串反转
@Test
public
void
testStringReversal(){
ArrayStack stack =
new
ArrayStack();
String str =
"how are you"
;
char
[] cha = str.toCharArray();
for
(
char
c : cha){
stack.push(c);
}
while
(!stack.isEmpty()){
System.out.print(stack.pop());
}
}
|
结果：
五、利用栈判断分隔符是否匹配
写过xml标签或者html标签的，咱们都知道<必须和最近的>进行匹配，[ 也必须和最近的 ] 进行匹配。
好比：<abc[123]abc>这是符号相匹配的，若是是 <abc[123>abc] 那就是不匹配的。
对于 12<a[b{c}]>，咱们分析在栈中的数据：遇到匹配正确的就消除
最后栈中的内容为空则匹配成功，不然匹配失败！！！
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
|
//分隔符匹配
//遇到左边分隔符了就push进栈，遇到右边分隔符了就pop出栈，看出栈的分隔符是否和这个有分隔符匹配
@Test
public
void
testMatch(){
ArrayStack stack =
new
ArrayStack(
3
);
String str =
"12<a[b{c}]>"
;
char
[] cha = str.toCharArray();
for
(
char
c : cha){
switch
(c) {
case
'{'
:
case
'['
:
case
'<'
:
stack.push(c);
break
;
case
'}'
:
case
']'
:
case
'>'
:
if
(!stack.isEmpty()){
char
ch = stack.pop().toString().toCharArray()[
0
];
if
(c==
'}'
&& ch !=
'{'
|| c==
']'
&& ch !=
'['
|| c==
')'
&& ch !=
'('
){
System.out.println(
"Error:"
+ch+
"-"
+c);
}
}
break
;
default
:
break
;
}
}
}
|
六、总结
根据栈后进先出的特性，咱们实现了单词逆序以及分隔符匹配。因此其实栈是一个概念上的工具，具体能实现什么功能能够由咱们去想象。栈经过提供限制性的访问方法push()和pop()，使得程序不容易出错。
对于栈的实现，咱们稍微分析就知道，数据入栈和出栈的时间复杂度都为O(1)，也就是说栈操做所耗的时间不依赖栈中数据项的个数，所以操做时间很短。并且须要注意的是栈不须要比较和移动操做，咱们不要多此一举。