算法笔记 6.7 问题A【codeup 1918】简单计算器

以下来源：《算法笔记》第7章 提高篇（1）——数据结构专题（1） P247

题目描述

读入一个只包含 +, -, *, / 的非负整数计算表达式，计算该表达式的值。

输入

测试输入包含若干测试用例，每个测试用例占一行，每行不超过200个字符，整数和运算符之间用一个空格分隔。没有非法表达式。当一行中只有0时输入结束，相应的结果不要输出。

输出

对每个测试用例输出1行，即该表达式的值，精确到小数点后2位。

样例输入

30 / 90 - 26 + 97 - 5 - 6 - 13 / 88 * 6 + 51 / 29 + 79 * 87 + 57 * 92
0

样例输出

12178.21

思路

步骤1：中缀表达式转后缀表达式

1. 设立一个操作符栈，用以临时存放操作符；设立一个数组或队列，用以存放后缀表达式。
2. 从左至右扫描中缀表达式，如果碰到操作数（操作数可能不止一位，因此需要一位一位读入然后合并），就把操作数加入后缀表达式中。
3. 如果碰到操作符op，就将其优先级与操作符栈的栈顶操作符的优先级比较。
   • 若op的优先级高于栈顶操作符的优先级，则压入操作符栈。
   • 若op的优先级低于或等于栈顶操作符的优先级，则将操作符栈的操作符不断弹出到后缀表达式中，直到op的优先级高于栈顶操作符的优先级。
4. 重复上述操作，直到中缀表达式扫描完毕，之后若操作符栈中仍有元素，则将它们依次弹出至后缀表达式中。
5. 若出现括号，在步骤3前判断，如果是左括号，就压入操作符栈；如果是右括号，就把操作符里的元素不断弹出到后缀表达式直到碰到左括号。

步骤2：计算后缀表达式

1. 从左到右臊面后缀表达式，如果是操作数，就压入栈。
2. 如果是操作符，就连续弹出两个操作数（先弹出的是第二操作数，后弹出的是第一操作数），然后进行操作符的操作。
3. 生成的新操作数压入栈中。
4. 反复直到后缀表达式扫描完毕，这时栈中只会存在一个数，就是最终的答案。
5. 注意除法可能导致浮点数，因此操作数类型要设成浮点型。
6. 题目中说肯定是合法表达式，因此上面的操作一定能够成功。但如果题目表明可能出现非法表达式，那就要注意每一步使用的对象是否合法。

• 用string的erase方法可以直接把表达式中的空格去掉。

参考代码

#include <cstdio>
#include <iostream>
#include <string>
#include <stack>
#include <queue>
#include <map>
using namespace std;

struct node {
    double num; //操作数
    char op; //操作符
    bool flag; //true表示操作数，false表示操作符
};

string str; //输入字符串
stack<node> s; //操作符栈
queue<node> q; //后缀表达式
map<char, int> op; //操作符优先级

//将中缀表达式转换为后缀表达式
void Change() {
    double num;
    node temp;
    for(int i = 0; i < str.length();) {
        if(str[i] >= '0' && str[i] <= '9') { //如果是操作数
            temp.flag = true; //标记是操作数
            temp.num = str[i++] - '0'; //记录操作数的第一位
            while(i < str.length() && str[i] >= '0' && str[i] <= '9') { //如果操作数不止一位
                temp.num = temp.num * 10 + (str[i] - '0'); //更新操作数
                i++;
            }
            q.push(temp);
        } else { //如果是操作符
            temp.flag = false; //标记是操作符
            while(!s.empty() && op[str[i]] <= op[s.top().op]) {
                //只要操作符栈的栈顶元素比该操作符高，就把操作符栈栈顶元素弹出到后缀表达式中
                q.push(s.top());
                s.pop();
            }
            temp.op = str[i];
            s.push(temp); //把该操作符压入操作符栈中
            i++;
        }
    }
    while(!s.empty()) { //如果操作符栈还有操作符，就把它弹出到后缀表达式中
        q.push(s.top());
        s.pop();
    }
}

//计算后缀表达式
double Cal() {
    double temp1, temp2;
    node cur, temp;
    while(!q.empty()) { //只要后最表达式队列非空
        cur = q.front(); //记录队首元素
        q.pop();
        if(cur.flag == true) //如果是操作数，直接压入栈
            s.push(cur);
        else { //如果是操作符
            temp2 = s.top().num; //弹出第二个操作数
            s.pop();
            temp1 = s.top().num; //弹出第一个操作数
            s.pop();
            temp.flag = true; //记录临时操作数（本次计算结果）
            if(cur.op == '+') //加法
                temp.num = temp1 + temp2;
            else if(cur.op == '-') //减法
                temp.num = temp1 - temp2;
            else if(cur.op == '*') //乘法
                temp.num = temp1 * temp2;
            else //除法
                temp.num = temp1 / temp2;
            s.push(temp); //把该操作数压入栈
        }
    }
    return s.top().num; //栈顶元素就是后缀表达式的值
}

int main() {
    //设定操作符的优先级
    op['+'] = op['-'] = 1;
    op['*'] = op['/'] = 2;
    //输入并处理表达式
    while(getline(cin, str), str != "0") {
        for(string::iterator it = str.end(); it != str.begin(); it--) {
            if(*it == ' ') //把表达式中的空格全部去掉
                str.erase(it);
        }
        while(!s.empty()) //初始化栈
            s.pop();
        Change();
        printf("%.2f\n", Cal());
    }
    return 0;
}