UVA 536 Tree Recovery （二叉树遍历，由先序.中序求后序序列）

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 file 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

【题意】

每个结点用一个大写字母表示，给出二叉树的先序和中序遍历序列，求出后序遍历序列

【分析】

先建树。

先序序列的第一个字母为根节点，在中序序列中找到这个字母，这个字母前面的字母就是左子树，右边的就是右子树。

将左右子树递归，再用同样的方法递归左右子树，每次确定一个root。

二叉树建成后，递归后序遍历即可

【代码】

#include<bits/stdc++.h>
using namespace std;

char pre[29],in[29];
int L[29],R[29];

int dfs(int l,int r,int u,int v)
{
    int i=u;
    while(in[i]!=pre[l])i++;

    L[pre[l]]=u>i-1 ? -1 : dfs(l+1,l+i-u, u,i-1);
    R[pre[l]]=i+1>v ? -1 : dfs(l+i-u+1,r, i+1,v);
    return pre[l];
}
void read(int rt)
{
    if(L[rt]!=-1)read(L[rt]);
    if(R[rt]!=-1)read(R[rt]);
    printf("%c",rt+'A');
}
int main()
{
    while(~scanf("%s%s",pre,in))
    {
        memset(L,-1,sizeof(L));
        memset(R,-1,sizeof(R));
        int n=strlen(pre);
        for(int i=0;i<n;i++)pre[i]-='A',in[i]-='A';
        int rt=dfs(0,n-1,0,n-1); //make tree
        read(rt);
        printf("\n");
    }
    return  0;
}