定義
先入後出，有點類似將書放在抽屜裏，先放進去的書，如果想拿到他，必須將他上面書拿完纔可以，粗俗的形容可以這麼比喻：“吃了吐”叫棧，“吃了拉”叫隊列，話粗理不粗。棧是一種“操作受限”的線性表，只允許一段插入和刪除數據。
從功能上看，數組或鏈表確實可代替棧，但是在特定的情況中，數組和鏈表暴露的接口太多，操作上雖然靈活，但是很多條件不可控，使用上當然容易出現問題。
當某個數據集合只涉及在一段插入和刪除數據，並且滿足先進後出的特性，我們就應該首選棧這種數據結構。
實現
根據其定義和特點，棧主要包含兩個操作，入棧和出棧。數組和鏈表都可以實現，用數組實現的棧叫做 順序棧，用鏈表實現的棧叫做 鏈式棧。後面會貼上具體的實現代碼和測試用例。
棧存儲數據只需要一個大小爲 n 的數組就足夠了，在操作數據的過程中，只需要一兩個臨時變量存儲空間，所以空間複雜度是 O(1)，至於入棧和出棧的時間複雜度也是 O(1)。
練習
數組實現棧(支持動態擴容)
需要注意點：
- 當數據不斷增加，大小達到閾值，也就是容器滿了，此時大小需要擴容到原來的兩倍。
- 當數據不斷減小，大小達到整個大小四分之一時，此時大小需要縮小爲原來的 1/2。
class ArrayStack<T> implements Iterable<T>{
private T[] data;
private int totalCount;
private int count;
ArrayStack(int capacity) {
data = (T[]) new Object[capacity];
totalCount = capacity;
}
private boolean push(T t) {
if (count == totalCount) {
resize(totalCount * 2);
}
data[count] = t;
count++;
System.out.println("push: " + t + " data:\t" + Arrays.toString(data));
return true;
}
private T pop() {
if (count == 0) return null;
T t = data[count - 1];
data[count - 1] = null;
count --;
if (count == totalCount / 4 && totalCount / 2 != 0) {
resize(totalCount / 2);
}
System.out.println("pop: " + t + " data:\t" + Arrays.toString(data));
return t;
}
boolean isEmpty() {
return count == 0;
}
int size() {
return count;
}
T peek() {
if (count == 0) {
return null;
}
T t = data[count - 1];
System.out.println("peek: " + t + " data:\t" + Arrays.toString(data));
return t;
}
private void resize(int newSize) {
T[] newData = (T[]) new Object[newSize];
for (int i = 0; i < count; i++) {
newData[i] = data[i];
}
totalCount = newData.length;
System.out.println("擴容前：" + data.length);
data = newData;
System.out.println("重新調整大小:\t" + data.length + " data:\t" + Arrays.toString(data));
}
public static void main(String[] args) {
ArrayStack<Integer> data = new ArrayStack<Integer>(4);
data.push(1);
data.push(2);
data.push(3);
data.push(4);
data.push(5);
data.push(6);
System.out.println("size:\t" + data.size());
System.out.println("isEmpty:\t" + data.isEmpty());
for (Integer datum : data) {
System.out.print(datum);
}
System.out.println();
data.pop();
data.pop();
data.pop();
data.pop();
data.peek();
data.peek();
data.peek();
}
@Override
public Iterator<T> iterator() {
return new ArrayIterator();
}
class ArrayIterator implements Iterator<T> {
int i = count;
@Override
public boolean hasNext() {
return i > 0;
}
@Override
public T next() {
return data[--i];
}
@Override
public void remove() {
}
}
}
這裏如果需要支持加強 for 循環，則需要創建自定義實現 Iterator 類。
運行結果：
push: 1 data: [1, null, null, null]
push: 2 data: [1, 2, null, null]
push: 3 data: [1, 2, 3, null]
push: 4 data: [1, 2, 3, 4]
擴容前：4
重新調整大小: 8 data: [1, 2, 3, 4, null, null, null, null]
push: 5 data: [1, 2, 3, 4, 5, null, null, null]
push: 6 data: [1, 2, 3, 4, 5, 6, null, null]
size: 6
isEmpty: false
654321
pop: 6 data: [1, 2, 3, 4, 5, null, null, null]
pop: 5 data: [1, 2, 3, 4, null, null, null, null]
pop: 4 data: [1, 2, 3, null, null, null, null, null]
擴容前：8
重新調整大小: 4 data: [1, 2, null, null]
pop: 3 data: [1, 2, null, null]
peek: 2 data: [1, 2, null, null]
peek: 2 data: [1, 2, null, null]
peek: 2 data: [1, 2, null, null]
鏈表實現棧
需要注意的是臨界值的判斷。
class LinkedStack<T> implements Iterable<T> {
Node<T> head = null;
int count = 0;
void push(T t) {
Node<T> node = createNode(t);
if (head == null) {
head = node;
} else {
node.next = head;
head = node;
}
count++;
System.out.println("push:\t" + t + " data:\t" + head.toString());
}
T pop() {
if (head == null) {
return null;
}
T t = head.value;
head = head.next;
if (head != null) {
System.out.println("pop:\t" + t + " data:\t" + head.toString());
} else {
System.out.println("pop:\t" + t + " data:\tnull");
}
count--;
return t;
}
boolean isEmpty() {
return count == 0;
}
int size() {
return count;
}
T peek() {
if (head == null) {
return null;
}
T t = head.value;
System.out.println("peek:\t" + t + " data:\t" + head.toString());
return t;
}
Node<T> createNode(T t) {
return new Node<T>(t, null);
}
public static void main(String[] args) {
LinkedStack<Integer> stack = new LinkedStack<Integer>();
stack.push(1);
stack.push(2);
stack.push(3);
stack.push(4);
System.out.println("size:\t" + stack.size());
System.out.println("isEmpty:\t" + stack.isEmpty());
for (Integer integer : stack) {
System.out.println(integer);
}
stack.peek();
stack.peek();
stack.peek();
stack.pop();
stack.pop();
stack.pop();
stack.pop();
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
for (T t : this) {
sb.append(t).append(" ");
}
sb.append("\n");
return sb.toString();
}
void clear() {
head = null;
count = 0;
}
@Override
public Iterator<T> iterator() {
return new LinkedIterator();
}
class LinkedIterator implements Iterator<T> {
Node<T> first = head;
int n = count;
@Override
public boolean hasNext() {
return n > 0;
}
@Override
public T next() {
T t = first.value;
first = first.next;
n--;
return t;
}
@Override
public void remove() {
}
}
}
運行結果：
push: 1 data: 1
push: 2 data: 2 1
push: 3 data: 3 2 1
push: 4 data: 4 3 2 1
size: 4
isEmpty: false
4321
peek: 4 data: 4 3 2 1
peek: 4 data: 4 3 2 1
peek: 4 data: 4 3 2 1
pop: 4 data: 3 2 1
pop: 3 data: 2 1
pop: 2 data: 1
pop: 1 data: null
棧在括號匹配中的應用
括號一般都是一一對應的，那可以用棧保存未匹配的左括號，從左到又進行掃描。
class StackTest1 {
public static void main(String[] args) {
LinkedStack<String> stack = new LinkedStack<String>();
stack.push("[");
stack.push("{");
stack.push("『");
stack.push("「");
stack.push("」");
stack.push("』");
stack.push("}");
stack.push("]");
System.out.println(stack.toString());
System.out.println("is correct:\t" + isCorrect(stack));
}
private static boolean isCorrect(LinkedStack<String> stack) {
boolean isCorrect = true;
LinkedStack<String> stack1 = new LinkedStack<String>();
for (String s : stack) {
stack1.push(s);
}
Iterator<String> iterator = stack.iterator();
Iterator<String> iterator1 = stack1.iterator();
while (iterator.hasNext() && iterator1.hasNext()) {
if (!equals(iterator.next(), iterator1.next())) {
return false;
}
}
return isCorrect;
}
private static boolean equals(String one, String two) {
return ("[".equals(one) && "]".equals(two)) || ("[".equals(two) && "]".equals(one)) ||
("{".equals(one) && "}".equals(two)) || ("{".equals(two) && "}".equals(one)) ||
("「".equals(one) && "」".equals(two)) || ("「".equals(two) && "」".equals(one)) ||
("『".equals(one) && "』".equals(two)) || ("『".equals(two) && "』".equals(one));
}
}
瀏覽器在棧的應用
一般瀏覽器支持回退和前進功能，其實可以通過棧來實現這個功能。
- 使用兩個棧，一個存儲後退的數據，一個存儲前進的數據
- 每次打開新的網址，後退棧壓入，前進棧清空
- 每次回退網站，後退棧出棧，前進棧壓入
- 在已經後退基礎上前進，後退棧壓入，前進棧出棧
- 每次前進和後退都需要判斷各自棧是否可以進行數據操作
class StackTest2 {
String currentPage = "";
LinkedStack<String> backStack;
LinkedStack<String> forwardStack;
StackTest2() {
backStack = new LinkedStack<String>();
forwardStack = new LinkedStack<String>();
}
void open(String url) {
if (currentPage != null) {
backStack.push(url);
forwardStack.clear();
}
showPage(url, "open");
}
boolean canGoBack() {
return !backStack.isEmpty();
}
boolean canGoForward() {
return !forwardStack.isEmpty();
}
void goBack() {
if (canGoBack()) {
String back = backStack.pop();
forwardStack.push(currentPage);
showPage(back, "go back");
}
}
void goForward() {
if (canGoForward()) {
String forward = forwardStack.pop();
backStack.push(currentPage);
showPage(forward, "go forward");
}
}
void showCurrentPage() {
System.out.println("current page url:\t" + currentPage);
}
void showPage(String url, String desc) {
this.currentPage = url;
System.out.println("current page url:\t" + this.currentPage + " desc:\t" + desc);
}
public static void main(String[] args) {
StackTest2 stack = new StackTest2();
stack.open("http://www.baidu.com");
stack.open("http://news.baidu.com/");
stack.open("http://news.baidu.com/ent");
stack.goBack();
stack.goBack();
stack.goForward();
stack.open("http://www.qq.com");
stack.goForward();
stack.goBack();
stack.goForward();
stack.goBack();
stack.goBack();
stack.goBack();
stack.goBack();
stack.showCurrentPage();
}
}
參考自極客時間