算法：括号匹配问题

　　给定一个表达式字符串 exp，编写一个程序来检查 exp 中 “ {”，“}”，“（”，”）”，“ [”，“]” 这三个括号对在完整性和顺序上是否正确。

输入：exp = “[()]{}{[()()]()}”
输出：平衡

输入：exp = “[(])”
输出：不平衡

算法：

• 声明一个字符堆栈 S。
• 现在遍历表达式字符串exp。
1. 如果当前字符是一个起始括号（'（'或'{'或'['），则将其压入堆栈。
2. 如果当前字符是右括号（'）'或'}'或']'），则从堆栈中弹出，如果弹出的字符是匹配的起始括号，则否括号不平衡。
• 完全遍历后，如果堆栈中还有一些起始括号，则“不平衡”。

算法时间复杂度为 O(n)，n 为表达式长度；使用了一个空间为 x 的堆栈，空间复杂度为 O(x)。

package algorithm;

/**
 * 括号匹配问题（Check for balanced parentheses）
 */
public class BalancedParen {
    /**
     * 存放括号（左半部分）的栈
     */
    static class Stack {
        int top = -1;
        char[] items = new char[100];

        /**
         * 入栈
         *
         * @param x
         */
        void push(char x) {
            if (top == 99)
                System.err.println("Stack full");
            else
                items[++top] = x;
        }

        /**
         * 出栈
         *
         * @return
         */
        char pop() {
            if (top == -1) {
                System.err.println("Underflow error");
                return '';
            } else {
                char element = items[top];
                top--;
                return element;
            }
        }

        /**
         * 判空
         *
         * @return
         */
        boolean isEmpty() {
            return top == -1;
        }
    }

    /**
     * 检查括号是否成对
     *
     * @param character1 左半部分
     * @param character2 右半部分
     * @return
     */
    private static boolean isMatchingPair(char character1, char character2) {
        if (character1 == '(' && character2 == ')')
            return true;
        else if (character1 == '{' && character2 == '}')
            return true;
        else
            return character1 == '[' && character2 == ']';
    }

    /**
     * 检查括号是否平衡
     *
     * @param exp 表达式
     * @return
     */
    private static boolean areParenthesisBalanced(char[] exp) {
        Stack st = new Stack();
        for (char c : exp) {
            // 把括号的左边部分压入栈中
            if (c == '{' || c == '(' || c == '[') {
                st.push(c);
            }

            // 当在表达式遇到括号的右半部分时，与栈中最近匹配到的（栈顶）括号类型是否相同
            if (c == '}' || c == ')' || c == ']') {
                if (st.isEmpty()) {
                    return false;
                } else if (!isMatchingPair(st.pop(), c)) {
                    return false;
                }
            }
        }

        return st.isEmpty(); // 若栈中还有括号存在，则表达式中缺相应括号的右半部分
    }

    public static void main(String[] args) {
        char[] exp = {'{', '(', ')', '}', '[', ']'};
        if (areParenthesisBalanced(exp))
            System.out.println("Balanced");
        else
            System.out.println("Not Balanced");
    }
}