用Java实现基于栈结构的中缀表达式求值

思路：

1. 定义两个栈，一个用于存储运算符，一个用于存储操作数；
2. 从左到右遍历中缀表达式中的每个字符；
3. 如果当前字符是数字，则直接压入操作数栈；
4. 如果当前字符是左括号，则直接压入运算符栈；
5. 如果当前字符是右括号，则不断弹出运算符栈中的元素，直到遇到左括号为止，将弹出的运算符与对应的操作数进行计算，将计算结果压入操作数栈；
6. 如果当前字符是运算符，则不断弹出运算符栈中优先级大于等于当前运算符的元素，将弹出的运算符与对应的操作数进行计算，将计算结果压入操作数栈，最后将当前运算符压入运算符栈；
7. 遍历完成后，依次弹出运算符栈中的元素，进行计算，直到运算符栈为空，最后操作数栈中剩下的元素即为表达式的计算结果。

代码实现：

import java.util.*;

public class InfixEvaluation {

    // 判断是否为运算符
    private static boolean isOperator(char c) {
        return c == '+' || c == '-' || c == '*' || c == '/';
    }

    // 获取运算符的优先级
    private static int getPriority(char c) {
        switch (c) {
            case '+':
            case '-':
                return 1;
            case '*':
            case '/':
                return 2;
            default:
                return 0;
        }
    }

    // 计算表达式
    private static int evaluate(int a, int b, char operator) {
        switch (operator) {
            case '+':
                return a + b;
            case '-':
                return a - b;
            case '*':
                return a * b;
            case '/':
                return a / b;
            default:
                return 0;
        }
    }

    // 中缀表达式求值
    public static int evaluateInfix(String expression) {
        Stack<Integer> operands = new Stack<>(); // 操作数栈
        Stack<Character> operators = new Stack<>(); // 运算符栈

        for (int i = 0; i < expression.length(); i++) {
            char c = expression.charAt(i);
            if (Character.isDigit(c)) { // 如果是数字，直接入栈
                int num = c - '0';
                while (i < expression.length() - 1 && Character.isDigit(expression.charAt(i + 1))) {
                    num = num * 10 + expression.charAt(i + 1) - '0';
                    i++;
                }
                operands.push(num);
            } else if (c == '(') { // 如果是左括号，直接入栈
                operators.push(c);
            } else if (c == ')') { // 如果是右括号，不断弹出运算符栈中的元素，直到遇到左括号为止
                while (operators.peek() != '(') {
                    char operator = operators.pop();
                    int b = operands.pop();
                    int a = operands.pop();
                    int result = evaluate(a, b, operator);
                    operands.push(result);
                }
                operators.pop(); // 弹出左括号
            } else if (isOperator(c)) { // 如果是运算符
                while (!operators.empty() && getPriority(operators.peek()) >= getPriority(c)) {
                    char operator = operators.pop();
                    int b = operands.pop();
                    int a = operands.pop();
                    int result = evaluate(a, b, operator);
                    operands.push(result);
                }
                operators.push(c);
            }
        }

        while (!operators.empty()) { // 弹出运算符栈中的元素，进行计算
            char operator = operators.pop();
            int b = operands.pop();
            int a = operands.pop();
            int result = evaluate(a, b, operator);
            operands.push(result);
        }

        return operands.pop(); // 返回操作数栈中的元素，即为表达式的计算结果
    }

    public static void main(String[] args) {
        String expression = "3+4*5-(6+7)*8/2";
        int result = evaluateInfix(expression);
        System.out.println(expression + " = " + result);
    }
}