【中缀表达式树】

#include<cstdio>
#include<cstring>
#include<stack>
#include<cstdio>
#include<algorithm>
using namespace std;
struct node{
    char v;
    struct node *l,*r;
    node(char c){
        v=c;
        l=r=NULL;
    }
};
stack<node*>p; // 操作数栈
stack<char>q; // 操作符栈

int len;
char str[1010];
int getOrder(char c){//优先级比较
    switch(c){
    case '+': case '-':
        return 0;
    case '*': case '/':
        return 1;
    case '(':case ')':
        return 2;
    }
}
void bulidNode(){  // 将p栈顶两数与q栈顶一操作符构建一颗二叉树，并压入p栈
    node *t1=new node(0);
    node *t2=new node(0);
    char s;
    t2=p.top();p.pop();
    t1=p.top();p.pop();
    s=q.top();q.pop();
    node *N=new node(s);
    N->l=t1;
    N->r=t2;
    p.push(N);
}
void PUSH(int &i){   //创建一个节点
    node *t=new node(str[i]);
    p.push(t);
}
/*
  根据中缀式构建表达式树
*/
void bulidTree(){
    int i;
    for(int i=0;i<len;i++){
        if(str[i]>='0'&&str[i]<='9')
            PUSH(i);
        else if(str[i]=='(')
            q.push('(');
        else if(str[i]==')'){
            while(q.top()!='(')
                    bulidNode();
            q.pop();
        }
        else {
            while(!q.empty()&& q.top()!='('&&getOrder(q.top())>=getOrder(str[i]))
                    bulidNode();
            q.push(str[i]);
        }
    }
    while(!q.empty()) bulidNode();
}
void PRTraverse(node *t){  //先序遍历
    if(t){
        printf("%c",t->v);
        PRTraverse(t->l);
        PRTraverse(t->r);
    }
}
void POTraverse(node *t){  //后序遍历
    if(t){
        POTraverse(t->l);
        POTraverse(t->r);
        printf("%c",t->v);
    }
}
int main(){
    int test ;
    scanf("%d",&test);
    while(test--){
        scanf("%s",str);
        len=strlen(str);
        bulidTree();
        POTraverse(p.top());
        printf("\n");
        PRTraverse(p.top());
        printf("\n");
        p.pop();
    }
    return 0;
}

/*
算法思想：其实很简单，主要就是栈的使用。算法时间复杂度是O(n),n是后缀表达式长度。
从前向后依次扫描后缀表达式，如果是操作数就建立一个单节点树，并把其指针压入栈。如果是操作符，则
建立一个以该操作符为根的树，然后从栈中依次弹出两个指针（这2个指针分别指向2个树），作为该树的
左右子树。然后把指向这棵树的指针压入栈。直到扫描完后缀表达式。
最后栈中就会只有一个指针。这个指针指向构造的表达式树的根节点。


*/

#include<cstdio>
#include<stack>
using namespace std;
struct Node{
    char data;
    Node *l,*r;
    Node(char c){
        data=c;
        l=r=NULL;
    }
};
char str[1000];
stack<Node*>st;
void create_ET(char *str){
    char *s=str;
    Node *temp;
    while(*s){
        if(*s=='+'||*s=='-'||*s=='*'||*s=='/'){
            temp=new Node(*s);
            temp->r=st.top(); st.pop();
            temp->l=st.top();st.pop();
            st.push(temp);
        }
        else{
            temp=new Node(*s);
            st.push(temp);
        }
            s++;
        }
}
void POSTraverse(Node *root){
    if(root!=NULL){
    POSTraverse(root->l);
    POSTraverse(root->r);
    printf("%c",root->data);
    }

}
int main(){
    while(~scanf("%s",str)){
        create_ET(str);
        POSTraverse(st.top());
        st.pop();
        printf("\n");
    }
}