逆波兰表达式的实现(也叫后缀表达式)

本文主要偏重实现如何将字符串表达式转换为逆波兰表达式。

关于其讲解参考我转载的一篇博文:http://www.cnblogs.com/vpoet/p/4659546.html

 

先说说优先级：

()    +-     */%（从左到右递增）

 

 

下面先简单再梳理一下:

1.建立两个栈,一个为N(数据栈),一个为OP(运算符栈)

2.将字符串从左向右遍历,把数据压入数据栈,把运算符压入运算符的栈

  关于运算符压栈的规则:⑴ 如果OP为空或者为待压栈操作符为左括号则直接将运算符压入栈

　　　　　　　　　　　⑵ 如果待压栈操作符的优先级大于栈顶操作符则直接入栈

　　　　　　　　　　　⑶ 如果栈顶操作符的优先级大于待压栈操作符,则将OP栈顶的操作符依次压入N知道遇到

　　　　　　　　　　　　 左括号或者OP为空则停止,此时压入该操作符到OP栈顶中

　　　　　　　　　　　⑷ 如果遇到右括号则将OP栈中的元素依次弹出压入N中直到遇到左括号为止，同时弹出左括号

                                         并且右括号不压入OP

　　　　　　　　　　　⑸ 最后将OP中的元素依次弹出并压入N中,将N弹出并逆序输出则是最终的逆波兰表达式

 

 

代码实现如下:

 

  1 #include <iostream>

  2 #include <stack>

  3 using namespace std;

  4 

  5 

  6 int operateprior(char a1)

  7 {

  8     int prior;

  9 

 10     switch(a1)

 11     {

 12     case '(':

 13         prior=0;

 14         break;

 15     case ')':

 16         prior=0;

 17         break;

 18     case '+':

 19         prior=1;

 20         break;

 21     case '-':

 22         prior=1;

 23         break;

 24     case '*':

 25         prior=2;

 26         break;

 27     case '/':

 28         prior=2;

 29         break;

 30     case '%':

 31         prior=2;

 32         break;

 33     }

 34     return prior;

 35 }

 36 

 37 

 38 char* NiBoLanFun(char* Str)

 39 {

 40     stack<char> N;

 41     stack<char> OP;

 42 

 43     while(*Str!='\0')

 44     {

 45         if(*Str>='0'&&*Str<='9')

 46         {

 47             N.push(*Str);

 48             Str++;

 49         }

 50         else

 51         {

 52             if(*Str=='('||OP.empty())

 53             {

 54                 OP.push(*Str++);

 55             }

 56             else

 57             {

 58                 if(*Str==')')

 59                 {

 60                     while(!OP.empty())

 61                     {

 62                         //cout<<"OP.top="<<OP.top()<<endl;

 63                         if(OP.top()!='(')

 64                         {        

 65                             N.push(OP.top());

 66                         }

 67                         OP.pop();

 68                         if(OP.top()=='(')

 69                         {

 70                             OP.pop();

 71                             break;

 72                         }

 73                     }

 74                     Str++;

 75                 }

 76                 else

 77                 {

 78                     while(!OP.empty()&&operateprior(*Str)<operateprior(OP.top()))

 79                     {

 80                         N.push(OP.top());

 81                         OP.pop();

 82                     }

 83                     OP.push(*Str++);

 84                 }

 85             }

 86         }

 87 

 88     

 89 

 90     }

 91 

 92     while(!OP.empty())

 93     {

 94         N.push(OP.top());

 95         OP.pop();

 96     }

 97 

 98     cout<<"The Trans string size="<<N.size()<<endl;

 99     char* TransStr;

100     TransStr=new char[N.size()+1];

101     memset(TransStr,'\0',N.size()+1);

102     int i=N.size()-1;

103     while(!N.empty())

104     {

105         TransStr[i]=N.top();

106         N.pop();

107         i--;

108     }

109     return TransStr;

110 }

111 

112 

113 

114 void main()

115 {

116     char str[50]={'\0'};

117     char *AfterStr;

118     cout<<"Please input the operate string: ";

119     cin>>str;

120     AfterStr=NiBoLanFun(str);

121     cout<<"The Trans String is: "<<AfterStr<<endl;

122     return;

123 }

 

运行截图:

 

其实逆波兰表达式的转换并不难,只是过程冗杂,条件判断较多。

OK，就到这里吧