中缀表达式转换为后缀表达式求值算法

转载自:http://www.cnblogs.com/wanghetao/archive/2012/04/23/2466580.html

逆波兰表达式

 

表达式一般由操作数(Operand)、运算符(Operator)组成，例如算术表达式中，通常把运算符放在两个操作数的中间，

这称为中缀表达式(Infix Expression)，如A+B。

波兰数学家Jan Lukasiewicz提出了另一种数学表示法，它有两种表示形式：

把运算符写在操作数之前，称为波兰表达式(Polish Expression)或前缀表达式(Prefix Expression)，如+AB；

把运算符写在操作数之后，称为逆波兰表达式(Reverse Polish Expression)或后缀表达式(Suffix Expression)，如AB+；

其中，逆波兰表达式在编译技术中有着普遍的应用。

 

算法：

一、 将中缀表达式转换成后缀表达式算法：

1、从左至右扫描一中缀表达式。

2、若读取的是操作数，则判断该操作数的类型，并将该操作数存入操作数堆栈

3、若读取的是运算符

  (1) 该运算符为左括号"("，则直接存入运算符堆栈。

  (2) 该运算符为右括号")"，则输出运算符堆栈中的运算符到操作数堆栈，直到遇到左括号为止。

  (3) 该运算符为非括号运算符：

      (a) 若运算符堆栈栈顶的运算符为括号，则直接存入运算符堆栈。

      (b) 若比运算符堆栈栈顶的运算符优先级高或相等，则直接存入运算符堆栈。

      (c) 若比运算符堆栈栈顶的运算符优先级低，则输出栈顶运算符到操作数堆栈，并将当前运算符压入运算符堆栈。

4、当表达式读取完成后运算符堆栈中尚有运算符时，则依序取出运算符到操作数堆栈，直到运算符堆栈为空。

 

二、逆波兰表达式求值算法：

1、循环扫描语法单元的项目。

2、如果扫描的项目是操作数，则将其压入操作数堆栈，并扫描下一个项目。

3、如果扫描的项目是一个二元运算符，则对栈的顶上两个操作数执行该运算。

4、如果扫描的项目是一个一元运算符，则对栈的最顶上操作数执行该运算。

5、将运算结果重新压入堆栈。

6、重复步骤2-5，堆栈中即为结果值。

c++代码示例

*
*    这里主要是逆波兰式的实现，使用两个stack 这里用字符串来模拟一个stack，第一步，将中缀表达式转变为后缀表达式
*    第二步，然后再使用一个stack，计算后缀表达式的结果，这一步很容易出错，考虑到浮点数的问题。
*/
#include <iostream>
#include <string>
#include <stack>
#include <iomanip>

using namespace std;

int cmp(char ch)     // 运算符优先级
{
    switch(ch)
    {
        case '+':
        case '-': return 1;
        case '*':
        case '/': return 2;
        default : return 0;
    }
}
void change(string &s1, string &s2)       // 中缀表达式转变后缀表达式
{
    stack <char > s;
    s.push('#');
    int i = 0;
    while(i < s1.length()-1)
    {
        if(s1[i] == '(')
        {
            s.push(s1[i++]);
        }
        else if(s1[i] == ')')
        {
            while(s.top() != '(')
            {
                s2 += s.top();
                s2 += ' ';
                s.pop();
            }
            s.pop();
            i++;
        }
        else if(s1[i] == '+'||s1[i] == '-'||s1[i] == '*'||s1[i] == '/')
        {
            while(cmp(s.top()) >= cmp(s1[i]))
            {
                s2 += s.top();
                s2 += ' ';
                s.pop();
            }
            s.push(s1[i]);
            i++;
        }
        else
        {
            while('0' <= s1[i]&&s1[i] <= '9'||s1[i] == '.')
            {
                s2 += s1[i++];
            }
            s2 += ' ';
        }
    }
    while(s.top() != '#')
    {
        s2 += s.top();
        s2 += ' ';
        s.pop();
    }
}

double value(string s2)         // 计算后缀表达式，得到其结果。
{
    stack < double> s;
    double x,y;
    int i = 0;
    while(i < s2.length())
    {
        if(s2[i] == ' ')
        {
            i++;
            continue;
        }
        switch(s2[i])
        {
            case '+': x = s.top(); s.pop(); x += s.top(); s.pop(); i++; break;
            case '-': x = s.top(); s.pop(); x =s.top()-x; s.pop(); i++; break;
            case '*': x = s.top(); s.pop(); x *= s.top(); s.pop(); i++; break;
            case '/': x = s.top(); s.pop(); x = s.top()/x; s.pop(); i++; break;
            default :
            {
                x = 0;
                while('0' <= s2[i]&&s2[i] <= '9')
                {
                    x = x*10+s2[i] - '0';
                    i++;
                }
                if(s2[i] == '.')
                {
                    double k = 10.0;
                    y = 0;
                    i++;
                    while('0' <= s2[i]&&s2[i] <= '9')
                    {
                        y += ((s2[i]-'0')/k);
                        i++;
                        k *= 10;
                    }
                    x += y;
                }
            }
        }
        s.push(x);
    }
    return s.top();
}
int main(int argc, char const *argv[])
{
    int n;
    string s1,s2;
    cin>>n;
    while(n--)
    {
        cin>>s1;
        s2 = "";
        change(s1,s2);
        cout<<fixed<<setprecision(2)<<value(s2)<<endl;
    }
    return 0;
}