swust oj 984

利用二叉树中序及先序遍历确定该二叉树的后序序列

1000(ms)

10000(kb)

2754 / 5599

已知二叉树的中序和先序遍历可以唯一确定后序遍历、已知中序和后序遍历可以唯一确定先序遍历，但已知先序和后序，却不一定能唯一确定中序遍历。现要求根据输入的中序遍历结果及先序遍历结果，要求输出其后序遍历结果。

输入

输入数据占2行，其中第一行表示中序遍历结果，第二行为先序遍历结果。

输出

对测试数据，输出后序遍历结果。

样例输入

BFDAEGC
ABDFCEG

样例输出

FDBGECA 

 #include<iostream>
 #include<algorithm>
 #include<cstring>
 #include<cstdlib>
 #include<cstdio>
 typedef char Datetype;
 using namespace std;
 int x;

 typedef struct link{
     Datetype date;
     struct link *lchild;
     struct link *rchild;
 }tree;

 typedef struct queue{
     tree *data;
     struct queue *next;
 }que;

 typedef struct {
     que *front;
     que *rear;
 }lin;

 void Initqueue(lin *&L)
 {
     L=(lin *)malloc(sizeof(lin));
     L->front=L->rear=NULL;
 }

 void destroyed(lin *&L)
 {
     que *p=NULL,*r=NULL;
     p=L->front;
     while(p!=NULL)
     {
         r=p;
         p=p->next;
         free(r);
     }
     free(L);
 }

 bool pop(lin *&L, tree *&e)
 {
     que *p;
     if(L->rear==NULL)
         return false;
     p=L->front;
     if(L->rear==L->front)
         L->front=L->rear=NULL;
     else
         L->front=p->next;
     e=p->data;
     free(p);
     return true;
 }

 int empty(lin *&L)
 {
     return (L->rear==NULL);
 }

 void push(lin *&L,tree *e)
 {
     que *p;
     p = (que *)malloc(sizeof(que));
     p->data=e;
     p->next=NULL;
     if(L->rear==NULL)
     {
         L->front=p;
         L->rear=p;
     }
     else
     {
         L->rear->next=p;
         L->rear=p;
     }
 }

 void creattree(tree *&L)
 {
     char c;
     cin>>c;
     if(c=='#')
         L=NULL;
     else
     {
         L = (tree *)malloc(sizeof(tree)) ;
         L->date=c;
         creattree(L->lchild);
         creattree(L->rchild);
     }
 }

 void find(tree *L)
 {
     if(L!=NULL)
     {
         x++;
         find(L->rchild);
     }
 }

 void destroytree(tree *&L)
 {
     if(L!=NULL)
     {
         destroytree(L->lchild);
         destroytree(L->rchild);
         free(L);
     }
 }

 int deep(tree *L)
 {
     int ldep,rdep,max;
     if(L!=NULL)
     {
         ldep=deep(L->lchild);
         rdep=deep(L->rchild);
         max=ldep>rdep?ldep+:rdep+;
         return max;
     }
     else
         return ;
 }

 void finddegree(tree *&L, int n)
 {
     if(L!=NULL)
     {
         if(x<n)
             x=n;
         finddegree(L->lchild,n);
         finddegree(L->rchild,n+);
     }

 }

 void run(tree *L)
 {
     tree *p=L;
     lin *qu;
     Initqueue(qu);
     if(L!=NULL)
         push(qu,p);
     while(!empty(qu))
     {
         pop(qu,p);
         cout<<p->date;
         if(p->lchild!=NULL)
             push(qu,p->lchild);
         if(p->rchild!=NULL)
             push(qu,p->rchild);
     }
     destroyed(qu);
 }

 void display(tree *&L)
 {
     if(L!=NULL)
     {
         display(L->lchild);
         display(L->rchild);
         cout<<L->date;
     }
 }

 void creat(tree *&L ,char *in,char *pre,int x)
 {
     int k=;
     char *p;
     if(x<=)
     {
         L=NULL;
         return ;
     }
     L=(tree *)malloc(sizeof(tree));
     L->date = *pre;
     for(p=in ; p<in+x; p++)
     {
         if(*p==*pre)
             break;
     }
     k=p-in;
     creat(L->lchild,in,pre+,k);
     creat(L->rchild,p+,pre+k+,x-k-);
 }

 int main()
 {
     tree *L = NULL;
     x=;
     char in[],pre[];
     cin>>in;
     cin>>pre;
     x=strlen(in);
     creat(L,in,pre,x);
     display(L);
     destroytree(L);
     return ;
 }