lizihan-software-project/Expressionjurge.java

import java.util.ArrayList;
import java.util.List;
import java.util.Stack;
import java.util.Map;
import java.util.HashMap;

public class Expressionjurge {

  public boolean hasError(String expression) {
    try {
      String cleanExpr = expression.replaceAll("\\s+", "");
      List<Object> rpn = infixToRPN(cleanExpr);
      return evaluateRPN(rpn);
    } catch (Exception e) {
      return true; // 任何异常都视为有错误
    }
  }

  private static List<Object> infixToRPN(String expression) {
    List<Object> output = new ArrayList<>();
    Stack<Character> operators = new Stack<>();
    StringBuilder number = new StringBuilder();
    Map<Character, Integer> precedence = Map.of('+', 1, '-', 1, '*', 2, '/', 2);
    for (int i = 0; i < expression.length(); i++) {
      char c = expression.charAt(i);
      if (Character.isDigit(c) || c == '.') {
        number.append(c);
      } else {
        if (number.length() > 0) {
          output.add(Double.parseDouble(number.toString()));
          number = new StringBuilder();
        }
        if (c == '(') {
          operators.push(c);
        } else if (c == ')') {
          while (!operators.isEmpty() && operators.peek() != '(') {
            output.add(operators.pop());
          }
          if (!operators.isEmpty()) operators.pop();
        } else if (isOperator(c)) {
          while (!operators.isEmpty() && operators.peek() != '(' &&
                  precedence.getOrDefault(operators.peek(), 0) >= precedence.get(c)) {
            output.add(operators.pop());
          }
          operators.push(c);
        }
      }
    }
    if (number.length() > 0) {
      output.add(Double.parseDouble(number.toString()));
    }
    while (!operators.isEmpty()) {
      output.add(operators.pop());
    }
    return output;
  }

  private static boolean evaluateRPN(List<Object> rpn) {
    Stack<Double> stack = new Stack<>();

    for (Object token : rpn) {
      if (token instanceof Double) {
        stack.push((Double) token);
      } else {
        char operator = (Character) token;
        if (stack.size() < 2) return true; // 表达式错误

        double b = stack.pop();
        double a = stack.pop();
        double result;

        switch (operator) {
          case '+': result = a + b; break;
          case '-':
            result = a - b;
            if (result < 0) return true; // 发现负数
            break;
          case '*': result = a * b; break;
          case '/':
            if (b == 0) return true; // 发现除零
            result = a / b;
            if (result < 0) return true; // 发现负数
            break;
          default: return true; // 未知运算符
        }
        stack.push(result);
      }
    }

    return stack.size() != 1; // 如果栈中不是恰好一个元素，说明表达式错误
  }

  private static boolean isOperator(char c) {
    return c == '+' || c == '-' || c == '*' || c == '/';
  }
}