中綴表達式轉換成波蘭表達式和逆波蘭表達式【代碼】

由於兩者方法相近，所以直接放一起方便互相對比

方法參考相關大神的講解，特此說明，代碼為本人所寫，轉載請聲明！

本人測試了五組數據，結果已附圖如下，暫時沒發現問題，如有問題，多謝指出。

 

以下摘自@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;
}