中缀表达式 转 (逆)波兰表达式

由于两者方法相近，所以直接放一起方便互相对比

方法参考相关大神的讲解，特此说明，代码为本人所写，转载请声明！

本人测试了五组数据，结果已附图如下，暂时没发现问题，如有问题，多谢指出。

以下摘自@wanghetao http://www.cnblogs.com/wanghetao/archive/2012/04/23/2466580.html

一、 将中缀表达式转换成后缀表达式算法：
　　1、从左至右扫描一中缀表达式。
　　2、若读取的是操作数，则判断该操作数的类型，并将该操作数存入操作数堆栈
　　3、若读取的是运算符
　　　　(1) 该运算符为左括号"("，则直接存入运算符堆栈。
　　　　(2) 该运算符为右括号")"，则输出运算符堆栈中的运算符到操作数堆栈，直到遇到左括号为止。
　　　　(3) 该运算符为非括号运算符：
　　　　　　(a) 若运算符堆栈栈顶的运算符为括号（只可能是左括号），则直接存入运算符堆栈。
　　　　　　(b) 若比运算符堆栈栈顶的运算符优先级高，则直接存入运算符堆栈。
　　　　　　(c) 若比运算符堆栈栈顶的运算符优先级低或相等，则不断输出栈顶运算符到操作数堆栈，直到栈顶没有运算符的优先级大于或者等于当前预算符（即栈顶存在运算符的话，优先级一定是小于当前运算符），最后将当前运算符压入运算符堆栈。
　　4、当表达式读取完成后运算符堆栈中尚有运算符时，则依序取出运算符到操作数堆栈，直到运算符堆栈为空。

二、逆波兰表达式求值算法：
　　1、从左到右依次扫描语法单元的项目。
　　2、如果扫描的项目是操作数，则将其压入操作数堆栈，并扫描下一个项目。
　　3、如果扫描的项目是一个二元运算符，则对栈的顶上两个操作数执行该运算。
　　4、如果扫描的项目是一个一元运算符，则对栈的最顶上操作数执行该运算。
　　5、将运算结果重新压入堆栈。
　　6、重复步骤2-5，堆栈中即为结果值。

-------------------------------------------------分界线-------------------------------------------------

以下摘自@unixfy http://www.cnblogs.com/unixfy/p/3344550.html

一、 将中缀表达式转换成前缀表达式算法：
　　1、首先设定一个操作符栈，从右到左顺序扫描整个中缀表达式，如果是操作数，则直接归入前缀表达式；
　　2、如果是操作符，则检测器是否是右括号，如果是右括号，则直接将其入栈；
　　3、如果是左括号，则将栈中的操作符依次弹栈，归入前缀表达式，直至遇到右括号，将右括号弹栈，处理结束；
　　4、如果是其他操作符，则检测栈顶操作符的优先级与当前操作符的优先级关系，
　　5、如果栈顶操作符优先级大于当前操作符的优先级，则弹栈，并归入前缀表达式，直至栈顶操作符优先级小于等于当前操作符优先级，这时将当前操作符压栈。
　　6、当扫描完毕整个中缀表达式后，检测操作符栈是否为空，如果不为空，则依次将栈中操作符弹栈，归入前缀表达式。最后，将前缀表达式翻转，得到中缀表达式对应的前缀表达式。

二、波兰表达式求值算法：
　　1、从右到左依次扫描语法单元的项目。
　　2、如果扫描的项目是操作数，则将其压入操作数堆栈，并扫描下一个项目。
　　3、如果扫描的项目是一个二元运算符，则对栈的顶上两个操作数执行该运算。
　　4、如果扫描的项目是一个一元运算符，则对栈的最顶上操作数执行该运算。
　　5、将运算结果重新压入堆栈。
　　6、重复步骤2-5，堆栈中即为结果值。

 

 

	中缀转前缀	中缀转后缀
栈	操作符栈	操作符栈
扫描顺序	从右到左	从左到右
遇到操作数	直接归入	直接归入
遇到右括号	直接入栈	将栈中操作符依次弹栈，归入，直至遇到左括号，将左括号弹栈，处理完毕
遇到左括号	将栈中操作符依次弹栈，归入，直至遇到右括号，将右括号弹栈，处理完毕	直接入栈
遇到其他操作符	检测栈顶操作符优先级与当前操作符优先级关系，如果栈顶大于当前，则出栈，归入，直至栈顶小于等于当前，并将当前操作符入栈	检测栈顶与当前优先级关系，如果栈顶大于等于当前则出栈，归入，直至栈顶小于当前，并将当前操作符入栈
操作符栈中的优先级	从栈底到栈顶操作优先级：非递减。即：栈顶可以大于或等于下面的	从栈底到栈顶优先级：递增。即：栈顶必须大于下面的
是否翻转	翻转	无需翻转

运行结果如下：

-------------------------------------------------代码区-------------------------------------------------

#include <iostream>
#include<stdlib.h>

using namespace std;

#define STACK_INIT_SIZE 100
#define STACKINCREASE 10

//为了简化问题，数字和符号统一当成字符看待
//由此导致的后果是接下来所有的运算过程中不允许出现小数,而且由于是利用ASCII表来储存整数,
//所以每个运算数都只能取0-9的一位数,暂时没有考虑负数问题.
//暂时没有考虑非法输入

typedef struct
{
    char *base;
    char *top;
    int stacksize;
}SqStack;


int InitStack(SqStack &S)
{
    S.base=(char *)malloc(STACK_INIT_SIZE*sizeof(char));
    if(!S.base)
    {
        cout<<"分配空间失败!";
        exit(-1);
    }
    S.top=S.base;
    S.stacksize=STACK_INIT_SIZE;
    return 0;
}


int Push(SqStack &S,char e)
{
    if((S.top-S.base)>=STACK_INIT_SIZE)
    {
        S.base=(char *)realloc(S.base,(STACK_INIT_SIZE+STACKINCREASE)*sizeof(char));
        if(!S.base)
        {
           cout<<"分配空间失败!";
            exit(-1);
        }
        S.top=S.base+STACK_INIT_SIZE;
        S.stacksize=STACK_INIT_SIZE+STACKINCREASE;
    }
    *(S.top)=e;//结构体
    S.top++;
    return 0;
}


int Pop(SqStack &S,char &e)
{
    if(S.base==S.top)
    {
        cout<<"栈为空!";
        exit(0);
    }
    S.top--;
    e=*(S.top);
    return 0;
}

int GetTop(SqStack &S,char &e)
{
    if(S.base==S.top)
    {
        cout<<"栈为空!";
        return 0;
    }
    else
    {
        e=*(S.top-1);
        return 1;
    }
}


int EmptyStack(SqStack &S)
{
    if(S.base==S.top) return 1;//stack is empty!
    else return 0;//stack is not empty!
}


int Precede(char a,char b)//a为符号栈栈顶元素,b为待插入的元素
{
    int i;//i=1入栈,i=0弹出操作符以及操作数进行计算
    if((a=='+'||a=='-')&&(b=='*'||b=='/')) i=1;
    if((a=='+'||a=='-')&&(b=='+'||b=='-')) i=0;
    if((a=='*'||a=='/')&&(b=='*'||b=='/')) i=0;
    if((a=='*'||a=='/')&&(b=='+'||b=='-')) i=0;
    if(a=='('||a==')') i=1;
    return i;
}


int Nifix_To_Suffix(char *p)
{
    char a,c,e;
    int i;
    SqStack S;//S为操作符栈，遇到操作数直接输出，所以不需要操作数栈
    InitStack(S);
    c=*p++;
    cout<<"转换后的后缀表达式为："<<endl;
    while(c!='#')
    {
         if(c>=48&&c<=57) cout<<c;//输入为数字,直接输出
         if(c=='(') Push(S,c); //输入为左括号
         if(c==')')//输入为右括号
         {
             if(!EmptyStack(S)) GetTop(S,e);
             while(e!='(')
             {
                 Pop(S,a);cout<<a;
                 if(!EmptyStack(S)) GetTop(S,e);//直到遇到左括号
                 if(e=='(') Pop(S,e);
             }
         }
         if(c=='+'||c=='-'||c=='*'||c=='/')
         {
             if(EmptyStack(S))  Push(S,c);
             else
             {
                 GetTop(S,e);
                 i=Precede(e,c);
                 if(i==1) Push(S,c);
                 if(i==0)
                 {
                     while(!i)
                     {
                         Pop(S,a); cout<<a;
                         if(!EmptyStack(S)) {GetTop(S,e); i=Precede(e,c);}
                         else break;
                     }
                     Push(S,c);
                 }
             }
         }
         c=*p++;
    }
    if(!EmptyStack(S))
    {
        while(!EmptyStack(S))
        {
             Pop(S,a);
             cout<<a;
        }
    }
    cout<<endl;
    return 0;
}


int Nifix_To_Prefix (char *p)
{
    char a,c,d,e;
    int i;
    SqStack S,S1,S2;//S为操作符栈,S1为存储倒置后元素的栈,S2存储的是逆序的前缀表达式，最后依次弹出以实现最终的前缀表达式
    InitStack(S);InitStack(S1);InitStack(S2);
    //由于要从右到左依次读取表达式中的各个元素，所以这里利用一个栈S1将它们倒置
    d='#';
    Push(S1,d);
    while(*p!='#')
    {
        d=*p;
        Push(S1,d);
        p++;
        if(*p=='#') break;
    }
    Pop(S1,c);
    cout<<"转换后的前缀表达式为："<<endl;
    while(c!='#')
    {
         if(c>=48&&c<=57) Push(S2,c);//输入为数字,直接输出
         if(c==')') Push(S,c); //输入为右括号
         if(c=='(')//输入为左括号
         {
             if(!EmptyStack(S)) GetTop(S,e);
             while(e!=')')
             {
                 Pop(S,a);Push(S2,a);
                 if(!EmptyStack(S)) GetTop(S,e);//直到遇到左括号
                 if(e==')') Pop(S,e);
             }
         }
         if(c=='+'||c=='-'||c=='*'||c=='/')
         {
             if(EmptyStack(S))  Push(S,c);
             else
             {
                 GetTop(S,e);
                 i=Precede(e,c);
                 if(i==1) Push(S,c);
                 if(i==0)
                 {
                     while(!i)
                     {
                         Pop(S,a); Push(S2,a);
                         if(!EmptyStack(S)) {GetTop(S,e); i=Precede(e,c);}
                         else break;
                     }
                     Push(S,c);
                 }
             }
         }
         Pop(S1,c);
    }
    if(!EmptyStack(S))
    {
        while(!EmptyStack(S))
        {
             Pop(S,a);
             Push(S2,a);
        }
    }
    while(!EmptyStack(S2))
    {
        Pop(S2,a);
        cout<<a;
    }
    cout<<endl;
    return 0;
}




int main()
{
    //数据测试
    char *p1="3+2*5#";
    char *p2="2*5+3#";
    char *p3="2+3*(5-1)#";
    char *p4="((3+5*2)+2)/5+6/3*2+3#";
    char *p5="2+(3+4)*5#";
    cout<<"3+2*5"<<endl; Nifix_To_Suffix(p1); Nifix_To_Prefix(p1);cout<<endl<<endl;
    cout<<"2*5+3"<<endl; Nifix_To_Suffix(p2); Nifix_To_Prefix(p2);cout<<endl<<endl;
    cout<<"2+3*(5-1)"<<endl; Nifix_To_Suffix(p3); Nifix_To_Prefix(p3);cout<<endl<<endl;
    cout<<"((3+5*2)+2)/5+6/3*2+3"<<endl; Nifix_To_Suffix(p4); Nifix_To_Prefix(p4);cout<<endl<<endl;
    cout<<"2+(3+4)*5"<<endl; Nifix_To_Suffix(p5); Nifix_To_Prefix(p5);cout<<endl<<endl;
    return 0;
}