由遍历序列恢复二叉树

由遍历序列恢复二叉树

PS:这里介绍由先序序列和中序序列构造唯一二叉树 以及由后序遍历和中序遍历构造二叉树

---

一、由先序遍历和中序遍历恢复二叉树

---

举一个例子：
由：
先序序列为：ABCDEFGHI
中序序列为：BCAEDGHFI
恢复该二叉树
首先，由先序序列可知，结点A是二叉树根结点。其次，根据中序序列，在A之前所有的结点都是根结点的左子树的结点，在A之后的结点都是根结点右子树的结点，由此就是下图的a) 的状态。
然后在对A左子树进行分解，得知B是左子树的根结点，又从中序序列知道，B的左子树为空，B的右子树只有一个结点C。
接着对A的右子树进行分解，得知A的右子树的根结点是D；而D把其余结点分成两部分，即左子树E，右子树FGHI，如图b） 所示。
接下就是以D为根结点，将右子树继续分解了

可以知道，上述过程就是一个递归的过程。。

于是上例题：
输入

两个字符串，其长度n均小于等于26。
第一行为前序遍历，第二行为中序遍历。
二叉树中的结点名称以大写字母表示：A，B，C…最多26个结点。

输出

输入样例可能有多组，对于每组测试样例，
输出一行，为后序遍历的字符串。

样例输入

ABC
CBA
ABCDEFG
DCBAEFG
样例输出

CBA
DCBGFEA

直接上代码：

/**注意下二级指针*/
#include<cstdio>
#include<cstring>
#include<cstdlib>
using namespace std;
char preOrder[30];
char inOrder[30];
typedef struct node
{
    char data;
    struct node *lchild,*rchild;
}*BiTree;
BiTree t;
/**由先序序列、中序序列恢复二叉树*/
//其中i，j表示前序遍历的下界和上界；k，h表示中序遍历的下界和上界
void preInOrder(int i,int j,int k,int h,BiTree *t)        //其中的t为二级指针
{
    *t=(node*)malloc(sizeof(node));
    (*t)->data=preOrder[i];
    int m=k;
    while(inOrder[m]!=preOrder[i])
        m++;
    if(m==k)
        (*t)->lchild=NULL;
    else
        preInOrder(i+1,i+m-k,k,m-1,&((*t)->lchild));
    if(m==h)
        (*t)->rchild=NULL;
    else
        preInOrder(i+m-k+1,j,m+1,h,&((*t)->rchild));
}
/**后序遍历*/
void postOrder(BiTree t)
{
    if(t==NULL)
        return;
    postOrder(t->lchild);
    postOrder(t->rchild);
    printf("%c",t->data);
}
int main()
{
    while(~scanf("%s%s",preOrder,inOrder))
    {
        int n=strlen(preOrder);
        preInOrder(0,n-1,0,n-1,&t);
        postOrder(t);
        printf("\n");
    }
    return 0;
}

上述代码可能较为复杂，然后还有简单版的代码二：

#include<cstdio>
#include<cstring>
#include<cstdlib>
using namespace std;
typedef struct node
{
    char data;
    struct node *lchild,*rchild;
}*BiTree;
BiTree t;
char pre[30];
char in[30];
/**由先序序列、中序序列恢复二叉树*/
BiTree BuildTree(char *pre,char *in,int size)
{
    BiTree t;
    for(int i=0;i<size;i++)
    {
        if(pre[0]==in[i])
        {
            t=(node *)malloc(sizeof(node));
            t->data=in[i];
            t->lchild=BuildTree(pre+1,in,i);
            t->rchild=BuildTree(pre+i+1,in+i+1,size-i-1);
            return t;
        }
    }
    return NULL;
}
/**后序遍历*/
void postOrder(BiTree t)
{
    if(t==NULL)
        return;
    postOrder(t->lchild);
    postOrder(t->rchild);
    printf("%c",t->data);
}
int main()
{
    while(~scanf("%s%s",pre,in))
    {
        t=(node *)malloc(sizeof(node));
        int n=strlen(pre);
        t=BuildTree(pre,in,n);
        postOrder(t);
        printf("\n");
    }
    return 0;
}

---

二、由后序遍历和中序遍历恢复二叉树

---

本来觉得由后序遍历和中序遍历恢复二叉树和通过先序遍历和中序遍历会有比较大的区别
但是没有仔细想二叉树的结果，其他两者的方法差不了太多

主要也是做了这道题，才试着写了写通过后序遍历和中序遍历恢复二叉树

洛谷P1030

主要是注意和上面的区别

#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<cstring>
#include<algorithm>
#include<iostream>
#include<set>
#include<vector>
#include<queue>
#include<map>
#include<list>
#define INF 0x3f3f3f3f
#define ll long long
#define pi acos(-1.0)
using namespace std;
char inOrder[30];
char postOrder[30];
typedef struct node{
    char data;
    struct node *lchild,*rchild;
}*BiTree;
BiTree t;

//由中序遍历和后序遍历恢复二叉树（注意与上面的区别）
//i，j表示后序遍历的下界和上界；k，h表示中序遍历的下界和上界
void postInOrder(int i,int j,int k,int h,BiTree *t){
    *t=(node*)malloc(sizeof(node));
    (*t)->data=postOrder[j];    //这里变成了j
    int m=k;
    while(inOrder[m]!=postOrder[j]){  //同上
        m++;
    }
    if(m==k){
        (*t)->lchild=NULL;
    }
    else{
        postInOrder(i,i+m-k-1,k,m-1,&(*t)->lchild);   //i+1变为了i,i+m-k变为了i+m-k-1
    }
    if(m==h){
        (*t)->rchild=NULL;
    }
    else{
        postInOrder(i+m-k,j-1,m+1,h,&(*t)->rchild);    //i+m-k+1,变为了i+m-k,j变为了j-1
    }
}

//先序遍历
void preOrder(BiTree t){
    if(t==NULL){
        return ;
    }
    printf("%c",t->data);
    preOrder(t->lchild);
    preOrder(t->rchild);
}

int main(){
    scanf("%s%s",inOrder,postOrder);
    int n=strlen(inOrder);
    postInOrder(0,n-1,0,n-1,&t);
    preOrder(t);
    printf("\n");
    return 0;
}