使用堆栈检查表达式（格式良好）中的平衡括号的Java程序

给定一个表达式字符串exp，编写一个程序来检查 exp 中“{“, “}”, “(“, “)”, “[”, “]” 的对和顺序是否正确。

示例：

Input: exp = “[()]{}{[()()]()}” 
Output: Balanced

Input: exp = “[(])” 
Output: Not Balanced 

算法：

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

下图是上述方法的试运行：

下面是上述方法的实现：

Java

// Java program for checking
// balanced brackets
import java.util.*;
  
public class BalancedBrackets {
  
    // function to check if brackets are balanced
    static boolean areBracketsBalanced(String expr)
    {
        // Using ArrayDeque is faster than using Stack class
        Deque stack
            = new ArrayDeque();
  
        // Traversing the Expression
        for (int i = 0; i < expr.length(); i++) 
        {
            char x = expr.charAt(i);
  
            if (x == '(' || x == '[' || x == '{') 
            {
                // Push the element in the stack
                stack.push(x);
                continue;
            }
  
            // If current character is not opening
            // bracket, then it must be closing. So stack
            // cannot be empty at this point.
            if (stack.isEmpty())
                return false;
            char check;
            switch (x) {
            case ')':
                check = stack.pop();
                if (check == '{' || check == '[')
                    return false;
                break;
  
            case '}':
                check = stack.pop();
                if (check == '(' || check == '[')
                    return false;
                break;
  
            case ']':
                check = stack.pop();
                if (check == '(' || check == '{')
                    return false;
                break;
            }
        }
  
        // Check Empty Stack
        return (stack.isEmpty());
    }
  
    // Driver code
    public static void main(String[] args)
    {
        String expr = "([{}])";
  
        // Function call
        if (areBracketsBalanced(expr))
            System.out.println("Balanced ");
        else
            System.out.println("Not Balanced ");
    }
}

输出

Balanced

时间复杂度： O(n)
辅助空间：堆栈的 O(n)。

有关更多详细信息，请参阅有关使用 Stack 的表达式（格式良好）检查平衡括号的完整文章！