手把手帶你在Java中用【數組】和【鏈表】實現棧

一、棧的介紹

• 棧的英文爲(stack)
• 棧是一個先入後出(FILO-First In Last Out)的有序列表。
• 棧(stack)是限制線性表中元素的插入和刪除只能在線性表的同一端進行的一種特殊線性表。允許插入和刪除的一端，爲變化的一端，稱爲棧頂(Top)，另一端爲固定的一端，稱爲棧底(Bottom)。
• 根據棧的定義可知，最先放入棧中元素在棧底，最後放入的元素在棧頂，而刪除元素剛好相反，最後放入的元素最先刪除，最先放入的元素最後刪除
  
  

二、應用場景

• 逆序輸出
• 數制轉換

三、代碼實現

• 數組實現棧

public class ArrayStackDemo {
    public static void main(String[] args) {
        ArrayStack arrayStack = new ArrayStack(5);
        //顯示棧內容
        arrayStack.show();
        //添加
        arrayStack.push(1);
        arrayStack.push(2);
        arrayStack.push(3);
        arrayStack.push(4);
        arrayStack.push(5);
        arrayStack.push(6);

        //顯示棧內容
        System.out.println("添加值後的棧信息");
        arrayStack.show();

        //取出棧內容
        int stackPop = arrayStack.pop();
        System.out.println("取出的值爲："+stackPop);
        int stackPop2 = arrayStack.pop();
        System.out.println("取出的值爲："+stackPop2);
        //顯示棧內容
        System.out.println("取出值後的棧信息");
        arrayStack.show();

    }


}

// 定義一個棧,用數組實現
class ArrayStack{
    //棧大小
    private int maxSize;
    //定義一個數組用於模擬棧
    private int[] stack;
    //定義棧頂爲top，默認爲-1
    private int top = -1;

    //創建棧需要定義棧大小
    public ArrayStack(int maxSize){
        this.maxSize = maxSize;
        this.stack = new int[this.maxSize];
    }

    // 判斷棧空
    public boolean isEmpty(){
        return this.top == -1;
    }

    //判斷棧滿
    public boolean isFull(){
        return top == maxSize - 1;
    }

    //入棧
    public void push(int value){
        //判斷是否棧滿
        if(isFull()){
            System.out.println("棧已滿！");
            return;
        }
        //將棧頂指針前進一位
        top++;
        //向棧中添加輸入
        stack[top] = value;
    }

    //出棧
    public int pop(){
        //判斷當前棧是否爲空
        if(isEmpty()){
            System.out.println("當前棧空");
            throw new RuntimeException("當前棧無數據，不可出棧");
        }
        //將當前棧頂指向的數據存起來
        int value = stack[top];
        //棧頂後移一位
        top--;
        //將取得的數據返回
        return value;
    }

    //顯示棧
    public void show(){
        //判斷當前棧是否爲空
        if(isEmpty()){
            System.out.println("當前棧空");
           return;
        }
        for (int i = top;i >= 0;i--){
            System.out.printf("stack[%d]=%d\n",i,stack[i]);
        }
    }
}

• 鏈表實現棧 - 有頭節點

public class LinkedListStackDemo {
    public static void main(String[] args) {
        LinkedListStack linkedListStack = new LinkedListStack(5);
        //顯示棧內容
        linkedListStack.show();
        //添加
        linkedListStack.push(1);
        linkedListStack.push(2);
        linkedListStack.push(3);
        linkedListStack.push(4);
        linkedListStack.push(5);
        linkedListStack.push(6);

        //顯示棧內容
        System.out.println("添加值後的棧信息");
        linkedListStack.show();

        //取出棧內容
        int stackPop = linkedListStack.pop();
        System.out.println("取出的值爲："+stackPop);
        int stackPop2 = linkedListStack.pop();
        System.out.println("取出的值爲："+stackPop2);
        //顯示棧內容
        System.out.println("取出值後的棧信息");
        linkedListStack.show();
    }
}

//用單向鏈表實現棧
class LinkedListStack {
    //棧大小
    private int maxSize;
    //定義一個節點用於當作頭節點
    private Node first = new Node(-1);
    //定義棧頂爲top，默認指向first
    private Node top = first;

    //創建棧需要定義棧大小
    public LinkedListStack(int maxSize){
        this.maxSize = maxSize;
    }

    //判斷當前棧中有效節點，從頭節點的下一個開始到top棧頂爲有效節點
    public int size(){
        //判斷有沒有有效節點
        if(first.next == null){
            return 0;
        }
        int size = 0;
        //創建臨時指針用於計算節點數量
        Node temp = first.next;
        while (true){
            size++;
            //當前指針指向棧頂時退出
            if(temp == top){
                break;
            }
            temp = temp.next;
        }
        return size;
    }

    // 判斷棧空
    public boolean isEmpty(){
        return size() == 0;
    }

    //判斷棧滿
    public boolean isFull(){
        return size() == maxSize;
    }

    //入棧
    public void push(int value){
        //判斷是否棧滿
        if(isFull()){
            System.out.println("棧已滿！");
            return;
        }
        //創建對象
        Node node = new Node(value);
        //將新對象添加到棧中
        top.next = node;
        //將棧頂指針前進至新對象
        top = node;
    }

    //出棧
    public int pop(){
        //判斷當前棧是否爲空
        if(isEmpty()){
            System.out.println("當前棧空");
            throw new RuntimeException("當前棧無數據，不可出棧");
        }
        //將當前棧頂指向的數據存起來
        int value = top.number;
        //棧頂前移一位
        //創建臨時指針
        Node temp = first;
        while (true){
            //找棧頂
            //temp.next指向top,說明temp是要出棧的前一個節點，將該節點當作棧頂
            if(temp.next == top){
                top = temp;
                break;
            }
            //後移指針
            temp = temp.next;
        }
        //將取得的數據返回
        return value;
    }

    //顯示棧，從棧頂開始顯示
    public void show(){
        //判斷當前棧是否爲空
        if(isEmpty()){
            System.out.println("當前棧空");
            return;
        }
        //創建臨時指針
        Node temp;
        //循環棧當前實際大小次
        for (int i = size(); i >= 0; i--) {
            //每次臨時指針都從頭開始
            temp = first;
            //打印最後一個元素
            for (int j = 0; j < i; j++) {
                temp = temp.next;
                if(j == i-1){
                    System.out.printf("stack[%d]=%d\n", j, temp.number);
                }
            }
        }
    }

}

class Node {
    int number;
    Node next;

    public Node(int number) {
        this.number = number;
    }

    @Override
    public String toString() {
        return "Node{number=" + this.number + "}";
    }
}