优化括号平衡检测：理解与修复Java自定义栈的错误用法

  static boolean isBalanced(String expr){
      // base case: length of the expression must be even
        if (expr == null || expr.length() % 2 == 1) {
            return false;
        }

        Stack stack1 = new Stack();
        Stack stack2 = new Stack();

        // traverse the input expression and push characters
        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));
            }
        }

        // Problematic popping loop
        for(int i = 0; i< expr.length(); i++) {
            stack1.pop(); // May cause issues if stack1 is empty
            stack2.pop(); // May cause issues if stack2 is empty
        }

        return (stack1.isEmpty() && stack2.isEmpty()) ; 
    }

for(int i = 0; i< expr.length(); i++) {
    stack1.pop();
    stack2.pop();
}

public class BalancedParenthesesChecker {

  // Stack class (provided by user, for context)
  static class Node {
      Object info;
      Node next;

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

  static 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;
          }
      }
  }

  /**
   * 检查给定表达式中的括号是否“平衡”。
   * 此方法根据原始问题对“平衡”的定义进行修复：
   * 仅检查开括号 '(' 的数量是否与闭括号 ')' 的数量相等。
   * 它不检查括号的嵌套顺序。
   *
   * @param expr 待检查的字符串表达式。
   * @return 如果开括号和闭括号数量相等且表达式长度为偶数，则返回 true；否则返回 false。
   */
  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));
            }
        }

        // 改进后的弹出循环：只有当两个栈都有元素时才进行弹出操作
        // 这样可以避免在栈为空时继续尝试弹出
        while (!stack1.isEmpty() && !stack2.isEmpty()) {
            stack1.pop();
            stack2.pop();
        }

        // 最终判断：如果两个栈都为空，则认为表达式是平衡的
        // 这意味着开括号和闭括号的数量相等
        return (stack1.isEmpty() && stack2.isEmpty()) ; 
    }

    public static void main(String[] args) {
        System.out.println("Testing ((())): " + isBalanced("((()))")); // Expected: true
        System.out.println("Testing ()): " + isBalanced("(())"));   // Expected: true
        System.out.println("Testing )(: " + isBalanced(")("));     // Expected: true (based on this specific definition)
        System.out.println("Testing (: " + isBalanced("("));       // Expected: false (odd length)
        System.out.println("Testing ): " + isBalanced(")"));       // Expected: false (odd length)
        System.out.println("Testing (()): " + isBalanced("(()"));    // Expected: false (odd length)
        System.out.println("Testing empty string: " + isBalanced("")); // Expected: true (length 0, both stacks empty)
    }
}

public class Node {
    Object info; // 存储节点信息
    Node next;   // 指向下一个节点的引用

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

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; // 返回栈顶元素，不移除
        }
    }
}