(标签-c++|关键词-运算符)

Question

描述

将一个算式表达式的值求出来，在表达式中，有加、减、乘、除 4 个运算符，还有括号（括号匹配无误），其余的为 0−9之间的某个正整数，例如表达式为 9−(6+3×5)/3 ，则该表达式的值为 2。

输入描述

输入文件即为一行表达式，保证表达式格式正确，字符串长度小于等于10000

输出描述

输出文件即为表达式的值，结果保留 2 位小数

样例输入 1

9-(6+3*5)/3
样例输出 1

2.00
用c++怎么写啊！

Answer 1

该回答引用自GPT-deepseek, 由博主 GISer Liu 编写：

问题分析

用户的需求是实现一个C++程序，能够解析并计算包含加、减、乘、除和括号的数学表达式，并输出保留两位小数的结果。表达式中的运算符优先级需要正确处理，且括号的优先级最高。

解决思路

1. 表达式解析：我们需要将输入的字符串表达式解析成可以计算的形式。由于表达式可能包含括号，我们需要处理运算符的优先级。

2. 运算符优先级：乘法和除法的优先级高于加法和减法，括号内的表达式需要优先计算。

3. 栈的使用：我们可以使用栈来帮助处理运算符的优先级和括号的匹配。具体来说，可以使用两个栈：一个用于存储操作数，另一个用于存储运算符。

4. 计算过程：遍历表达式，遇到数字时将其压入操作数栈，遇到运算符时根据优先级决定是否进行计算，遇到括号时递归处理括号内的表达式。

解决方案

我们可以使用逆波兰表达式（后缀表达式）的方法来解决这个问题。具体步骤如下：

1. 中缀表达式转后缀表达式：将中缀表达式转换为后缀表达式，这样可以方便地使用栈来计算表达式的值。
2. 计算后缀表达式：使用栈来计算后缀表达式的值。

代码实现

#include <iostream>
#include <stack>
#include <string>
#include <cctype>
#include <iomanip>

using namespace std;

// 判断运算符的优先级
int precedence(char op) {
    if (op == '+' || op == '-') return 1;
    if (op == '*' || op == '/') return 2;
    return 0;
}

// 计算两个数的运算结果
double applyOp(double a, double b, char op) {
    switch (op) {
        case '+': return a + b;
        case '-': return a - b;
        case '*': return a * b;
        case '/': return a / b;
    }
    return 0;
}

// 计算表达式的值
double evaluate(string expression) {
    stack<double> values;  // 存储操作数
    stack<char> ops;       // 存储运算符

    for (int i = 0; i < expression.length(); i++) {
        // 跳过空格
        if (expression[i] == ' ') continue;

        // 如果是数字，读取完整的数字
        if (isdigit(expression[i])) {
            double val = 0;
            while (i < expression.length() && isdigit(expression[i])) {
                val = (val * 10) + (expression[i] - '0');
                i++;
            }
            values.push(val);
            i--;  // 因为for循环会自增i
        }

        // 如果是左括号，压入运算符栈
        else if (expression[i] == '(') {
            ops.push(expression[i]);
        }

        // 如果是右括号，计算括号内的表达式
        else if (expression[i] == ')') {
            while (!ops.empty() && ops.top() != '(') {
                double val2 = values.top();
                values.pop();

                double val1 = values.top();
                values.pop();

                char op = ops.top();
                ops.pop();

                values.push(applyOp(val1, val2, op));
            }
            ops.pop();  // 弹出左括号
        }

        // 如果是运算符
        else {
            while (!ops.empty() && precedence(ops.top()) >= precedence(expression[i])) {
                double val2 = values.top();
                values.pop();

                double val1 = values.top();
                values.pop();

                char op = ops.top();
                ops.pop();

                values.push(applyOp(val1, val2, op));
            }
            ops.push(expression[i]);
        }
    }

    // 计算剩余的表达式
    while (!ops.empty()) {
        double val2 = values.top();
        values.pop();

        double val1 = values.top();
        values.pop();

        char op = ops.top();
        ops.pop();

        values.push(applyOp(val1, val2, op));
    }

    return values.top();
}

int main() {
    string expression;
    getline(cin, expression);

    double result = evaluate(expression);
    cout << fixed << setprecision(2) << result << endl;

    return 0;
}

代码解释

1. precedence函数：用于判断运算符的优先级，乘法和除法的优先级高于加法和减法。

2. applyOp函数：根据运算符对两个操作数进行相应的运算。

3. evaluate函数：核心函数，用于解析表达式并计算结果。使用两个栈分别存储操作数和运算符，根据运算符的优先级和括号的匹配进行计算。

4. main函数：读取输入的表达式，调用evaluate函数计算结果，并输出保留两位小数的结果。

示例运行

对于输入 9-(6+3*5)/3，程序将输出 2.00。

总结

通过使用栈来处理运算符的优先级和括号的匹配，我们可以有效地解析并计算复杂的数学表达式。该方法不仅适用于简单的四则运算，还可以扩展到更复杂的表达式计算。

如果该回答解决了您的问题，请采纳！如果没有，请私信联系或评论您的疑惑