A - Tree Recovery（9.3.1）

A - Tree Recovery（9.3.1）

Time Limit:1000MS     Memory Limit:65536KB     64bit IO Format:%I64d & %I64u

Submit  Status

Description

Little Valentine liked playing with binary trees very much. Her favorite game was constructing randomly looking binary trees with capital letters in the nodes. 
This is an example of one of her creations: 

                                               D

                                              / \

                                             /   \

                                            B     E

                                           / \     \

                                          /   \     \

                                         A     C     G

                                                    /

                                                   /

                                                  F

To record her trees for future generations, she wrote down two strings for each tree: a preorder traversal (root, left subtree, right subtree) and an inorder traversal (left subtree, root, right subtree). For the tree drawn above the preorder traversal is DBACEGF and the inorder traversal is ABCDEFG. 
She thought that such a pair of strings would give enough information to reconstruct the tree later (but she never tried it). 

Now, years later, looking again at the strings, she realized that reconstructing the trees was indeed possible, but only because she never had used the same letter twice in the same tree. 
However, doing the reconstruction by hand, soon turned out to be tedious. 
So now she asks you to write a program that does the job for her! 
Input

The input will contain one or more test cases. 
Each test case consists of one line containing two strings preord and inord, representing the preorder traversal and inorder traversal of a binary tree. Both strings consist of unique capital letters. (Thus they are not longer than 26 characters.) 
Input is terminated by end of file. 
Output

For each test case, recover Valentine's binary tree and print one line containing the tree's postorder traversal (left subtree, right subtree, root).

Sample Input

DBACEGF ABCDEFG
BCAD CBAD

Sample Output

ACBFGED
CDAB

解题报告：

本题是由二叉树的中序遍历顺序与前序遍历顺序确定后根遍历顺序。

     由前序遍历和中序遍历的递归定义中可以看出，前序遍历的首字符是树的根。中序遍历中位于该字符左侧的子串为左子树中遍历的结果，中序遍历中位于该字符右侧的子串为右子树中的遍历结果。设。

     中序遍历s=s1s2...sk..sn;

      前序遍历p=p1p2...pn;

      显然前序遍历的p1即为该树的树根，对于中序遍历里的与p1相等的sk为树根，根据后跟遍历分析：

       若k>1，则左子树存在，位于sk左侧的序列（s1...sk）为中序遍历中的左子树结果，前序遍历的（p2...pk）为前序遍历的左子树结果；

       若k<n, 则右子树存在，位于sk右侧的子序列即为中序遍历的右子树结果，前序遍历中（pk+1...pn）为前序遍历的右子树结果；

       分别递归二叉树的左子树和右子树（若存在的话），最后输出根sk或p1;

代码：

#include <iostream>
#include <cstring>
#include <cstdio>
using namespace std;
char pre[30],in[30];
void recover(int prel,int prer,int inl,int inr)
{
    int root;
    if(prel>prer||inl>inr)//左右子树都不存在则返回
         return ;
        for(root=inl;root<=inr;root++)//寻找根节点
            if(pre[prel]==in[root])
            break;
        if(root>0)
            recover(prel+1,prel+(root-inl),inl,root-1);//递归左子树
        if(root<inr)
            recover(prel+(root-inl)+1,prer,root+1,inr);//递归右子树

    printf("%c",in[root]);//输出根节点
}
int main()
{
    int len1,len2;
    while(scanf("%s%s",pre,in)!=EOF)
    {
        len1=strlen(pre);
        len2=strlen(in);
        recover(0,len1-1,0,len2-1);
        printf("\n");
    }
    return 0;
}

法二：先建树后递归输出后根遍历的结果。

代码：

#include <iostream>
#include <cstring>
#include <cstdio>
using namespace std;
char pre[30],in[30];
struct node
{
    char ch;
    node *left,*right;
};
node *recover(int prel,int prer,int inl,int inr)
{
    node * root1;
    root1=new node;
    int root;
    if(prel>prer||inl>inr)
         return root1=0;
        for(root=inl;root<=inr;root++)
            if(pre[prel]==in[root])
            break;
        root1->ch=in[root];
        root1->left=recover(prel+1,prel+(root-inl),inl,root-1);
        root1->right=recover(prel+(root-inl)+1,prer,root+1,inr);
        return root1;
}
void print(node *n)
{
    if(n==NULL)
        return ;
    print(n->left);
    print(n->right);
    cout<<n->ch;
}
int main()
{
    int len1,len2;
    while(scanf("%s%s",pre,in)!=EOF)
    {
        len1=strlen(pre);
        len2=strlen(in);
        node *head;
        head=recover(0,len1-1,0,len2-1);
        print(head);
        printf("\n");
    }
    return 0;
}