前缀、中缀、后缀表达式以及简单计算器的C++实现

前缀表达式（波兰表达式）、中缀表达式、后缀表达式（逆波兰表达式）

介绍

　　三种表达式都是四则运算的表达方式,用以四则运算表达式求值，即数学表达式的求解。

前缀表达式

• 前缀表达式是一种没有括号的算术表达式，与中缀表达式不同的是，其将运算符写在前面，操作数写在后面。为纪念其发明者波兰数学家Jan Lukasiewicz，前缀表达式也称为“波兰式”。例如，- 1 + 2 3，它等价于1-(2+3)。

中缀表达式

• 中缀表达式就是一般的算数表达式，操作符以中缀形式出现在操作数之间。

后缀表达式

• 后缀表达式指的是不包含括号，运算符放在两个运算对象的后面，所有的计算按运算符出现的顺序，严格从左向右进行（不再考虑运算符的优先规则）。

中缀表达式转前缀表达式

　　例如：对于中缀表达式(3+4)×5-6，其前缀表达式为- × + 3 4 5 6。前后缀表达式与中缀之间的转换关系，不在此赘述，在Seraphjin的博客中，通过二叉树的方式，很好地解释了这一内容。

除了该博客中所说的二叉树法，还可以通过栈方法，来实现二者的转换，具体步骤如下：

• 初始化两个栈：运算符栈S1和储存中间结果的栈S2；
• 从右至左扫描中缀表达式；
• 遇到操作数时，将其压入S2；
• 遇到运算符时，比较其与S1栈顶运算符的优先级：
• 如果S1为空，或栈顶运算符为右括号“)”，则直接将此运算符入栈；
• 否则，若优先级比栈顶运算符的较高或相等，也将运算符压入S1；
• 否则，将S1栈顶的运算符弹出并压入到S2中，再与S1中新的栈顶运算符相比较；
• 遇到括号时：
• 如果是右括号“)”，则直接压入S1；
• 如果是左括号“(”，则依次弹出S1栈顶的运算符，并压入S2，直到遇到右括号为止，此时将这一对括号丢弃；
• 重复上述步骤，直到表达式的最左边；
• 将S1中剩余的运算符依次弹出并压入S2；
• 依次弹出S2中的元素并输出，结果即为中缀表达式对应的前缀表达式。

前缀表达式的计算机求解

　　利用计算器对前缀表达式求解其算数值时，采用从左到右扫描的方法，遇到操作数，则将其入栈，遇到操作符，则从栈中弹出两个操作数，由于前缀操作符位于数字之前，因此，第二个弹出的操作数为被操作数。然后对两个操作数根据操作符做相应的操作。

1. 从右至左扫描，将6、5、4、3压入堆栈
2. 遇到+运算符，因此弹出3和4（3为栈顶元素，4为次顶元素，注意与后缀表达式做比较），计算出3+4的值，得7，再将7入栈
3. 接下来是×运算符，因此弹出7和5，计算出7×5=35，将35入栈
4. 最后是-运算符，计算出35-6的值，即29，由此得出最终结果

中缀表达式转后缀表达式

　　表达式的转换，有二叉树法和栈方法，二叉树法不在此追述，详情见上文链接。

　　栈方法将中缀表达式转后缀表达式的方法如下所示：

• 初始化两个栈：运算符栈S1和储存中间结果的栈S2；
• 从左至右扫描中缀表达式；
• 遇到操作数时，将其压入S2；
• 遇到运算符时，比较其与S1栈顶运算符的优先级：
• 如果S1为空，或栈顶运算符为左括号“(”，则直接将此运算符入栈；
• 否则，若优先级比栈顶运算符的高，也将运算符压入S1（注意转换为前缀表达式时是优先级较高或相同，而这里则不包括相同的情况）；
• 否则，将S1栈顶的运算符弹出并压入到S2中，再与S1中新的栈顶运算符相比较；
• 遇到括号时：
• 如果是左括号“(”，则直接压入S1；
• 如果是右括号“)”，则依次弹出S1栈顶的运算符，并压入S2，直到遇到左括号为止，此时将这一对括号丢弃；
• 重复上述步骤，直到表达式的最右边；
• 将S1中剩余的运算符依次弹出并压入S2；
• 依次弹出S2中的元素并输出，结果的逆序即为中缀表达式对应的后缀表达式（转换为前缀表达式时不 用逆序）。

后缀表达式在算数逻辑运算中的作用，以及简单计算器的C++实现

　　由上述内容可知，利用前缀或者后缀表达式，可以很好的利用计算器，解决日常中缀表达式的求解，在此基础上，给出，无括号情况下，简单计算器的实现。

　　.h文件代码

 #ifndef _C_H_
 #define _C_H_
 #include<iostream>
 #include<string>
 #include<algorithm>
 #include<stdio.h>
 #include<map>
 #include<queue>
 #include<stack>
 #include<cstdio>
 #endif

　　.cpp
　　文件代码

 #include "C.h"

 using namespace std;

 struct node{
     double num;     //操作符
     char op;    //操作数
     bool flag;      //数符判定

 };

 string str;     //输入字符串
 stack<node> s;  //操作符栈
 queue<node> q;  //操作数队列
 map<char, int>op;   //操作符优先级

 void Change();      //中缀表达式转后缀表达式
 double Cal();       //计算表达式的值

 int main(){
     op['*'] = op['/'] = ;
     op['+'] = op['-'] = ;
     while(getline(cin, str), str!=""){
         for(string::iterator it = str.end();it!=str.begin();it--){
             if(*it == ' '){
                 str.erase(it);  //擦除表达式中的空格
             }
         }
         while(!s.empty()){
             s.pop();    //初始化栈
         }
         Change();   //中缀表达式转换为后缀表达式
         double rs = Cal();
         printf("%.2f\n", rs);
     }

     return ;
 }

 //中缀表达式转后缀表达式
 void Change(){
     node temp;
     for(unsigned int i=;i<str.length();){
         if(str[i]>=''&&str[i]<=''){   //为操作数
             temp.flag = true;
             temp.num = str[i++] - '';    //记录该操作数的最高位
             while(i<str.length() && str[i]>='' && str[i]<=''){//记录该操作数的后续几位
                 temp.num = temp.num *  + (str[i] - '');  //更新操作数
                 i++;
             }
             q.push(temp);
         }
         else{//为操作符
             temp.flag = false;
             while(!s.empty()&&op[str[i]]<=op[s.top().op]){
                 q.push(s.top());
                 s.pop();
             }
             temp.op = str[i];
             s.push(temp);
             i++;
         }
     }
     while(!s.empty()){//操作符栈非空，则直接入后缀表达式队列
         q.push(s.top());
         s.pop();
     }
 }

 double Cal(){
     double temp1, temp2;
     node cur, temp;
     while(!q.empty()){
         cur = q.front();
         q.pop();
         if(cur.flag){
             s.push(cur);
         }
         else{
             temp.flag = true;   //暂存计算数据
             temp2 = s.top().num;    //取第2操作数
             s.pop();
             temp1 = s.top().num;    //取第1操作数
             s.pop();
             if(cur.op=='+'){
                 temp.num = temp1 + temp2;
             }
             else if(cur.op=='-'){
                 temp.num = temp1 - temp2;   //后缀表达式，操作符在原表达式中位于操作数2和操作数1之间
             }
             else if(cur.op=='*'){
                 temp.num = temp1 * temp2;
             }
             else{
                 temp.num = temp1 / temp2;
             }
             s.push(temp);
         }
     }
     return s.top().num;
 }

　　有括号输入表达式下，计算器的实现：

 #include "C.h"

 using namespace std;

 struct node{
     double num;     //操作数
     char op;    //操作符
     bool flag;      //数符定界，若真则为操作数，反之为操作符
 };

 string str;     //输入字符串
 map<char, int> m;   //操作符优先级
 queue<node> q;      //操作数队列
 stack<node> s;      //操作符栈

 void Change(){
     /*
     *中缀表达式转后缀表达式
     */
     node temp;
     for(unsigned int i=;i<str.length();){
         if(str[i]>=''&&str[i]<=''){//字符为操作数
             temp.flag = true;
             temp.num = str[i++] - '';    //记录该操作数
             while(i<str.length()&&str[i]>=''&&str[i]<=''){  //记录该操作数的后续几位
                 temp.num = temp.num *  + (str[i] - '');
                 i++;
             }
             q.push(temp);
         }
         else if(str[i]=='+'||str[i]=='-'||str[i]=='/'||str[i]=='*'||str[i]=='('){
             temp.flag = false;
             if(!s.empty()&&s.top().op=='('){//判断操作符栈栈顶是否为左括号
                 temp.op = str[i];
                 s.push(temp);
             }
             else{
                 while(!s.empty()&&m[str[i]]<=m[s.top().op]){
                     q.push(s.top());
                     s.pop();
                 }
                 temp.op = str[i];
                 s.push(temp);
             }
             i++;
         }
         else{
             while(!s.empty()&&s.top().op!='('){
                 q.push(s.top());
                 s.pop();
             }
             s.pop();
             i++;
         }
     }
     while(!s.empty()){
         q.push(s.top());
         s.pop();
     }
 }

 double Cal(){
     node cur, temp;
     double temp1, temp2;
     while(!q.empty()){
         cur = q.front();
         q.pop();
         if(cur.flag){
             s.push(cur);
         }
         else{
             temp2 = s.top().num;
             s.pop();
             temp1 = s.top().num;
             s.pop();
             if(cur.op=='*'){
                 temp.num = temp1 * temp2;
             }
             else if(cur.op=='+'){
                 temp.num = temp1 + temp2;
             }
             else if(cur.op=='-'){
                 temp.num = temp1 - temp2;
             }
             else{
                 temp.num = temp1 / temp2;
             }
             s.push(temp);
         }
     }
     return s.top().num;
 }

 int main(){
     m['('] = m[')'] = ;
     m['*'] = m['/'] = ;
     m['+'] = m['-'] = ;

     while(getline(cin, str), str!=""){
         for(string::iterator it=str.end();it!=str.begin();it--){
             if(*it==' '){
                 str.erase(it);
             }
         }
         cout<<str<<endl;
         while(!s.empty()){
             s.pop();
         }
         Change();
         printf("%.2f\n", Cal());
     }

     return ;
 }