A - Tree Recovery POJ - 2255 （二叉树）

Tree

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

这道题 是 给你 二叉树 的 前序 和 中序 然后让你输出 后序。
代码 如下 ：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#define N 1000
using namespace std;

struct TreeNote//  定义一个存储二叉树元素的  结构体  
{
    char ch;         // 该节点的 元素
    TreeNote * ltree;//  该节点的左子树
    TreeNote * rtree;//  该节点的右子树
};

//  下面的函数功能为：根据输入的 前序和中序 来吧 二叉树 构建 并储存
TreeNote * CreatTree(char * preorder, char * inorder, int longth)
{
    TreeNote * sontree = new TreeNote;// 创建一个新的 二叉树 节点
    sontree-> ch = *preorder;
    sontree-> ltree = NULL;
    sontree-> rtree = NULL;

    if(longth == 0)
        return NULL;
    int index = 0;
    for(; index < longth; index++)
        if(inorder[index] == *preorder)
            break;
    // 下面进行递归 来构建 整个二叉树
    sontree-> ltree = CreatTree(preorder+1, inorder, index);
    sontree-> rtree = CreatTree(preorder+index+1, inorder+index+1, longth-index-1);

    return sontree;
}

// 二叉树后序遍历，前序和中序遍历只是 ，输出函数的相对位置交换一下就可以了
void PostOrder(TreeNote * tone)
{
    if(tone)
    {
        PostOrder(tone-> ltree);
        PostOrder(tone-> rtree);
        cout<<tone->ch;
    }
}

int main()
{
    char preorder[N];
    char inorder[N];
    while(scanf("%s%s", preorder, inorder) != EOF)
    {
        // 储存整个二叉树的根节点
        TreeNote * tone = CreatTree(preorder, inorder, strlen(preorder));
        PostOrder(tone);// 递归 进行二叉树的后序遍历
        putchar('\n');
    }


    return 0;
}

下面 还有一道 跟这道题 很类似的 题， 也是 给你 前序 和 中序 让你输出 后序。

代码 如下：

Binary Tree Traversals

HDU - 1710

A binary tree is a finite set of vertices that is either empty or consists of a root r and two disjoint binary trees called the left and right subtrees. There are three most important ways in which the vertices of a binary tree can be systematically traversed or ordered. They are preorder, inorder and postorder. Let T be a binary tree with root r and subtrees T1,T2.

In a preorder traversal of the vertices of T, we visit the root r followed by visiting the vertices of T1 in preorder, then the vertices of T2 in preorder.

In an inorder traversal of the vertices of T, we visit the vertices of T1 in inorder, then the root r, followed by the vertices of T2 in inorder.

In a postorder traversal of the vertices of T, we visit the vertices of T1 in postorder, then the vertices of T2 in postorder and finally we visit r.

Now you are given the preorder sequence and inorder sequence of a certain binary tree. Try to find out its postorder sequence.

Input
The input contains several test cases. The first line of each test case contains a single integer n (1<=n<=1000), the number of vertices of the binary tree. Followed by two lines, respectively indicating the preorder sequence and inorder sequence. You can assume they are always correspond to a exclusive binary tree.

Output
For each test case print a single line specifying the corresponding postorder sequence.

Sample Input
9
1 2 4 7 3 5 8 9 6
4 7 2 1 8 5 9 3 6
Sample Output
7 4 2 8 9 5 6 3 1