後入先出的資料結構

在 LIFO 資料結構中，將首先處理新增到佇列中的最新元素。

與佇列不同，棧是一個 LIFO 資料結構。通常，插入操作在棧中被稱作入棧 push 。與佇列類似，總是在堆疊的末尾新增一個新元素。但是，刪除操作，退棧 pop ，將始終刪除佇列中相對於它的最後一個元素。

示例 - 棧

1. 入棧：你可以單擊下面的 Push 按鈕檢視如何將新元素 6 新增到棧中。

2. 退棧：你可以單擊下面的 Pop 按鈕檢視當你從棧中彈出一個元素時將移除哪個元素。

    Push                      Pop

實現 - 棧

棧的實現比佇列容易。動態陣列

// "static void main" must be defined in a public class.
class MyStack {
    private List<Integer> data;               // store elements
    public MyStack() {
        data = new ArrayList<>();
    }
    /** Insert an element into the stack. */
    public void push(int x) {
        data.add(x);
    }
    /** Checks whether the queue is empty or not. */
    public boolean isEmpty() {
        return data.isEmpty();
    }
    /** Get the top item from the queue. */
    public int top() {
        return data.get(data.size() - 1);
    }
    /** Delete an element from the queue. Return true if the operation is successful. */
    public boolean pop() {
        if (isEmpty()) {
            return false;
        }
        data.remove(data.size() - 1);
        return true;
    }
};

public class Main {
    public static void main(String[] args) {
        MyStack s = new MyStack();
        s.push(1);
        s.push(2);
        s.push(3);
        for (int i = 0; i < 4; ++i) {
            if (!s.isEmpty()) {
                System.out.println(s.top());
            }
            System.out.println(s.pop());
        }
    }
}
 

棧 - 用法

大多數流行的語言都提供了內建的棧庫，因此你不必重新發明輪子。除了初始化，我們還需要知道如何使用兩個最重要的操作：入棧和退棧。除此之外，你應該能夠從棧中獲得頂部元素。下面是一些供你參考的程式碼示例：

// "static void main" must be defined in a public class.
public class Main {
    public static void main(String[] args) {
        // 1. Initialize a stack.
        Stack<Integer> s = new Stack<>();
        // 2. Push new element.
        s.push(5);
        s.push(13);
        s.push(8);
        s.push(6);
        // 3. Check if stack is empty.
        if (s.empty() == true) {
            System.out.println("Stack is empty!");
            return;
        }
        // 4. Pop an element.
        s.pop();
        // 5. Get the top element.
        System.out.println("The top element is: " + s.peek());
        // 6. Get the size of the stack.
        System.out.println("The size is: " + s.size());
    }
}
 

從現在開始，我們可以使用內建的棧庫來更方便地解決問題。 讓我們從一個有趣的問題（最小棧）開始，幫助你複習有用的操作。 然後我們將看一些經典的棧問題。 當你想首先處理最後一個元素時，棧將是最合適的資料結構。

最小棧

設計一個支援 push，pop，top 操作，並能在常數時間內檢索到最小元素的棧。

• push(x) -- 將元素 x 推入棧中。
• pop() -- 刪除棧頂的元素。
• top() -- 獲取棧頂元素。
• getMin() -- 檢索棧中的最小元素。

示例:

MinStack minStack = new MinStack();
minStack.push(-2);
minStack.push(0);
minStack.push(-3);
minStack.getMin();   --> 返回 -3.
minStack.pop();
minStack.top();      --> 返回 0.
minStack.getMin();   --> 返回 -2.

程式碼如下:

public class MinStack {
    ArrayList<Integer> minstack ;
    int Top=-1;
    public MinStack() {
        minstack= new ArrayList<>();

    }

    public void push(int x) {
        minstack.add(x);
        Top++;

    }

    public void pop() {
        minstack.remove(Top);
        Top--;

    }

    public int top() {
        return  minstack.get(Top);

    }

    public int getMin() {
        int min=minstack.get(0);
        for(int i:minstack){
            if(i<min){
                min=i;
            }
        }
        return min;

    }

    public static void main(String[] args) {
        MinStack minStack = new MinStack();
        minStack.push(-2);
        minStack.push(0);
        minStack.push(-3);
        System.out.println(minStack.getMin());
        minStack.pop();
        System.out.println(minStack.top());
        System.out.println( minStack.getMin());
    }
}