算法：括号匹配问题

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

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

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

算法：

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

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

  1 package algorithm;
  2 
  3 /**
  4  * 括号匹配问题（Check for balanced parentheses）
  5  */
  6 public class BalancedParen {
  7     /**
  8      * 存放括号（左半部分）的栈
  9      */
 10     static class Stack {
 11         int top = -1;
 12         char[] items = new char[100];
 13 
 14         /**
 15          * 入栈
 16          *
 17          * @param x
 18          */
 19         void push(char x) {
 20             if (top == 99)
 21                 System.err.println("Stack full");
 22             else
 23                 items[++top] = x;
 24         }
 25 
 26         /**
 27          * 出栈
 28          *
 29          * @return
 30          */
 31         char pop() {
 32             if (top == -1) {
 33                 System.err.println("Underflow error");
 34                 return '\0';
 35             } else {
 36                 char element = items[top];
 37                 top--;
 38                 return element;
 39             }
 40         }
 41 
 42         /**
 43          * 判空
 44          *
 45          * @return
 46          */
 47         boolean isEmpty() {
 48             return top == -1;
 49         }
 50     }
 51 
 52     /**
 53      * 检查括号是否成对
 54      *
 55      * @param character1 左半部分
 56      * @param character2 右半部分
 57      * @return
 58      */
 59     private static boolean isMatchingPair(char character1, char character2) {
 60         if (character1 == '(' && character2 == ')')
 61             return true;
 62         else if (character1 == '{' && character2 == '}')
 63             return true;
 64         else
 65             return character1 == '[' && character2 == ']';
 66     }
 67 
 68     /**
 69      * 检查括号是否平衡
 70      *
 71      * @param exp 表达式
 72      * @return
 73      */
 74     private static boolean areParenthesisBalanced(char[] exp) {
 75         Stack st = new Stack();
 76         for (char c : exp) {
 77             // 把括号的左边部分压入栈中
 78             if (c == '{' || c == '(' || c == '[') {
 79                 st.push(c);
 80             }
 81 
 82             // 当在表达式遇到括号的右半部分时，与栈中最近匹配到的（栈顶）括号类型是否相同
 83             if (c == '}' || c == ')' || c == ']') {
 84                 if (st.isEmpty()) {
 85                     return false;
 86                 } else if (!isMatchingPair(st.pop(), c)) {
 87                     return false;
 88                 }
 89             }
 90         }
 91 
 92         return st.isEmpty(); // 若栈中还有括号存在，则表达式中缺相应括号的右半部分
 93     }
 94 
 95     public static void main(String[] args) {
 96         char[] exp = {'{', '(', ')', '}', '[', ']'};
 97         if (areParenthesisBalanced(exp))
 98             System.out.println("Balanced");
 99         else
100             System.out.println("Not Balanced");
101     }
102 }