逆波兰表达式求值

二元运算符的表达式定义为：(操作数) + (运算符) + (操作数) ，其中操作数也可以为表达式。
在计算机中，根据运算符所在的不同位置来命名，表达式可以有如下三种不同的表示方法：
记表达式为：Exp = S1 + OP + S2， S1和S2为操作数，OP为运算符。
则称 OP + S1 + S2 为表达式的前缀表示法；
称 S1 + OP + S2 为表达式的中缀表示法；
称 S1 + S2 + OP 为表达式的后缀表示法。

例如，对于表达式 Exp = a * b + (c - d / e) * f
前缀表达式为： + * a b * - c / d e f
中缀表达式为： a * b + c - d / e * f
后缀表达式为： a b * c d e / - f * +

对于这三种表达式，操作数之间的相对次序不变，而运算符的相对次序却不同。前缀表达式的运算规则为：连续出现的两个操作数和在它们 之前且紧靠它们的运算符构成一个最小表达式。中缀表达式由于丢失了括号信息，从而导致运算的次序不确定。后缀表达式是波兰逻辑学家 Jan.Lukasiewicz 发明的，通常又称为逆波兰表达式，它不需要括号，运算规则为：运算符在式中出现的顺序恰为表达式的运算顺序；每个运算符和在它之前出现且紧靠它的两个操作数构成一个最小表达式。

利用逆波兰表达式进行求值，对我们人类来说是不大好接受的，但是对计算机来说却是非常方便的，因为利用栈就能够很容易实现。具体的求值方法是先找运算符后找操作数。下面通过图示来进行分析。
例如对于表达式：1.3 * 2 + (5.1 - 3.6 / 2) * 4，其逆波兰表达式为：1.3 2 * 5.1 3.6 2 / - 4 * +

利用栈来对逆波兰表达式求值过程如下：
① 建立一个栈，首先将操作数 1.3 和 2 入栈，遇到 * 运算符则依次弹出两个元素进行运算，并把运算结果入栈。这里依次将 2 和 1.3 弹出执行 1.3*2 运算，把结果为 2.6 入栈。

② 将 5.1、3.6、2 依次入栈，遇到 / 运算符则依次将 2 和 3.6 弹出执行 3.6/2 运算， 把结果1.8 入栈。

③ 遇到 - 运算符则将1.8 和 5.1 依次弹出执行 5.1 - 1.8 运算， 把结果 3.3 入栈。

④ 将 4 入栈，遇到 * 运算符则依次将 4 和 3.3 弹出执行 3.3 * 4，把结果 13.2 入栈。

⑤ 遇到 + 运算符则依次将 13.2 和 2.6 弹出执行 2.6 + 13.2，把结果 15.8 入栈。然后没有数据需要入栈，将 15.8 弹出即为最终运算结果。

接下来考虑代码的实现。我们在逆波兰表达式的输入最后加一个 # 表示输入的结束。建立一个存放 double 型数字的栈，用一个数组存放需要输入的操作数的每个字符（包括小数点），操作符和运算符之间用空格隔开。利用 C++ 中的容器适配器 stack 可以写出 C++ 代码如下：

#include <iostream>
#include <stack>
using namespace std;

const int MAXBUFFER = 10;

int main()
{
    stack<double> s;
    char c;
    double d, e;
    char str[MAXBUFFER];
    int i = 0;

    cout << "请按逆波兰表达式输入待计算数据，数据与运算符之间用空格隔开，以#作为结束标志：" << endl;
    c = getchar();
    while (c != '#')
    {
        while (isdigit(c) || c == '.')
        {
            str[i++] = c;
            str[i] = '\0';
            if (i >= 10)
            {
                cout << "错误：数字太大了!" << endl;
                return -1;
            }

            c = getchar();
            if (c == ' ')
            {
                d = atof(str);  // 把字符串转换成浮点数
                s.push(d);
                i = 0;
                break;
            }
        }

        switch ( c )
        {
        case '+':
            e = s.top();
            s.pop();
            d = s.top();
            s.pop();
            s.push(d + e);
            break;
        case '-':
            e = s.top();
            s.pop();
            d = s.top();
            s.pop();
            s.push(d - e);
            break;
        case '*':
            e = s.top();
            s.pop();
            d = s.top();
            s.pop();
            s.push(d * e);
            break;
        case '/':
            e = s.top();
            s.pop();
            d = s.top();
            s.pop();
            if (e != 0)
            {
                s.push(d / e);
            }
            else
            {
                cout << "错误：除数为零" << endl;
                return -1;
            }
            break;
        }

        c = getchar();
    }

    cout << "运算结果为: " << s.top() << endl;
    s.pop();
    return 0;
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• 51
• 52
• 53
• 54
• 55
• 56
• 57
• 58
• 59
• 60
• 61
• 62
• 63
• 64
• 65
• 66
• 67
• 68
• 69
• 70
• 71
• 72
• 73
• 74
• 75
• 76
• 77
• 78
• 79
• 80
• 81
• 82
• 83
• 84
• 85
• 86