华为机试 四则运算

/*
* 把中缀表达式改成后缀表达式
* 遍历字符串，如果是数字，则输出，同时加上空格和后面的字符分隔
* 如果括号，有2种情况：
* 1 如果是（，进栈
* 2 如果是），将栈里面对应的（以及它上面的符号出栈
* 如果是符号，总的规则是只要栈顶的符号的优先级不低于当前符号，则把栈顶的符号一一出栈，
* 直到遇到栈顶的符号的优先级低于当前符号为止。具体有2种情况：
* 1 如果是+或-，将栈顶的符号一一出栈，直到遇到（或栈空了为止；然后把自身压栈
* 2 如果是*或/，将栈里面的*或/出栈，直到遇到其他符号或栈空了为止；然后把自身压栈
*/
#include<iostream>
#include<string>
#include<stack>
#include<sstream>
using namespace std;

void convert2RPN(string &s) {
    stringstream ss;
    stack<char> stk;
    for (int i = 0; i < s.length(); i++) 
    {
        if (isdigit(s[i])) 
        {//数字
            ss << s[i];
            // 如果下一位不是数字，或者已经是最后一位，就加上空格
            if ((i < s.length() - 1 && !isdigit(s[i + 1]))
                || i == s.length() - 1) 
            {
                ss << ' ';
            }
        }
        else 
        {  //操作符或括号
            if (stk.empty()) 
            {
                stk.push(s[i]);
            }
            else 
            {
                switch (s[i]) 
                {
                case '(':
                    stk.push(s[i]);
                    break;
                case ')':
                    // 把配套的'('和之上的符号出栈
                    while (stk.top() != '(') 
                    {
                        ss << stk.top();
                        stk.pop();
                    }
                    stk.pop();
                    break;
                case '+':
                case '-':
                    // '+' '-' '*' '/'都出栈
                    while (!stk.empty() && stk.top() != '(') 
                    {
                        ss << stk.top();
                        stk.pop();
                    }
                    stk.push(s[i]);
                    break;
                case '*':
                case '/':
                    // '*'和'/'出栈
                    while (!stk.empty() && (stk.top() == '*' || stk.top() == '/')) 
                    {
                        ss << stk.top();
                        stk.pop();
                    }
                    stk.push(s[i]);
                    break;
                }
            }
        }
    }
    // 运算完了，此时把栈的元素都pop出来
    while (!stk.empty()) {
        ss << stk.top();
        stk.pop();
    }
    s = ss.str();
}

/*
* 计算后缀表达式
* 遍历后缀表达式，如果是数字，则压栈，如果是符号，则从栈里面pop两个数字，然后和符号做
* 相应的运算，同时把结果压栈，最后把栈顶结果返回
*/
float calculateRPN(const string &s) {
    stack<float> stk;
    for (size_t i = 0; i < s.length(); i++) {
        // 如果是数字，就和之前的数字组合起来
        if (isdigit(s[i])) {
            int e = atoi(&s[i]);
            int t = e / 10;
            while (t > 0) {
                i++;
                t /= 10;
            }
            i++;
            stk.push(e);
        }
        else {
            float r = stk.top();
            stk.pop();
            float l = stk.top();
            stk.pop();
            float result;
            switch (s[i]) {
            case '+':
                result = l + r;
                break;
            case '-':
                result = l - r;
                break;
            case '*':
                result = l * r;
                break;
            case '/':
                result = l / r;
                break;
            }
            stk.push(result);
        }
    }
    return stk.top();
}

int main()
{
    string str;
    while (cin >> str) {
        convert2RPN(str);
        cout << calculateRPN(str) << endl;
    }
}