数据结构课程设计表达式计算java

好的，为了完成这个任务，我们需要以下几个步骤：

1. 定义一个栈结构，用于存储运算符和操作数。
2. 读入一个中缀表达式字符串。
3. 将中缀表达式字符串转换为后缀表达式字符串。
4. 计算后缀表达式字符串的值。

以下是具体的代码实现：

1. 定义栈结构

我们可以使用 Java 的 Stack 类来实现栈结构。定义如下：

import java.util.Stack;

public class ExpressionCalculator {
    private Stack<Character> operatorStack;
    private Stack<Double> operandStack;

    public ExpressionCalculator() {
        operatorStack = new Stack<Character>();
        operandStack = new Stack<Double>();
    }

    //...
}

在这个类中，我们定义了两个栈：`operatorStack` 用于存储运算符，`operandStack` 用于存储操作数。

2. 读入中缀表达式字符串

我们可以使用 Java 的 Scanner 类来读入中缀表达式字符串。定义如下：

import java.util.Scanner;

public class ExpressionCalculator {
    //...

    public void inputExpression() {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入中缀表达式：");
        String expression = scanner.nextLine();
        //...
    }
}

在这个方法中，我们通过 `Scanner.nextLine()` 方法读入用户输入的中缀表达式字符串。

3. 将中缀表达式字符串转换为后缀表达式字符串

我们可以使用栈结构来实现中缀表达式转后缀表达式的算法。具体实现如下：

public String infixToPostfix(String infix) {
    StringBuilder postfix = new StringBuilder();
    for (int i = 0; i < infix.length(); i++) {
        char ch = infix.charAt(i);
        if (Character.isDigit(ch)) {
            // 如果是数字，直接输出到后缀表达式字符串中
            postfix.append(ch);
        } else if (ch == '+' || ch == '-' || ch == '*' || ch == '/') {
            // 如果是运算符
            while (!operatorStack.empty() && priority(operatorStack.peek()) >= priority(ch)) {
                postfix.append(operatorStack.pop());
            }
            operatorStack.push(ch);
        } else if (ch == '(') {
            // 如果是左括号
            operatorStack.push(ch);
        } else if (ch == ')') {
            // 如果是右括号
            while (operatorStack.peek() != '(') {
                postfix.append(operatorStack.pop());
            }
            operatorStack.pop(); // 弹出左括号
        }
    }
    // 将剩余的运算符输出到后缀表达式字符串中
    while (!operatorStack.empty()) {
        postfix.append(operatorStack.pop());
    }
    return postfix.toString();
}

private int priority(char ch) {
    switch (ch) {
        case '+':
        case '-':
            return 1;
        case '*':
        case '/':
            return 2;
        default:
            return 0;
    }
}

在这个方法中，我们遍历中缀表达式字符串的每个字符。如果是数字，则直接输出到后缀表达式字符串中；如果是运算符，则将它和栈顶的运算符进行比较，如果栈顶的运算符优先级大于等于当前运算符，则弹出栈顶的运算符并输出到后缀表达式字符串中，直到栈顶的运算符优先级小于当前运算符或栈为空时，将当前运算符压入栈中；如果是左括号，则直接压入栈中；如果是右括号，则弹出栈中的运算符并输出到后缀表达式字符串中，直到遇到左括号为止。

4. 计算后缀表达式字符串的值

我们可以使用栈结构来实现后缀表达式计算的算法。具体实现如下：

public double evaluate(String postfix) {
    for (int i = 0; i < postfix.length(); i++) {
        char ch = postfix.charAt(i);
        if (Character.isDigit(ch)) {
            // 如果是数字，压入操作数栈中
            operandStack.push((double) (ch - '0'));
        } else if (ch == '+' || ch == '-' || ch == '*' || ch == '/') {
            // 如果是运算符，弹出操作数栈中的两个操作数进行计算，将结果压入操作数栈中
            double operand2 = operandStack.pop();
            double operand1 = operandStack.pop();
            switch (ch) {
                case '+':
                    operandStack.push(operand1 + operand2);
                    break;
                case '-':
                    operandStack.push(operand1 - operand2);
                    break;
                case '*':
                    operandStack.push(operand1 * operand2);
                    break;
                case '/':
                    operandStack.push(operand1 / operand2);
                    break;
            }
        }
    }
    // 返回操作数栈中的唯一元素，即计算结果
    return operandStack.pop();
}

在这个方法中，我们遍历后缀表达式字符串的每个字符。如果是数字，则将它转换为 double 类型并压入操作数栈中；如果是运算符，则弹出操作数栈中的两个操作数进行计算，将结果压入操作数栈中。最终，操作数栈中只剩下一个元素，就是计算结果。

完整代码如下：