根據表達式序列（前綴、中綴、后綴）構建表達式樹

如果輸入序列是表達式（前綴表達式、中綴表達式、后綴表達式，中綴表達式要求帶括號有幾個運算符就帶幾個）則構建出來的樹為表達式樹，對該樹前、中、后序遍歷得到對應序的表達式。

不過，中綴表達式帶括號，而表達式樹不帶括號，故中序遍歷表達式樹時需要加適當的括號才能得到正確的中綴表達式。

1、表達式樹的構建與遍歷

0、工具函數（鏈表節點定義、讀取下一個字符、判斷字符是否操作數）：

typedef struct node
{
    char data;
    struct node * lchild;
    struct node * rchild;
}BTNode,*BTREE;


char nextToken(char infix[])//括號、操作數、操作符等 都為一個字符 
{
    static int pos=0;
    while(infix[pos]!='\0' && infix[pos]==' '){pos++;}//跳過空格 
    return infix[pos++];
}
int isOpNum(char ch)//是否是操作數 
{
    if(ch=='#' || ch=='(' || ch==')' || ch=='+' || ch=='-' || ch=='*' || ch=='/' || ch==' ' || ch=='|' )
    {
        return 0;
    }
    return 1;
}

1、輸入前綴表達式構建表達式樹（遞歸）：

void createPrefix_recursive(char prefix[],BTREE &T)
{//遞歸方式_由前綴表達式構建表達式樹 
    char x=nextToken(prefix);
    
    T=(BTREE)malloc(sizeof(BTNode));
    T->data=x;
    T->lchild=NULL;
    T->rchild=NULL;
    
    if(!isOpNum(x))//是操作符。前綴表達式的最后一個字符一定是操作數，所以下面的遞歸會停止。 
    { 
        createPrefix_recursive(prefix,T->lchild);
        createPrefix_recursive(prefix,T->rchild);
    }
}

2、輸入中綴表達式構建表達式樹（遞歸）：

（要求輸入的中綴表達式帶括號，有n個運算符就有n個括號，為什么？因為加括號就是為了給運算符定優先級。進一步的，若給不帶括號的中綴表達式加括號有幾種？卡特蘭數種，因為n個運算符入棧有卡特蘭數種出棧順序，相關題：LeetCode241）

void createInfix_recursive(char infix[],BTREE &T)
{//遞歸方式_由中綴表達式構建表達式樹，要求輸入的中綴表達式加括號，有幾個操作數就幾個括號 。如果輸入的前、中、后綴表達式都帶括號，則很容易由此法改造得到構建表達式樹的算法。 
    char x=nextToken(infix);
    
    T=(BTREE)malloc(sizeof(BTNode));
    T->lchild=NULL;
    T->rchild=NULL;
    
    if(x=='(')
    {//處理括號里的表達式 
        createInfix_recursive(infix,T->lchild);//表達式的左操作數 
        
        x=nextToken(infix);//表達式的操作符 
        T->data=x;
        
        createInfix_recursive(infix,T->rchild);//表達式的右操作數 
        nextToken(infix);//右括號 
    }
    else
    {
        T->data=x;
    }
}

3、輸入后綴表達式構建表達式樹（非遞歸）

#define M 100
void createPostfix_nonrecursive(char postfix[],BTREE &T)
{//非遞歸方式_由后綴表達式構建表達式樹 
    BTREE stack[M],p;
    int top=-1;
    char x;
    while(1)
    {
        x=nextToken(postfix);
        if(x=='\0') return;
        
        p=(BTREE)malloc(sizeof(BTNode)) ;
        p->data=x;
        p->lchild=NULL;
        p->rchild=NULL;
        
        if(isOpNum(x))
        {//操作數 
            stack[++top]=p;
        }
        else
        {//操作符 
            p->lchild=stack[top-1];
            p->rchild=stack[top];
            stack[top-1]=p;
            top--;
            T=p;
        }
    }
    T=stack[0];
}

4、表達式樹遍歷（遞歸，前綴、中綴、后綴）：（中綴遍歷在遍歷時需要加括號才能得到正確結果，方法為訪問到內部節點時加左右括號。）

void searchPrefix(BTREE T)
{
    if(T!=NULL)
    {//·ÃÎʵ½ÄÚ²¿½Úµãʱ×óÓÒ¼ÓÀ¨ºÅ 
//        if(T->lchild!=NULL && T->rchild!=NULL){   printf("(");   }

        printf("%c",T->data);
        searchPrefix(T->lchild);
        searchPrefix(T->rchild);
        
//        if(T->lchild!=NULL && T->rchild!=NULL){  printf(")");  }
    }
}
void searchInfix(BTREE T)
{
    if(T!=NULL)
    {//ÖÐÐò±éÀú±í´ïʽÊ÷ÐèÒªÌí¼ÓÀ¨ºÅÐÅÏ¢£¬ÒÔ±£Ö¤ÔËËãÓÅÏȼ¶£º·ÃÎʵ½ÄÚ²¿½Úµãʱ×óÓÒ¼ÓÀ¨ºÅ 
        if(T->lchild!=NULL && T->rchild!=NULL){   printf("(");   }
        
        searchInfix(T->lchild);
        printf("%c",T->data);
        searchInfix(T->rchild);
        
        if(T->lchild!=NULL && T->rchild!=NULL){  printf(")");  }
    }
}
void searchPostfix(BTREE T)
{
    if(T!=NULL)
    {//·ÃÎʵ½ÄÚ²¿½Úµãʱ×óÓÒ¼ÓÀ¨ºÅ 
//        if(T->lchild!=NULL && T->rchild!=NULL){   printf("(");   }
        
        searchPostfix(T->lchild);
        searchPostfix(T->rchild);
        printf("%c",T->data);
        
//        if(T->lchild!=NULL && T->rchild!=NULL){  printf(")");  }
    }
}

如果遍歷前綴、后綴表達式時也要加括號，則方法一樣，在訪問到內部節點時加左右括號即可。從這里我們受到啟發，不借助程序，手動將中綴表達式轉換為前后綴表達式的方法：把括號內的操作符放到括號前面或后面然后去掉括號即可；反之，要將前后綴表達式轉為中綴表達式，只要加上括號然后把操作符放到括號內兩操作數中間即可！

5、測試：

int main()
{ 
//    *+A/-BCDE
//    ((A+((B-C)/D))*E)
//    ABC-D/+E*
    char str[]="ABC-D/+E*";
    BTREE T;
    
//    createPrefix_recursive(str,T);
//    createInfix_recursive(str,T);
    createPostfix_nonrecursive(str,T);

    
    searchPrefix(T);      
    printf("\n");
    
    searchInfix(T);
    printf("\n");
    
    searchPostfix(T);
    printf("\n");
    
    return 0;
}

2、前中后綴表達式間的轉換（以中綴表達式轉后綴表達式為例）

// *+A/-BCDE
// ((A+((B-C)/D))*E)
// ABC-D/+E*

2.1、轉換方法

手動轉換：把括號內的操作符放到括號前面或后面然后去掉括號即可；反之，要將前后綴表達式轉為中綴表達式，只要加上括號然后把操作符放到括號內兩操作數中間即可！

程序轉換：

法1：由中綴表達式構建表達式樹，然后后序遍歷該表達式樹即可

法2：不借助表達式樹，通過定義操作符的優先級純借助棧來實現，如下：

#include<stdio.h>
char nextToken(char infix[])//括號、操作數、操作符等 都為一個字符 
{
    static int pos=0;
    while(infix[pos]!='\0' && infix[pos]==' '){pos++;}//跳過空格 
    return infix[pos++];
}
int isOpNum(char ch)//是否是操作數 
{
    if(ch=='#' || ch=='(' || ch==')' || ch=='+' || ch=='-' || ch=='*' || ch=='/' || ch==' ')
    {
        return 0;
    }
    return 1;
}
int isCurchPriorToChtop(char chCur,char chTop)//當前元素是否比棧頂元素優先級大 
{
    if(chCur=='(' || chTop=='#' || chTop=='(') return 1;
    else if( (chCur=='*'||chCur=='/') && chTop!='*' && chTop!='/' ) return 1;
    else return 0;
}

//輸入中綴表達式轉后綴，單純用堆棧。假定中綴表達式符合語法。操作數或操作符都為一個char，可能有空格  
//也可通過對輸入的中綴表達式構建表達式樹然后后序遍歷來得到后綴表達式。 
#define M 100
void infix2Postfix(char infix[])
{
    char stack[M],x;
    int top=-1;
    stack[++top]='#';
    while(1)
    {
        x=nextToken(infix);
        if(isOpNum(x))
        {
            printf("%c",x);
        }
        else if(x=='#')
        {//中綴表達式掃描結束 
            while(top>=0)
            {
                printf("%c",stack[top--]);
            }
            return;
        }
        else if(x==')')
        {
            while(stack[top]!='(')
            {
                printf("%c",stack[top--]);
            }
            top--;
        }
        else
        {
            while(!isCurchPriorToChtop(x,stack[top]))
            {
                printf("%c",stack[top--]);
            }
            stack[++top]=x;
        }
    }
}
int main()
{
    char infix[]="(((A+(B-C)/D) *E)) #";
    int n=sizeof(infix)/sizeof(char);
    infix2Postfix(infix);
    return 0;
}

2.2、轉換相關的性質

中綴表達式轉前后綴表達式后，操作數順序不變、操作符順序會改變，但前后綴表達式的操作符順序恰好相反。

2.3、前后綴表達式的計算

前綴表達式：從后往前掃，遇到操作數入棧、遇到字符時取兩棧頂元素進行相應運算后結果入棧。

后綴表達式：與上類似，只是是從前往后掃。

 

相關閱讀：二叉樹-MarchOn