关于逆波兰式

一个表达式E的逆波兰式如下定义：

1. 如果E是一个变量或者常量，E的后缀式是其自身；
2. 如果E是E1 op E2的形式，则其后缀式是E1' E2' op的形式，其中E1'表示E1的后缀式；
3. 如果E=(E1)，那么E的后缀式与E1相同（换言之，逆波兰式不需要括号来表示优先级）；

将一个普通的中缀表达式exp转换为逆序表达式的一般算法是：

stack s1,s2; //s1是临时存放运算符的，s2是存放后缀式的

s1.push('#'); //放入优先级最低的符号

for x in exp:

    if(x is num):

        y=got(x);        //注意这里got函数里面必须完成x迭代器的前行

s2.push(y);

    else if(x is op):

　　　　while(x<=s1.top() || s1.top=='('):

　　　　　　s2.push(s1.pop());

　　　　if(x==')'):

　　　　　　while(s1.top()!='(')s2.push(s1.pop());

　　　　　　s1.pop();

　　　　else s1.push(x);

　　while(s1.top()!='#')s2.push(s1.pop());

完成上述步骤后，s2中存放的即是倒序的逆波兰式；

利用逆波兰式posfix计算:

stack s;

doubel lhs,rhs=s.top();

for x in posfix:

    if(x is op):

　　　　rhs=s.pop();

　　　　lhs=s.pop();

　　　　rhs=calc(lhs,rhs,x);

　　　　s.push(rhs);

　　else s.push(x)

return rhs;

如果需要计算浮点数，最好将操作符映射成小浮点数；

无bug的解决方案是先分词，然后用stack存放单词结构，无须映射，更加清晰；

补上例程：

#include <vector>
#include <map>
#include <stack>
#include <iostream>
#include <sstream>
#include <string>
#include <cctype>
using namespace std;

struct Word
{
    Word(char k='n',double v=0):
        kind(k),value(v)
    {

    }
    char kind;
    double value;
};
bool isOperator(char k)
{
    static char op[]=
    {
        '+','-','*','/','(',')'
    };
    int size=sizeof(op)/sizeof(op[0]);
    for(int i=0;i!=size;++i)
    {
        if (k==op[i])
        {
            return true;
        }
    }
    return false;
}
int split2Words(const string& srcString,vector<Word> &dst)
{
    dst.clear();
    stringstream ss;
    ss<<srcString;
    char kindFlag;
    double value;
    while (ss>>kindFlag)
    {
        if(isdigit(kindFlag))
        {
            ss.putback(kindFlag);
            ss>>value;
            dst.push_back(Word('n',value));
        }else if(isOperator(kindFlag))
        {
            dst.push_back(Word(kindFlag));
        }
        else
        {
            return -1;
        }
    }
    return 0;
}
int convert2Posfix(vector<Word> &words)
{
    stack<Word> s1,s2;
    s1.push('#');
    static map<char,char> priority;
    if (priority.empty())
    {
        priority['#']=0;
        priority['+']=2;
        priority['-']=2;
        priority['*']=3;
        priority['/']=3;
        priority['(']=4;
        priority[')']=4;
    }
    Word current;
    for(int i=0;i!=words.size();++i)
    {
        current=words[i];
        if (current.kind=='n')
        {
            s2.push(current);
        }else
        {
            while(priority[current.kind]<=priority[s1.top().kind] && s1.top().kind!='(')
            {
                s2.push(s1.top());
                s1.pop();
            }
            if (current.kind==')')
            {
                while(s1.top().kind!='(')
                {
                    s2.push(s1.top());
                    s1.pop();
                }
                s1.pop();
            }else
            {
                s1.push(current);
            }
        }
    }
    while(s1.top().kind!='#')
    {
        s2.push(s1.top());
        s1.pop();
    }
    words.clear();
    while (!s2.empty())
    {
        words.insert(words.begin(),s2.top());
        s2.pop();
    }
    //for (int i=0;i!=words.size();++i)
    //{
    //    if (words[i].kind=='n')
    //    {
    //        cout<<words[i].value;
    //    }else
    //    {
    //        cout<<words[i].kind;
    //    }
    //}
    //cout<<endl;
    return 0;
}
double calc(double lhs,double rhs,char op)
{
    switch (op)
    {
    case '+':
        return lhs+rhs;
    case '-':
        return lhs-rhs;
    case '*':
        return lhs*rhs;
    case '/':
        return lhs/rhs;
    default:
        break;
    }
    return 0;
}
double calcPosix(const vector<Word> &words)
{
    stack<double> s1;
    double lhs,rhs=words[0].value;
    for(int i=0;i!=words.size();++i)
    {
        if (words[i].kind=='n')
        {
            s1.push(words[i].value);
        }else
        {
            rhs=s1.top();
            s1.pop();
            lhs=s1.top();
            s1.pop();
            rhs=calc(lhs,rhs,words[i].kind);
            s1.push(rhs);
        }
    }
    return rhs;
}
int main()
{
    string expression;
    vector<Word> words;
    double result;
    while(getline(cin,expression))
    {    
        int flag=split2Words(expression,words);
        //if(flag<0) exit(EXIT_FAILTURE);
        convert2Posfix(words);
        result=calcPosix(words);
        cout<<result<<endl;
    }

    return 0;
}

上述例程可以计算含括号的浮点数普通四则运算，但是没有错误处理功能…

程序待优化。