java實現棧結構

棧的定義  

      棧（Stack）是限制僅在表的一端進行插入和刪除運算的線性表。  

    (1)通常稱插入、刪除的這一端為棧頂 （Top），另一端稱為棧底 （Bottom）。  

    (2)當表中沒有元素時稱為空白棧。  

    (3)棧為後進先出（Last In First Out）的線性表，簡稱為 LIFO 表。  

      棧的修改是按後進先出的原則進行。每次刪除（退棧）的總是當前棧中" 

最新"的元素，即最後插入（進棧）的元素，而最先插入的是被放在棧的底部， 

要到最後才能刪除。 

 

【樣本】元素是以a1，a2，…，an的順序進棧，退棧的次序卻是an，an-1，…， 

a1。  

 

2、棧的基本運算  

 （1）InitStack（S）  

      構造一個空棧S。  

 （2）StackEmpty（S）  

      判棧空。若S為空白棧，則返回TRUE，否則返回FALSE。  

 （3）StackFull（S）  

      判棧滿。若S為滿棧，則返回TRUE，否則返回FALSE。  

注意： 該運算只適用於棧的順序儲存結構。  

 （4）Push（S，x）  

      進棧。若棧S不滿，則將元素x插入S的棧頂。  

 （5）Pop（S）  

 

 

定義堆棧ADT
StackADT
package Stack;
public interface StackADT {
    public void push(Object element);//壓棧
    public Object pop();//出棧
    public boolean isEmpty();
    public int size();
    public Object peek();//返回棧頂對象的一個引用
    public String toString();
}

 

鏈式實現：

在棧的一段添加和刪除元素，在棧中維護一個指向棧頂的結點和一個count變數指示棧的大小：
private LinearNode top; //指向棧頂
private int count;//標記棧的大小
每次出棧和壓棧在鏈表的表頭：（也可以再表尾，實現方式不一樣而已）
top--->元素1--->元素2--->元素3.........
實現（附帶測試main）：
LinkedStack
package Stack;
import Bag.LinearNode;
//為了重點來實現演算法，將異常情況直接列印出然後退出程式，不再聲明異常類
public class LinkedStack implements StackADT {
    private LinearNode top; //指向棧頂
    private int count;//標記棧的大小
    public static void main(String[] args){
        LinkedStack stack = new LinkedStack();
        System.out.println("將0到10依次壓棧");
        for(int i = 0;i < 10;i++)
            stack.push(i);
        System.out.println("連續執行5次出棧操作");
        for(int i = 0;i < 5;i++)
            stack.pop();
        System.out.println("棧為空白嗎。： " + stack.isEmpty());
        System.out.println("棧的大小為： " + stack.size());
        System.out.println("棧頂元素為： " + stack.top.getElement());
        System.out.println("棧頂元素為： " + stack.peek());   
    }
    public LinkedStack()
    {
        top = null;
        count = 0;
    }
    public int size() {
        return count;
    }
    public boolean isEmpty() {
        return (size() == 0);
    }
    public void push(Object element) {
        LinearNode node = new LinearNode(element);
        node.setNext(top);
        top = node;
        count++;
    }
    public Object pop() {
        if(isEmpty())
        {
            System.out.println("stack is empty!");
            System.exit(1);
        }
        Object result = top.getElement();
        top = top.getNext();
        count--;
        return result;
    }
    public Object peek() {
        Object result =  top.getElement();
        return result;
    }
}
運行結果：
將0到10依次壓棧
連續執行5次出棧操作
棧為空白嗎。： false
棧的大小為： 5
棧頂元素為： 4
棧頂元素為： 4

數組實現：

棧底總是數組下標為0的位置，入棧出棧從數組下標的最後一個元素開始：
private Object[] contents;
private int top;//top標記下一個入棧的位置，同時也表示棧的容量大小，跟鏈式實現的count比較一下。。。
實現（附帶測試main）：
ArrayStack
package Stack;
public class ArrayStack implements StackADT {
    private Object[] contents;
    private int top;//top標記下一個入棧的位置，同時也表示棧的容量大小，跟鏈式實現的count比較一下。。。
    private static int SIZE = 10;
    public ArrayStack()
    {
        contents = new Object[SIZE];
        top = 0;
    }
    public void expand(){//藉助於申請一個輔助空間,每次擴充容量一倍
        Object[] larger = new Object[size()*2];
        for(int index = 0;index < top;index++)
            larger[index] =  contents[index];
        contents = larger;
    }
    public int size() {
        return top;
    }
    public boolean isEmpty() {
        return (size() == 0);
    }
    public void push(Object element) {
        //if(isEmpty())
            //expand();
        if(top == contents.length)
            expand();
        contents[top] = element;
        top++;
    }
    public Object pop() {
        if(isEmpty())
        {
            System.out.println("stack is empty!");
            System.exit(1);
        }
        Object result = contents[top-1];
        contents[top-1] = null;//出棧
        top--;
        return result;   
        /*書上這樣寫簡便一點：：：
         * top--;
         * Object result = contents[top];
         * contents[top] = null;*/       
    }
    public Object peek() {
        Object result;
        if(isEmpty())
            result = null;
        else
            result = contents[top-1];
        return result;
    }
    public static void main(String[] args) {
        ArrayStack stack = new ArrayStack();
        System.out.println("將0到24依次壓棧，然後連續10次出棧");
        for(int i = 0;i < 25;i++)
            stack.push(i);
        for(int i = 0;i < 10;i++)
            stack.pop();
        System.out.println("棧的大小為： " + stack.size());
        System.out.println("棧為空白嗎。： " + stack.isEmpty());
        System.out.println("棧頂元素為： " + stack.peek());
    }
}
運行結果：
將0到24依次壓棧，然後連續10次出棧
棧的大小為： 15
棧為空白嗎。： false
棧頂元素為： 14