表达式求值

首先要知道如何求逆波兰式(后缀表达式)：

　　表达式的表示形式有中缀、前缀和后缀3中形式。中缀表达式按操做符的优先级进行计算（后面代码实现只包括+、-、*、\,小括号），即数学运算。 后缀表达式中只有操做数和操做符。操做符在两个操做数以后。它的计算规则很是简单，严格按照从左到右的次序依次执行每个操做。每遇到一个操做符，就将前面的两个数执行相应的操做。 
　　由后缀表达式计算中缀表达式原理：计算机处理后缀表达式求值问题是比较方便的，即将遇到的操做数暂存于一个操做数栈中，凡是遇到操做数，便从栈中pop出两个操做数，并将结果存于操做数栈中，直到对后缀表达式中最后一个操做数处理完，最后压入栈中的数就是后最表达式的计算结果。 

　中缀表达式转换为等价的后缀表达式 
　中缀表达式不方便与计算机处理，一般要讲中缀表达式转换为一个与之等价的后缀表达式。等价是指两个表达式的计算顺序和计算结果彻底相同。 
　　中缀表达式：0.3/(5*2+1)# 的等价后缀表达式是：0.3 5 2 * 1 + /# 
　　仔细观察这两个等价的表达式可知，操做数的出现次序是相同的，但运算符的出现次序是不一样的。在后缀表达式中，运算符的出现次序是实际进行操做的次序；在中追表达式中，因为受到操做符的优先级和括号的影响，操做符出现次序与实际进行操做的次序极可能是不同的。 

算法描述： 
　　将中缀表达式转换为等价的后缀表达式的过程要使用一个栈放“（”，具体能够按照下面的方式进行。 
　　（1）从左到右依次扫描中缀表达式的每个字符，若是是数字字符和圆点“.”则直接将它们写入后缀表达式中。 
　　（2）若是遇到的是开括号“（”，则将它们压入一个操做符栈（不须要与栈顶操做符相比较），它代表一个新的计算层次的开始，在遇到和它匹配的闭括号“）”时，将栈中的元素弹出来并放入后缀表达式中，直到栈顶元素为“(”时，将栈顶元素“（”弹出（不须要加入后缀表达式），代表这一层括号内的操做处理完毕。 
　　（3）若是遇到的是操做符，则将该操做符和操做符栈顶元素比较： 
    　　　　一、当所遇到的操做符的优先级小于或等于栈顶元素的优先级时，则取 出栈顶元素放入后缀表达式，并弹出该栈顶元素，反复执行直到当前操做符的优先级大于栈顶元素的优先级小于；

    　　　　二、当所遇到的操做符的优先级大于栈顶元素的优先级的时则将它压入栈中。 

　　（4）重复上述步骤直到遇到中缀表达式的结束符标记“#”，弹出栈中的全部元素并放入后缀表达式中，转换结束

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　——copy from 飘过的小牛

 

获得后缀表达式，就不难计算表达式的值，若是是数字压入栈，当遇到运算符，弹出两个(双目)数字计算后再压栈，答案就是栈剩下的最后一个数字

 

代码：

/*
    表达式求值，逆波兰式(后缀表达式)算法
    输入(能够有空格，支持小数，实现'+-/*%')： ((1+2)*5+1)/4=
    注意：取模必定是要整型，实现版本数字全是double，强制类型转换可能倒置错误
    转换为后缀表达式： 获得：1 2 + 5 * 1 + 4 / =
    计算后缀表达式：获得：4.00
*/
struct Exp  {
    stack<char> op;
    stack<double> num;
    bool error;
 
    int prior(char ch)  {                           //运算符的优先级
        switch (ch) {
            case '+':
            case '-': return 1;
            case '*':
            case '%':
            case '/': return 2;
            default:  return 0;
        }
    }
    bool is_digit(char ch)  {
        return '0' <= ch && ch <= '9';
    }
    string get_postfix(string s)    {               //中缀表达式转变后缀表达式
        while (!op.empty ())    op.pop ();
        op.push ('#');
        string ret = "";
        int len = s.length (), i = 0;
        while (i < len)    {
            if (s[i] == ' ' || s[i] == '=')    {
                i++;    continue;
            }
            else if (s[i] == '(')    {
                op.push (s[i++]);
            }
            else if (s[i] == ')')   {
                while (op.top () != '(')    {
                    ret += op.top ();   ret += ' ';
                    op.pop ();
                }
                op.pop ();  i++;
            }
            else if (s[i] == '+' || s[i] == '-' || s[i] == '*' || s[i] == '/' || s[i] == '%')  {
                while (prior (op.top ()) >= prior (s[i]))    {
                    ret += op.top ();   ret += ' ';
                    op.pop ();
                }
                op.push (s[i++]);
            }
            else    {
                while (is_digit (s[i]) || s[i] == '.')  {
                    ret += s[i++];
                }
                ret += ' ';
            }
        }
        while (op.top () != '#') {
            ret += op.top ();   ret += ' ';
            op.pop ();
        }
        ret += '=';
        return ret;
    }
    double cal(double a, double b, char ch) {
        if (ch == '+')  return a + b;
        if (ch == '-')  return a - b;
        if (ch == '*')  return a * b;
        if (ch == '%')  return (int)((int)a % (int)b);
        if (ch == '/')  {
            if (b != 0) return a / b;
            error = true;   return 0;
        }
    }
    double solve(string str)    {                   //计算后缀表达式
        string s = get_postfix (str);
        while (!num.empty ())   num.pop ();
        error = false;
        int len = s.length (), i = 0;
        while (i < len)  {
            if (s[i] == ' ' || s[i] == '=') {i++;   continue;}
            else if (s[i] == '+' || s[i] == '-' || s[i] == '*' || s[i] == '/' || s[i] == '%')  {
                double a = num.top ();  num.pop ();
                double b = num.top ();  num.pop ();
                num.push (cal (b, a, s[i]));    i++;
            }
            else  {
                double x = 0;
                while (is_digit (s[i])) {
                    x = x * 10 + s[i] - '0';    i++;
                }
                if (s[i] == '.')    {
                    double k = 10.0, y = 0;
                    i++;
                    while (is_digit (s[i])) {
                        y += ((s[i] - '0') / k);
                        i++;    k *= 10;
                    }
                    x += y;
                }
                num.push (x);
            }
        }
        return num.top ();
    }
}E;
 
int main(void)    {
    ios::sync_with_stdio (false);                       //若是全用流的话，加这句话能跑快点
    int T;  cin >> T;
    string str; getline (cin, str);
    while (T--) {
        getline (cin, str);
        cout << E.get_postfix (str) << endl;
        cout << fixed << setprecision (6) << E.solve (str) << endl;
    }
 
    return 0;
}

　拿着这个模板就能够解决：NYOJ_467_中缀式变后缀式，NYOJ_35_表达式求值，HDOJ_1237_简单计算器，以及ZSTOJ_4189_逻辑运算 ('!'是单目运算符)