前缀表达式、中缀表达式、后缀表达式的相互转换

1.中缀表达式转前缀表达式

转换规则：

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

代码实现：

//中缀表达式转换为前缀表达式 
#include<iostream>
#include<stack>
#include<unordered_map>
using namespace std;
unordered_map<char,int>mp;
//s1为运算符栈
//s2为中间结果栈
stack<char>s1,s2;
//设置初始优先级
void init(){
    mp['+']=mp['-']=1;
    mp['*']=mp['/']=2;
}
int main(){
    init();
    string s;
    //读取字符串 
    //中缀表达式：(3+4)*5-6
	//前缀表达式：-*+3456 
    cin>>s;
    for(int i=s.size()-1;i>=0;i--){
        if(s[i]>='0'&&s[i]<='9')s2.push(s[i]);//如果是数字，直接压入s2 
        else if(s[i]=='+'||s[i]=='-'||s[i]=='*'||s[i]=='/'){//如果是运算符 
            while(true){
                if(s1.empty()||s1.top()==')'){//s1为空 ，或者栈顶为)
                    s1.push(s[i]);
                    break;
                }else if(mp[s[i]]>=mp[s1.top()]){//当前运算符优先级大于等于s1栈顶运算符优先级 
                    s1.push(s[i]);
                    break;
                }else{//小于等于 
                    char t=s1.top();
                    s1.pop();
                    s2.push(t);
                }
            }
        }else{
            if(s[i]==')')s1.push(s[i]);//直接读入 
            else{
                while(s1.top()!=')'){
                    char t=s1.top();
                    s2.push(t);
                    s1.pop();
                }
                s1.pop();
            }
        }
    }
    //将剩余的运算符压入到操作数栈 
    while(!s1.empty()){
        char t=s1.top();
        s1.pop();
        s2.push(t);
    }
    //输出前缀表达式
    while(!s2.empty()){
        cout<<s2.top();
        s2.pop();
    }
    return 0;
}

2.中缀表达式转换为后缀表达式

1.初始化两个栈：运算符栈s1和储存中间结果的栈s2；
2.从左至右扫描中缀表达式；
3.遇到操作数时，将其压s2；
4.遇到运算符时，比较其与s1栈顶运算符的优先级：
  1.如果s1为空，或栈顶运算符为左括号“(”，则直接将此运算符入栈；
  2.否则，若优先级比栈顶运算符的高，也将运算符压入s1
  3.否则，将s1栈顶的运算符弹出并压入到s2中，再次转到(4-1)与s1中新的栈顶运算符相比较；
5.遇到括号时：
  1.如果是左括号“(”，则直接压入s1；
  2.如果是右括号“)”，则依次弹出s1栈顶的运算符，并压入s2，直到遇到左括号为止，此时将这一对括号丢弃；
6.重复步骤2至5，直到表达式的最右边；
7.将s1中剩余的运算符依次弹出并压入s2；
8.依次弹出s2中的元素并输出，结果的逆序即为中缀表达式对应的后缀表达式

代码实现：

#include<iostream>
#include<stack>
#include<unordered_map>
using namespace std;
unordered_map<char,int>mp;
//s1为运算符栈
//s2为中间结果栈
stack<char>s1,s2;
//设置初始优先级
void init(){
    mp['+']=mp['-']=1;
    mp['*']=mp['/']=2;
}
int main(){
    init();
    string s;
    //读取字符串 
    //中缀表达式：(3+4)*5-6
	//后缀表达式：34+5*6-
    cin>>s;
    for(int i=0;i<s.size();i++){
        if(s[i]>='0'&&s[i]<='9')s2.push(s[i]);//如果是数字，直接压入s2 
        else if(s[i]=='+'||s[i]=='-'||s[i]=='*'||s[i]=='/'){//如果是运算符 
            while(true){
                if(s1.empty()||s1.top()=='('){//s1为空 ，或者栈顶为(
                    s1.push(s[i]);
                    break;
                }else if(mp[s[i]]>mp[s1.top()]){//当前运算符优先级大于s1栈顶运算符优先级 
                    s1.push(s[i]);
                    break;
                }else{//小于等于 
                    char t=s1.top();
                    s1.pop();
                    s2.push(t);
                }
            }
        }else{
            if(s[i]=='(')s1.push(s[i]);//直接读入 
            else{
                while(s1.top()!='('){
                    char t=s1.top();
                    s2.push(t);
                    s1.pop();
                }
                s1.pop();
            }
        }
    }
    //将剩余的运算符压入到操作数栈 
    while(!s1.empty()){
        char t=s1.top();
        s1.pop();
        s2.push(t);
    }
    //由于要从栈底往栈顶输出，故要进行一次反转 
    while(!s2.empty()){
        char t=s2.top();
        s2.pop();
        s1.push(t);
    }
    //输出后缀表达式
    while(!s1.empty()){
        cout<<s1.top();
        s1.pop();
    }
    return 0;
}

3.后缀表达式求值

代码实现：

#include <iostream>
#include <stack>
#include <string>
#include <unordered_map>
using namespace std;
 
stack<int> num;
stack<char> op;
 
//优先级表
unordered_map<char, int> h{ {'+', 1}, {'-', 1}, {'*',2}, {'/', 2} };
 
 
void eval()//求值
{
    int a = num.top();//第二个操作数
    num.pop();
 
    int b = num.top();//第一个操作数
    num.pop();
 
    char p = op.top();//运算符
    op.pop();
 
    int r = 0;//结果 
 
    //计算结果
    if (p == '+') r = b + a;
    if (p == '-') r = b - a;
    if (p == '*') r = b * a;
    if (p == '/') r = b / a;
 
    num.push(r);//结果入栈
}
 
int main()
{
    string s;//读入表达式
    cin >> s;
    for (int i = 0; i < s.size(); i++)
    {
        if (isdigit(s[i]))//数字入栈
        {
            int x = 0, j = i;//计算数字
            while (j < s.size() && isdigit(s[j]))
            {
                x = x * 10 + s[j] - '0';
                j++;
            }
            num.push(x);//数字入栈
            i = j - 1;
        }
        //左括号无优先级，直接入栈
        else if (s[i] == '(')//左括号入栈
        {
            op.push(s[i]);
        }
        //括号特殊，遇到左括号直接入栈，遇到右括号计算括号里面的
        else if (s[i] == ')')//右括号
        {
            while(op.top() != '(')//一直计算到左括号
                eval();
            op.pop();//左括号出栈
        }
        else
        {
            while (op.size() && h[op.top()] >= h[s[i]])//待入栈运算符优先级低，则先计算
                eval();
            op.push(s[i]);//操作符入栈
        }
    }
    while (op.size()) eval();//剩余的进行计算
    cout << num.top() << endl;//输出结果
    return 0;
}