Java中利用双栈判断特定类型表达式平衡性的方法与实践

  static boolean isBalanced(String expr){
      // 基本校验：表达式为空或长度为奇数，则不可能平衡
        if (expr == null || expr.length() % 2 == 1) {
            return false;
        }

        Stack stack1 = new Stack(); // 存储开括号
        Stack stack2 = new Stack(); // 存储闭括号

        // 遍历表达式，将开括号和闭括号分别压入不同的栈
        for (int i = 0; i< expr.length(); i++){ 
            if (expr.charAt(i) == '(') {
                stack1.push(expr.charAt(i));
            } 
            if (expr.charAt(i) == ')') {
               stack2.push(expr.charAt(i));
            }
        }

        // 尝试弹出所有字符
        for(int i = 0; i< expr.length(); i++) {
            stack1.pop(); // 问题所在：可能从空栈弹出
            stack2.pop(); // 问题所在：可能从空栈弹出
        }

        // 判断两个栈是否都为空
        return (stack1.isEmpty() && stack2.isEmpty()) ; 
    }

// Stack 类定义
public class Stack{
    private Node top;

    public Stack() {
        top = null;
    }

    public boolean isEmpty(){
        return (top ==null);
    }

    public void push(Object newItem){
        top = new Node(newItem,  top);
    }

    public Object pop(){
        if (isEmpty()){
            System.out.println(
             "Trying to pop when stack is empty"); // 空栈弹出时的错误提示
            return null;
        }else{
            Node temp = top;
            top = top.next;
            return temp.info;
        }
    }

    void popAll(){
        top = null;
    }

    public Object peek(){
        if (isEmpty()){
           System.out.println(
            "Trying to peek when stack is empty");
           return null;
        }else{  
           return top.info;
        }
    }
}

// Node 类定义
public class Node {
    Object info;
    Node next;

    Node(Object info, Node next){
        this.info=info;
        this.next=next;
    }    
}

Trying to pop when stack is empty
Trying to pop when stack is empty
Trying to pop when stack is empty
Trying to pop when stack is empty
Trying to pop when stack is empty
Trying to pop when stack is empty
true