棧，是一種線性資料結構，比起陣列而言，棧對應的操作較少，棧只能從一端新增元素，也只能從此端取出元素。棧是種後進先出的資料結構。它類似於彈夾中子彈，先進的後出來，而後進的卻先出來。

       在棧中，允許插入和刪除的一端被棧頂，另一端被稱為棧底，不含任何資料元素的棧被稱為空棧。棧又稱為後進先出（Last  In First Out）的線性表，簡稱LIFO結構。

       棧的操作方法

package com.hqw;

public interface Stack<E> {

    void push(E value);
    E pop();
    E peek();
    int getSize();
    boolean isEmpty();
}
 

       基於封裝的陣列類，對棧的操作的實現

package com.hqw.stack;

import com.hqw.array.Array;

/**
 * @author [email protected]
 * @date 2018/6/5 10:26
 */
public class ArrayStack<E> implements Stack<E> {
    private Array<E> array;
    public ArrayStack(int capacity) {
        array = new Array<>(capacity);
    }
    public ArrayStack() {
        array = new Array<>();
    }

    /**
     * 獲取佇列容量
     * @return
     */
    public int getCapacity() {
        return array.getCapacity();
    }

    /**
     * 獲取棧中儲存元素個數
     * @return
     */
    @Override
    public int getSize() {
        return array.getSize();
    }

    /**
     * 檢視是否為空棧
     * @return
     */
    @Override
    public boolean isEmpty() {
        return array.isEmpty();
    }

    /**
     * 入棧
     * @param value
     */
    @Override
    public void push(E value) {
        array.addLast(value);
    }

    /**
     * 出棧
     * @return
     */
    @Override
    public E pop() {
        return array.removeLast();
    }

    /**
     * 檢視棧頂元素
     * @return
     */
    @Override
    public E peek() {
        return array.getLast();
    }

    @Override
    public String toString() {
        StringBuilder res = new StringBuilder();
        res.append("stack: top: [");
        for (int i = getSize() - 1; i >= 0; i--) {
            res.append(array.get(i));
            if (i != 0) {
                res.append(", ");
            }
        }
        res.append("]");
        return res.toString();
    }
}
 

    棧的簡單應用——括號匹配（選自LeetCode）

   題目：

                Given a string containing just the characters '(', ')', '{', '}', '[' and ']', determine if the input string is valid.

                 An input string is valid if:

                     1. Open brackets must be closed by the same type of brackets.

                     2. Open brackets must be closed in the correct order.

                 Note that an empty string is also considered valid

   解答：

        為了減少程式碼量，所以我就使用了Java中Stack類，並未使用自己實現的棧

import java.util.Stack;
class Solution {

    public boolean isValid(String s) {
        Stack<Character> stack = new Stack<>();
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if (c == '(' || c == '[' || c == '{') {
                stack.push(c);
            } else {
                if (stack.isEmpty())
                    return false;
                char topChar = stack.pop();
                if (c == ')' && topChar != '(')
                    return false;
                else if (c == '}' && topChar != '{')
                    return false;
                else if (c == ']' && topChar != '[')
                    return false;
            }
        }
        if (stack.isEmpty())
            return true;
        return false;
    }
}