數據結構Java實現05----棧：順序棧和鏈式堆棧

 

一、堆棧的基本概念：

堆棧（也簡稱作棧）是一種特殊的線性表，堆棧的數據元素以及數據元素間的邏輯關系和線性表完全相同，其差別是線性表允許在任意位置進行插入和刪除操作，而堆棧只允許在固定一端進行插入和刪除操作。

先進后出：堆棧中允許進行插入和刪除操作的一端稱為棧頂，另一端稱為棧底。堆棧的插入和刪除操作通常稱為進棧或入棧，堆棧的刪除操作通常稱為出棧或退棧。

備注：棧本身就是一個線性表，所以我們之前討論過線性表的順序存儲和鏈式存儲，對於棧來說，同樣適用。

 

二、堆棧的抽象數據類型：

數據集合：

堆棧的數據集合可以表示為a0,a1,…,an-1，每個數據元素的數據類型可以是任意的類類型。

操作集合：

（1）入棧push(obj)：把數據元素obj插入堆棧。

（2）出棧pop()：出棧, 刪除的數據元素由函數返回。

（3）取棧頂數據元素getTop()：取堆棧當前棧頂的數據元素並由函數返回。

（4）非空否notEmpty()：若堆棧非空則函數返回true，否則函數返回false。

 

三、順序棧：

順序存儲結構的堆棧稱作順序堆棧。其存儲結構示意圖如下圖所示：

1、順序棧的實現：

（1）設計Stack接口

（2）實現SequenceStack類

注：棧是線性表的特例，線性表本身就是用數組來實現的。於是，順序棧也是用數組實現的。

代碼實現：

(1)Stack.java:（Stack接口）

public interface Stack {

    //入棧
    public void push(Object obj) throws Exception;

    //出棧
    public Object pop() throws Exception;

    //獲取棧頂元素
    public Object getTop() throws Exception;

    //判斷棧是否為空
     public boolean isEmpty();
}

 

 

(2)SequenceStack.java:

//順序棧
public class SequenceStack implements Stack {

    Object[] stack; //對象數組（棧用數組來實現）
    final int defaultSize = 10; //默認最大長度
    int top; //棧頂位置（的一個下標）:其實可以理解成棧的實際長度
    int maxSize; //最大長度

    //如果用無參構造的話，就設置默認長度
    public SequenceStack() {
        init(defaultSize);
    }

    //如果使用帶參構造的話，就調用指定的最大長度
    public SequenceStack(int size) {
        init(size);
    }

    public void init(int size) {
        this.maxSize = size;
        top = 0;
        stack = new Object[size];
    }

    //獲取棧頂元素
    @Override
    public Object getTop() throws Exception {
        // TODO Auto-generated method stub
        if (isEmpty()) {
            throw new Exception("堆棧為空！");
        }

        return stack[top - 1];
    }

    //判斷棧是否為空
    @Override
    public boolean isEmpty() {
        // TODO Auto-generated method stub
        return top == 0;
    }

    //出棧操作
    @Override
    public Object pop() throws Exception {
        // TODO Auto-generated method stub
        if (isEmpty()) {
            throw new Exception("堆棧為空！");
        }
        top--;

        return stack[top];
    }

    //入棧操作
    @Override
    public void push(Object obj) throws Exception {
        // TODO Auto-generated method stub
        //首先判斷棧是否已滿
        if (top == maxSize) {
            throw new Exception("堆棧已滿！");
        }
        stack[top] = obj;
        top++;
    }
}

2、測試類：

設計一個順序棧，從鍵盤輸入十個整數壓進棧，然后再彈出棧，並打印出棧序列。

代碼實現：

(3)Test.java:

import java.util.Scanner;

public class Test {
    public static void main(String[] args) throws Exception {
        SequenceStack stack = new SequenceStack(10);

        Scanner in = new Scanner(System.in);
        int temp;
        for (int i = 0; i < 10; i++) {
            System.out.println("請輸入第" + (i + 1) + "個整數：");
            temp = in.nextInt();
            stack.push(temp);
        }

        //遍歷輸出
        while (!stack.isEmpty()) {
            System.out.println(stack.pop());
        }
    }
}

運行效果：

 

四、Java中棧與堆的區別：

棧(stack):（線程私有）

　　是一個先進后出的數據結構，通常用於保存方法(函數)中的參數，局部變量。在java中,所有基本類型和引用類型的引用都在棧中存儲。棧中數據的生存空間一般在當前scopes內(就是由{...}括起來的區域)。

堆(heap):（線程共享）

　　是一個可動態申請的內存空間(其記錄空閑內存空間的鏈表由操作系統維護)，C中的malloc語句所產生的內存空間就在堆中。在java中，所有使用new xxx()構造出來的對象都在堆中存儲，當垃圾回收器檢測到某對象未被引用，則自動銷毀該對象。所以，理論上說java中對象的生存空間是沒有限制的，只要有引用類型指向它，則它就可以在任意地方被使用。

 

五、hashCode與對象之間的關系：

如果兩個對象的hashCode不相同，那么這兩個對象肯定也不同。

如果兩個對象的hashCode相同，那么這兩個對象有可能相同，也有可能不同。

總結一句：不同的對象可能會有相同的hashCode；但是如果hashCode不同，那肯定不是同一個對象。

代碼舉例：

public class StringTest {

    public static void main(String[] args) {

        //s1 和 s2 其實是同一個對象。對象的引用存放在棧中，對象存放在方法區的字符串常量池
        String s1 = "china";
        String s2 = "china";

        //凡是用new關鍵創建的對象，都是在堆內存中分配空間。
        String s3 = new String("china");

        //凡是new出來的對象，絕對是不同的兩個對象。
        String s4 = new String("china");

        System.out.println(s1 == s2);  //true
        System.out.println(s1 == s3);
        System.out.println(s3 == s4);
        System.out.println(s3.equals(s4));

        System.out.println("\n-----------------\n");
      /*String很特殊，重寫從父類繼承過來的hashCode方法，使得兩個
       *如果字符串里面的內容相等，那么hashCode也相等。
       **/

        //hashCode相同
        System.out.println(s3.hashCode());  //hashCode為94631255
        System.out.println(s4.hashCode());  //hashCode為94631255

        //identityHashCode方法用於獲取原始的hashCode
        //如果原始的hashCode不同，表明確實是不同的對象

        //原始hashCode不同
        System.out.println(System.identityHashCode(s3)); //2104928456
        System.out.println(System.identityHashCode(s4)); //2034442961

        System.out.println("\n-----------------\n");

        //hashCode相同
        System.out.println(s1.hashCode());  //94631255
        System.out.println(s2.hashCode());  //94631255

        //原始hashCode相同：表明確實是同一個對象
        System.out.println(System.identityHashCode(s1));  //648217993
        System.out.println(System.identityHashCode(s2));  //648217993
    }
}

 

上面的代碼中，注釋已經標明了運行的結果。通過運行結果我們可以看到，s3和s4的字符串內容相同，但他們是兩個不同的對象，由於String類重寫了hashCode方法，他們的hashCode相同，但原始的hashCode是不同的。

 

六、鏈式堆棧：

　　鏈式存儲結構的堆棧稱作鏈式堆棧。

　　與單鏈表相同，鏈式堆棧也是由一個個結點組成的，每個結點由兩個域組成，一個是存放數據元素的數據元素域data，另一個是存放指向下一個結點的對象引用（即指針）域next。

　　堆棧有兩端，插入數據元素和刪除數據元素的一端為棧頂，另一端為棧底。鏈式堆棧都設計成把靠近堆棧頭head的一端定義為棧頂。

依次向鏈式堆棧入棧數據元素a0, a1, a2, ..., an-1后，鏈式堆棧的示意圖如下圖所示：　

1、設計鏈式堆棧：

(1)Node.java:結點類

//結點類
public class Node {

    Object element; //數據域
    Node next;  //指針域

    //頭結點的構造方法
    public Node(Node nextval) {
        this.next = nextval;
    }

    //非頭結點的構造方法
    public Node(Object obj, Node nextval) {
        this.element = obj;
        this.next = nextval;
    }
    
    //獲得當前結點的后繼結點
    public Node getNext() {
        return this.next;
    }

    //獲得當前的數據域的值
    public Object getElement() {
        return this.element;
    }

    //設置當前結點的指針域
    public void setNext(Node nextval) {
        this.next = nextval;
    }

    //設置當前結點的數據域
    public void setElement(Object obj) {
        this.element = obj;
    }

    public String toString() {
        return this.element.toString();
    }
}

(2)Stack.java:

//棧接口
public interface Stack {

    //入棧
    public void push(Object obj) throws Exception;

    //出棧
    public Object pop() throws Exception;

    //獲得棧頂元素
    public Object getTop() throws Exception;

    //判斷棧是否為空
    public boolean isEmpty();
}

 

(3)LinkStack.java:

public class LinkStack implements Stack {

    Node head;  //棧頂指針
    int size;  //結點的個數

    public LinkStack() {
        head = null;
        size = 0;
    }

    @Override
    public Object getTop() throws Exception {
        // TODO Auto-generated method stub
        return head.getElement();
    }

    @Override
    public boolean isEmpty() {
        // TODO Auto-generated method stub
        return head == null;
    }

    @Override
    public Object pop() throws Exception {
        // TODO Auto-generated method stub
        if (isEmpty()) {
            throw new Exception("棧為空！");
        }
        Object obj = head.getElement();
        head = head.getNext();
        size--;
        return obj;
    }

    @Override
    public void push(Object obj) throws Exception {
        // TODO Auto-generated method stub
        head = new Node(obj, head);
        size++;
    }

(4)Test.java:測試類

import java.util.Scanner;

public class Test {

    public static void main(String[] args) throws Exception {
        //SequenceStack stack = new SequenceStack(10);
        LinkStack stack = new LinkStack();
        Scanner in = new Scanner(System.in);
        int temp;
        for (int i = 0; i < 10; i++) {
            System.out.println("請輸入第" + (i + 1) + "個整數：");
            temp = in.nextInt();
            stack.push(temp);
        }
        //遍歷輸出
        while (!stack.isEmpty()) {
            System.out.println(stack.pop());
        }
    }
}

運行效果：

 

 

七、堆棧的應用:

堆棧是各種軟件系統中應用最廣泛的數據結構之一。括號匹配和表達式計算是編譯軟件中的基本問題，其軟件設計中都需要使用堆棧。

• 括號匹配問題
• 表達式計算

1、括號匹配問題：

假設算術表達式中包含圓括號，方括號，和花括號三種類型。使用棧數據結構編寫一個算法判斷表達式中括號是否正確匹配，並設計一個主函數測試。

比如：

{a+[b+(c*a)/(d-e)]}    正確

([a+b)-(c*e)]+{a+b}    錯誤，中括號的次序不對

括號匹配有四種情況：

1.左右括號匹配次序不正確

2.右括號多於左括號

3.左括號多於右括號

4.匹配正確

下面我們就通過代碼把這四種情況列舉出來。

代碼實現：

public class Test {

    //方法：將字符串轉化為字符串數組
    public static String[] expToStringArray(String exp) {
        int n = exp.length();
        String[] arr = new String[n];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = exp.substring(i, i + 1);
        }
        return arr;
    }

    //方法：括號匹配問題的檢測
    public static void signCheck(String exp) throws Exception {
        SequenceStack stack = new SequenceStack();
        String[] arr = Test.expToStringArray(exp);
        for (int i = 0; i < arr.length; i++) {
            if (arr[i].equals("(") || arr[i].equals("[") || arr[i].equals("{")) { //當碰到都是左邊的括號的時候，統統壓進棧
                stack.push(arr[i]);
            } else if (arr[i].equals(")") && !stack.isEmpty() && stack.getTop().equals("(")) { //當碰到了右小括號時，如果匹配正確，就將左小括號出棧
                stack.pop();
            } else if (arr[i].equals(")") && !stack.isEmpty() && !stack.getTop().equals("(")) {
                System.out.println("左右括號匹配次序不正確！");
                return;
            } else if (arr[i].equals("]") && !stack.isEmpty() && stack.getTop().equals("[")) {
                stack.pop();
            } else if (arr[i].equals("]") && !stack.isEmpty() && !stack.getTop().equals("[")) {
                System.out.println("左右括號匹配次序不正確！");
                return;
            } else if (arr[i].equals("}") && !stack.isEmpty() && stack.getTop().equals("{")) {
                stack.pop();
            } else if (arr[i].equals("}") && !stack.isEmpty() && !stack.getTop().equals("{")) {
                System.out.println("左右括號匹配次序不正確！");
                return;
            } else if (arr[i].equals(")") || arr[i].equals("]") || arr[i].equals("}") && stack.isEmpty()) {
                System.out.println("右括號多於左括號！");
                return;
            }
        }
        if (!stack.isEmpty()) {
            System.out.println("左括號多於右括號！");
        } else {
            System.out.println("括號匹配正確！");
        }
    }


    public static void main(String[] args) throws Exception {

        String str = "([(a+b)-(c*e)]+{a+b}";
        //括號匹配的檢測
        Test.signCheck(str);
    }
}

運行效果：

 

上方代碼中，第50行是一個錯誤的括號表達式，於是運行結果也很明顯了。

 

2、表達式計算：

比如：

　　3+(6-4/2)*5=23 

其后綴表達式為：3642/-5*+# (#符號為結束符)

現在要做的是：

使用鏈式堆棧，設計一個算法計算表達式，當我們輸入后綴表達式后，能輸出運行結果。

代碼實現：

public class Test {

    //方法：使用鏈式堆棧，設計一個算法計算表達式
    public static void expCaculate(LinkStack stack) throws Exception {
        char ch; //掃描每次輸入的字符。
        int x1, x2, b = 0; //x1,x2:兩個操作數 ，b字符的ASCII碼
        System.out.println("輸入后綴表達式並以#符號結束:");
        while ((ch = (char) (b = System.in.read())) != '#') {
            //如果是數字，說明是操作數則壓入堆棧
            if (Character.isDigit(ch)) {
                stack.push(new Integer(Character.toString(ch)));
            }
            //如果不是數字，說明是運算符
            else {
                x2 = ((Integer) stack.pop()).intValue();
                x1 = ((Integer) stack.pop()).intValue();
                switch (ch) {
                    case '+':
                        x1 += x2;
                        break;
                    case '-':
                        x1 -= x2;
                        break;
                    case '*':
                        x1 *= x2;
                        break;
                    case '/':
                        if (x2 == 0) {
                            throw new Exception("分母不能為零！");
                        } else {
                            x1 /= x2;
                        }
                        break;
                }
                stack.push(new Integer(x1));
            }
        }
        System.out.println("后綴表達式計算結果是：" + stack.getTop());
    }

    public static void main(String[] args) throws Exception {
        LinkStack stack = new LinkStack();
        //(2+3)*(3-1)/2=5的后綴表達式為：23+31-*2/
        //方法：鍵盤輸入后綴表達式，輸出的得到計算結果
        Test.expCaculate(stack);

    }
}

 

運行效果：