LeetCode 770题解析：变量多项式计算器的实现

1. 问题背景与需求拆解

这道LeetCode 770题属于表达式解析与计算的经典难题，要求实现一个支持变量运算的多功能计算器。题目给出一个包含数字、变量和运算符的字符串表达式，需要完成以下核心功能：

• 解析包含变量（如x、y）的多项式表达式
• 处理加减乘除四则运算（注意除法取整）
• 支持括号改变运算优先级
• 最终输出规范化的多项式结果列表

实际工程中这类需求常见于公式编辑器、科学计算软件等场景。我在金融量化系统开发中就遇到过类似需求——需要动态解析用户输入的投资组合计算公式。

2. 核心解题思路分析

2.1 表达式解析方案选型

面对这种结构化文本解析问题，通常有几种技术路线：

1. 递归下降解析：手动实现词法分析和语法分析

   • 优点：完全可控，性能好
   • 缺点：实现复杂度高，约200+行代码

2. 逆波兰表达式转换：

   • 需要处理运算符优先级和括号
   • 对变量处理不够直观

3. 第三方库调用：

   • 如Python的eval()或Java的ScriptEngine
   • 不符合算法题限制条件

经过实践对比，我推荐采用双栈法（操作数栈+运算符栈）结合运算符优先级表的方案。这种方案在LeetCode 227（基础计算器II）中验证过有效性，扩展到本题只需增加变量处理逻辑。

2.2 变量多项式处理要点

与常规计算器问题最大的区别在于变量处理：

• 需要设计多项式表示结构（如3*x*y + 2*y + 1）
• 同类项合并时需考虑变量组合（x*y和y*x应合并）
• 最终输出按变量次数降序排列

建议使用Map<变量组合, 系数>的结构存储多项式项，例如：

java复制class Term {
    int coefficient;
    List<String> variables; // 如["x","y"]
    
    // 实现compareTo用于排序
}

3. 分步实现详解

3.1 词法分析阶段

首先需要将输入字符串转换为token流。注意处理：

• 连续数字字符组合成整数
• 变量名由小写字母组成
• 运算符包括+ - * / ( )

java复制private List<String> tokenize(String s) {
    List<String> tokens = new ArrayList<>();
    int i = 0, n = s.length();
    while (i < n) {
        if (Character.isWhitespace(s.charAt(i))) {
            i++;
            continue;
        }
        if (s.charAt(i) == '(' || s.charAt(i) == ')') {
            tokens.add(String.valueOf(s.charAt(i++)));
            continue;
        }
        // 处理数字
        if (Character.isDigit(s.charAt(i))) {
            StringBuilder num = new StringBuilder();
            while (i < n && Character.isDigit(s.charAt(i))) {
                num.append(s.charAt(i++));
            }
            tokens.add(num.toString());
            continue;
        }
        // 处理变量
        if (Character.isLowerCase(s.charAt(i))) {
            StringBuilder var = new StringBuilder();
            while (i < n && Character.isLowerCase(s.charAt(i))) {
                var.append(s.charAt(i++));
            }
            tokens.add(var.toString());
            continue;
        }
        // 处理运算符
        tokens.add(String.valueOf(s.charAt(i++)));
    }
    return tokens;
}

3.2 表达式求值核心逻辑

采用双栈法处理运算优先级，关键点：

1. 定义运算符优先级表
2. 遇到高优先级运算符时立即计算
3. 括号特殊处理——左括号入栈，右括号触发计算直到左括号

java复制private Map<String, Integer> opPriority = Map.of(
    "+", 1,
    "-", 1,
    "*", 2,
    "/", 2
);

private Term calculate(Term a, Term b, String op) {
    switch(op) {
        case "+": return a.add(b);
        case "-": return a.subtract(b);
        case "*": return a.multiply(b);
        case "/": return a.divide(b); // 注意题目要求整数除法
        default: throw new IllegalArgumentException();
    }
}

private List<Term> evaluate(List<String> tokens) {
    Deque<List<Term>> numStack = new ArrayDeque<>();
    Deque<String> opStack = new ArrayDeque<>();
    
    for (String token : tokens) {
        if (token.equals("(")) {
            opStack.push(token);
        } else if (token.equals(")")) {
            while (!opStack.peek().equals("(")) {
                // 弹出运算符计算
            }
            opStack.pop(); // 弹出左括号
        } else if (opPriority.containsKey(token)) {
            while (!opStack.isEmpty() && 
                  !opStack.peek().equals("(") &&
                  opPriority.get(opStack.peek()) >= opPriority.get(token)) {
                // 处理栈顶高优先级运算符
            }
            opStack.push(token);
        } else {
            // 处理数字或变量
            List<Term> term = parseTerm(token);
            numStack.push(term);
        }
    }
    // 处理剩余运算符
    while (!opStack.isEmpty()) {
        // 弹出计算
    }
    return numStack.pop();
}

3.3 多项式运算实现

Term类的核心方法实现示例：

java复制class Term implements Comparable<Term> {
    // 同类项判断
    public boolean isSameType(Term other) {
        return this.variables.equals(other.variables);
    }
    
    // 加法实现
    public Term add(Term other) {
        if (!isSameType(other)) {
            throw new IllegalArgumentException();
        }
        return new Term(this.coefficient + other.coefficient, this.variables);
    }
    
    // 乘法实现（变量组合合并）
    public Term multiply(Term other) {
        List<String> newVars = new ArrayList<>(this.variables);
        newVars.addAll(other.variables);
        Collections.sort(newVars); // 标准化变量顺序
        return new Term(this.coefficient * other.coefficient, newVars);
    }
    
    // 实现Comparable接口用于排序
    @Override
    public int compareTo(Term other) {
        if (this.variables.size() != other.variables.size()) {
            return other.variables.size() - this.variables.size();
        }
        for (int i = 0; i < this.variables.size(); i++) {
            int cmp = this.variables.get(i).compareTo(other.variables.get(i));
            if (cmp != 0) return cmp;
        }
        return 0;
    }
}

4. 常见问题与优化技巧

4.1 边界情况处理

1. 空表达式处理：

   java复制if (expression == null || expression.trim().isEmpty()) {
       return Collections.emptyList();
   }
   

2. 除法截断问题：

   java复制// 在Term的divide方法中
   public Term divide(Term other) {
       if (other.coefficient == 0) throw new ArithmeticException();
       if (!other.variables.isEmpty()) {
           throw new UnsupportedOperationException();
       }
       return new Term(this.coefficient / other.coefficient, this.variables);
   }
   

3. 变量顺序标准化：

   • 在乘法运算后对变量列表排序，确保x*y和y*x被视为同类项

4.2 性能优化点

1. 预计算优化：

   • 对常量表达式如(1+2)*3，可在编译期直接计算出结果
   • 使用memoization缓存已解析的变量组合

2. 并行计算：

   • 对于超长表达式，可以分段并行计算后合并结果

3. 内存优化：

   • 使用Flyweight模式共享相同的变量组合对象

4.3 测试用例设计

建议覆盖以下场景：

java复制@Test
public void testCases() {
    // 纯数字运算
    test("1 + 2 * 3", Arrays.asList("7"));
    
    // 变量运算
    test("x * y + x * z", Arrays.asList("x*y", "x*z"));
    
    // 括号改变优先级
    test("(x + y) * (x - y)", Arrays.asList("x*x", "-y*y"));
    
    // 除法截断
    test("5 / 2 * x", Arrays.asList("2*x"));
    
    // 混合运算
    test("x * 3 + y * 2 + x * y", Arrays.asList("x*y", "3*x", "2*y"));
}

5. 工程实践扩展

在实际项目中，这种表达式计算器可以进一步扩展为：

1. 函数支持：

   • 添加sin、log等数学函数
   • 需要扩展词法分析识别函数名

2. 类型系统：

   • 区分整数、浮点数、布尔值等类型
   • 实现自动类型转换

3. 错误处理：

   • 友好的语法错误提示
   • 支持错误恢复机制

4. 性能监控：

   • 统计表达式计算耗时
   • 识别性能热点

我在实际项目中实现过一个类似的计算引擎，用于金融衍生品定价。关键经验是：

• 使用解释器模式分离语法解析和执行逻辑
• 采用访问者模式实现不同操作（如求值、格式化、求导）
• 对于高频调用场景，可以编译为Java字节码动态执行

重要提示：在除法运算时，如果除数是变量表达式（如x/y），根据题目要求应该直接报错而非继续计算。这是很多初次尝试者容易忽略的边界条件。