數據結構和算法（3）-----棧

1、棧的基本概念

　棧（英語：stack）又稱爲堆棧或堆疊，棧作爲一種數據結構，是一種只能在一端進行插入和刪除操作的特殊線性表。它按照先進後出的原則存儲數據，先進入的數據被壓入棧底，最後的數據在棧頂，需要讀數據的時候從棧頂開始彈出數據（最後一個數據被第一個讀出來）。棧具有記憶作用，對棧的插入與刪除操作中，不需要改變棧底指針。

　　棧是允許在同一端進行插入和刪除操作的特殊線性表。允許進行插入和刪除操作的一端稱爲棧頂(top)，另一端爲棧底(bottom)；棧底固定，而棧頂浮動；棧中元素個數爲零時稱爲空棧。插入一般稱爲進棧（PUSH），刪除則稱爲退棧（POP）。

　　由於堆疊數據結構只允許在一端進行操作，因而按照後進先出（LIFO, Last In First Out）的原理運作。棧也稱爲後進先出表。

　　這裏以羽毛球筒爲例，羽毛球筒就是一個棧，剛開始羽毛球筒是空的，也就是空棧，然後我們一個一個放入羽毛球，也就是一個一個push進棧，當我們需要使用羽毛球的時候，從筒裏面拿，也就是pop出棧，但是第一個拿到的羽毛球是我們最後放進去的。

2、Java模擬簡單的順序棧實現

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);
    } 
 
}

測試：

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 變量指向的始終是棧頂的元素。

　　產生的問題：

　　①、上面棧的實現初始化容量之後，後面是不能進行擴容的（雖然棧不是用來存儲大量數據的），如果說後期數據量超過初始容量之後怎麼辦？（自動擴容）

　　②、我們是用數組實現棧，在定義數組類型的時候，也就規定了存儲在棧中的數據類型，那麼同一個棧能不能存儲不同類型的數據呢？（聲明爲Object）

　　③、棧需要初始化容量，而且數組實現的棧元素都是連續存儲的，那麼能不能不初始化容量呢？（改爲由鏈表實現）

3、增強功能版棧

對於上面出現的問題，第一個能自動擴容，第二個能存儲各種不同類型的數據，解決辦法如下：（第三個在講鏈表的時候在介紹）

　　這個模擬的棧在JDK源碼中，大家可以參考 Stack 類的實現，也是用Object[]實現

　　

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;
        }
    }
 
}

測試：

//測試自定義棧類 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());
}

結果：

4、利用棧實現字符串逆序

我們知道棧是後進先出，我們可以將一個字符串分隔爲單個的字符，然後將字符一個一個push()進棧，在一個一個pop()出棧就是逆序顯示了。如下：

　　將 字符串“how are you” 反轉！！！

　　ps：這裏我們是用上面自定的棧來實現的，大家可以將ArrayStack替換爲JDK自帶的棧類Stack試試

//進行字符串反轉
@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());
    }
}

結果：

5、利用棧判斷分隔符是否匹配

寫過xml標籤或者html標籤的，我們都知道<必須和最近的>進行匹配，[ 也必須和最近的 ] 進行匹配。

　　比如：<abc[123]abc>這是符號相匹配的，如果是 <abc[123>abc] 那就是不匹配的。

　　對於 12<a[b{c}]>，我們分析在棧中的數據：遇到匹配正確的就消除

　最後棧中的內容爲空則匹配成功，否則匹配失敗！！！

//分隔符匹配
//遇到左邊分隔符了就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;
        }
    }
}

6、總結

根據棧後進先出的特性，我們實現了單詞逆序以及分隔符匹配。所以其實棧是一個概念上的工具，具體能實現什麼功能可以由我們去想象。棧通過提供限制性的訪問方法push()和pop()，使得程序不容易出錯。

　　對於棧的實現，我們稍微分析就知道，數據入棧和出棧的時間複雜度都爲O(1)，也就是說棧操作所耗的時間不依賴棧中數據項的個數，因此操作時間很短。而且需要注意的是棧不需要比較和移動操作，我們不要畫蛇添足。