前面咱們講解了數組，數組更多的是用來進行數據的存儲，純粹用來存儲數據的數據結構，咱們指望的是插入、刪除和查找性能都比較好。對於無序數組，插入快，可是刪除和查找都很慢，爲了解決這些問題，後面咱們會講解好比二叉樹、哈希表的數據結構。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)，也就是說棧操做所耗的時間不依賴棧中數據項的個數，所以操做時間很短。並且須要注意的是棧不須要比較和移動操做，咱們不要多此一舉。