前缀表达式（波兰表达式）、中缀表达式、后缀表达式（逆波兰表达式）
介绍
三种表达式都是四则运算的表达方式,用以四则运算表达式求值，即数学表达式的求解。
前缀表达式
-
前缀表达式是一种没有括号的算术表达式，与中缀表达式不同的是，其将运算符写在前面，操作数写在后面。为纪念其发明者波兰数学家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中的元素并输出，结果即为中缀表达式对应的前缀表达式。
前缀表达式的计算机求解
利用计算器对前缀表达式求解其算数值时，采用从左到右扫描的方法，遇到操作数，则将其入栈，遇到操作符，则从栈中弹出两个操作数，由于前缀操作符位于数字之前，因此，第二个弹出的操作数为被操作数。然后对两个操作数根据操作符做相应的操作。
- 从右至左扫描，将6、5、4、3压入堆栈
- 遇到+运算符，因此弹出3和4（3为栈顶元素，4为次顶元素，注意与后缀表达式做比较），计算出3+4的值，得7，再将7入栈
- 接下来是×运算符，因此弹出7和5，计算出7×5=35，将35入栈
- 最后是-运算符，计算出35-6的值，即29，由此得出最终结果
中缀表达式转后缀表达式
表达式的转换，有二叉树法和栈方法，二叉树法不在此追述，详情见上文链接。
栈方法将中缀表达式转后缀表达式的方法如下所示：
- 初始化两个栈：运算符栈S1和储存中间结果的栈S2；
- 从左至右扫描中缀表达式；
- 遇到操作数时，将其压入S2；
- 遇到运算符时，比较其与S1栈顶运算符的优先级：
- 如果S1为空，或栈顶运算符为左括号“(”，则直接将此运算符入栈；
- 否则，若优先级比栈顶运算符的高，也将运算符压入S1（注意转换为前缀表达式时是优先级较高或相同，而这里则不包括相同的情况）；
- 否则，将S1栈顶的运算符弹出并压入到S2中，再与S1中新的栈顶运算符相比较；
- 遇到括号时：
- 如果是左括号“(”，则直接压入S1；
- 如果是右括号“)”，则依次弹出S1栈顶的运算符，并压入S2，直到遇到左括号为止，此时将这一对括号丢弃；
- 重复上述步骤，直到表达式的最右边；
- 将S1中剩余的运算符依次弹出并压入S2；
- 依次弹出S2中的元素并输出，结果的逆序即为中缀表达式对应的后缀表达式（转换为前缀表达式时不 用逆序）。
后缀表达式在算数逻辑运算中的作用，以及简单计算器的C++实现
由上述内容可知，利用前缀或者后缀表达式，可以很好的利用计算器，解决日常中缀表达式的求解，在此基础上，给出，无括号情况下，简单计算器的实现。
.h文件代码
1 #ifndef _C_H_ 2 #define _C_H_ 3 #include<iostream> 4 #include<string> 5 #include<algorithm> 6 #include<stdio.h> 7 #include<map> 8 #include<queue> 9 #include<stack> 10 #include<cstdio> 11 #endif
.cpp
文件代码
1 #include "C.h"
2
3 using namespace std;
4
5 struct node{
6 double num; //操作符
7 char op; //操作数
8 bool flag; //数符判定
9
10 };
11
12 string str; //输入字符串
13 stack<node> s; //操作符栈
14 queue<node> q; //操作数队列
15 map<char, int>op; //操作符优先级
16
17 void Change(); //中缀表达式转后缀表达式
18 double Cal(); //计算表达式的值
19
20 int main(){
21 op['*'] = op['/'] = 2;
22 op['+'] = op['-'] = 1;
23 while(getline(cin, str), str!="0"){
24 for(string::iterator it = str.end();it!=str.begin();it--){
25 if(*it == ' '){
26 str.erase(it); //擦除表达式中的空格
27 }
28 }
29 while(!s.empty()){
30 s.pop(); //初始化栈
31 }
32 Change(); //中缀表达式转换为后缀表达式
33 double rs = Cal();
34 printf("%.2f\n", rs);
35 }
36
37 return 0;
38 }
39
40 //中缀表达式转后缀表达式
41 void Change(){
42 node temp;
43 for(unsigned int i=0;i<str.length();){
44 if(str[i]>='0'&&str[i]<='9'){ //为操作数
45 temp.flag = true;
46 temp.num = str[i++] - '0'; //记录该操作数的最高位
47 while(i<str.length() && str[i]>='0' && str[i]<='9'){//记录该操作数的后续几位
48 temp.num = temp.num * 10 + (str[i] - '0'); //更新操作数
49 i++;
50 }
51 q.push(temp);
52 }
53 else{//为操作符
54 temp.flag = false;
55 while(!s.empty()&&op[str[i]]<=op[s.top().op]){
56 q.push(s.top());
57 s.pop();
58 }
59 temp.op = str[i];
60 s.push(temp);
61 i++;
62 }
63 }
64 while(!s.empty()){//操作符栈非空，则直接入后缀表达式队列
65 q.push(s.top());
66 s.pop();
67 }
68 }
69
70 double Cal(){
71 double temp1, temp2;
72 node cur, temp;
73 while(!q.empty()){
74 cur = q.front();
75 q.pop();
76 if(cur.flag){
77 s.push(cur);
78 }
79 else{
80 temp.flag = true; //暂存计算数据
81 temp2 = s.top().num; //取第2操作数
82 s.pop();
83 temp1 = s.top().num; //取第1操作数
84 s.pop();
85 if(cur.op=='+'){
86 temp.num = temp1 + temp2;
87 }
88 else if(cur.op=='-'){
89 temp.num = temp1 - temp2; //后缀表达式，操作符在原表达式中位于操作数2和操作数1之间
90 }
91 else if(cur.op=='*'){
92 temp.num = temp1 * temp2;
93 }
94 else{
95 temp.num = temp1 / temp2;
96 }
97 s.push(temp);
98 }
99 }
100 return s.top().num;
101 }
有括号输入表达式下，计算器的实现：
1 #include "C.h"
2
3 using namespace std;
4
5 struct node{
6 double num; //操作数
7 char op; //操作符
8 bool flag; //数符定界，若真则为操作数，反之为操作符
9 };
10
11 string str; //输入字符串
12 map<char, int> m; //操作符优先级
13 queue<node> q; //操作数队列
14 stack<node> s; //操作符栈
15
16
17 void Change(){
18 /*
19 *中缀表达式转后缀表达式
20 */
21 node temp;
22 for(unsigned int i=0;i<str.length();){
23 if(str[i]>='0'&&str[i]<='9'){//字符为操作数
24 temp.flag = true;
25 temp.num = str[i++] - '0'; //记录该操作数
26 while(i<str.length()&&str[i]>='0'&&str[i]<='9'){ //记录该操作数的后续几位
27 temp.num = temp.num * 10 + (str[i] - '0');
28 i++;
29 }
30 q.push(temp);
31 }
32 else if(str[i]=='+'||str[i]=='-'||str[i]=='/'||str[i]=='*'||str[i]=='('){
33 temp.flag = false;
34 if(!s.empty()&&s.top().op=='('){//判断操作符栈栈顶是否为左括号
35 temp.op = str[i];
36 s.push(temp);
37 }
38 else{
39 while(!s.empty()&&m[str[i]]<=m[s.top().op]){
40 q.push(s.top());
41 s.pop();
42 }
43 temp.op = str[i];
44 s.push(temp);
45 }
46 i++;
47 }
48 else{
49 while(!s.empty()&&s.top().op!='('){
50 q.push(s.top());
51 s.pop();
52 }
53 s.pop();
54 i++;
55 }
56 }
57 while(!s.empty()){
58 q.push(s.top());
59 s.pop();
60 }
61 }
62
63 double Cal(){
64 node cur, temp;
65 double temp1, temp2;
66 while(!q.empty()){
67 cur = q.front();
68 q.pop();
69 if(cur.flag){
70 s.push(cur);
71 }
72 else{
73 temp2 = s.top().num;
74 s.pop();
75 temp1 = s.top().num;
76 s.pop();
77 if(cur.op=='*'){
78 temp.num = temp1 * temp2;
79 }
80 else if(cur.op=='+'){
81 temp.num = temp1 + temp2;
82 }
83 else if(cur.op=='-'){
84 temp.num = temp1 - temp2;
85 }
86 else{
87 temp.num = temp1 / temp2;
88 }
89 s.push(temp);
90 }
91 }
92 return s.top().num;
93 }
94
95 int main(){
96 m['('] = m[')'] = 3;
97 m['*'] = m['/'] = 2;
98 m['+'] = m['-'] = 1;
99
100 while(getline(cin, str), str!="0"){
101 for(string::iterator it=str.end();it!=str.begin();it--){
102 if(*it==' '){
103 str.erase(it);
104 }
105 }
106 cout<<str<<endl;
107 while(!s.empty()){
108 s.pop();
109 }
110 Change();
111 printf("%.2f\n", Cal());
112 }
113
114 return 0;
115 }
来源：https://www.cnblogs.com/sgatbl/p/9413106.html