poj 1577 Falling Leaves（二叉搜索树的简单操作（建立、插入））

Falling Leaves
点击打开题目链接

Time Limit: 1000MS		Memory Limit: 10000K
Total Submissions: 3941		Accepted: 2181

Description

Figure 1
Figure 1 shows a graphical representation of a binary tree of letters. People familiar with binary trees can skip over the definitions of a binary tree of letters, leaves of a binary tree, and a binary search tree of letters, and go right to The problem.

A binary tree of letters may be one of two things:

1. It may be empty.
   
2. It may have a root node. A node has a letter as data and refers to a left and a right subtree. The left and right subtrees are also binary trees of letters.

In the graphical representation of a binary tree of letters:

1. Empty trees are omitted completely.
   
2. Each node is indicated by
   
   • Its letter data,
     
   • A line segment down to the left to the left subtree, if the left subtree is nonempty,
     
   • A line segment down to the right to the right subtree, if the right subtree is nonempty.

A leaf in a binary tree is a node whose subtrees are both empty. In the example in Figure 1, this would be the five nodes with data B, D, H, P, and Y.

The preorder traversal of a tree of letters satisfies the defining properties:

1. If the tree is empty, then the preorder traversal is empty.
   
2. If the tree is not empty, then the preorder traversal consists of the following, in order
   
   • The data from the root node,
     
   • The preorder traversal of the root's left subtree,
     
   • The preorder traversal of the root's right subtree.

The preorder traversal of the tree in Figure 1 is KGCBDHQMPY.

A tree like the one in Figure 1 is also a binary search tree of letters. A binary search tree of letters is a binary tree of letters in which each node satisfies:

The root's data comes later in the alphabet than all the data in the nodes in the left subtree.

The root's data comes earlier in the alphabet than all the data in the nodes in the right subtree.

The problem:

Consider the following sequence of operations on a binary search tree of letters

Remove the leaves and list the data removed
Repeat this procedure until the tree is empty
Starting from the tree below on the left, we produce the sequence of trees shown, and then the empty tree

by removing the leaves with data

BDHPY
CM
GQ
K

Your problem is to start with such a sequence of lines of leaves from a binary search tree of letters and output the preorder traversal of the tree.

Input

The input will contain one or more data sets. Each data set is a sequence of one or more lines of capital letters.

The lines contain the leaves removed from a binary search tree in the stages described above. The letters on a line will be listed in increasing alphabetical order. Data sets are separated by a line containing only an asterisk ('*').

The last data set is followed by a line containing only a dollar sign ('$'). There are no blanks or empty lines in the input.

Output

For each input data set, there is a unique binary search tree that would produce the sequence of leaves. The output is a line containing only the preorder traversal of that tree, with no blanks.

Sample Input

BDHPY
CM
GQ
K
*
AC
B
$

Sample Output

KGCBDHQMPY
BAC

Source

Mid-Central USA 2000


简单的二叉搜索树的建立，题目给出叶子节点，然后将其删去，知道最后整棵树都被删去了；然后题目要求输出二叉搜索树本来的前序遍历的序列；
可知最后删去的叶节点就是这棵树的根节点；
只要从根节点，按照输入顺序相反的方向建立好二叉搜索树，再前序遍历输出即可；
建立时，节点是一个一个添加进去的；
添加函数：

void add(int x,char ch)
{
    if(ch<bt[x].data)//比节点data小的放到节点的左子树上
    {
        if(bt[x].left==0)//如果左子树已经有了再找左子树的左子树，直到找到没有的位置
        {
            bt[x].left=n++;//编号
            bt[bt[x].left].data=ch;//data赋值

        }
        else
        {
            add(bt[x].left,ch);//递归求插入；
        }
    }
    else
    {
        if(bt[x].right==0)//同上
        {
            bt[x].right=n++;
            bt[bt[x].right].data=ch;

        }
        else
            add(bt[x].right,ch);
    }
}

要说的是这个题的输入结束标志，’*‘和’$‘，如果是’*‘，则输出前序遍历的序列，如果是’$‘则输出前序遍历的序列并结束输入；
注：注意赋初值的位置（T^T   我不告诉你我怎么知道的   T^T）
代码：

#include<stdio.h>
#include<string.h>
#define MAX 55
char leves[MAX][MAX];
struct node
{
    char data;
    int left,right;
    node()
    {
        left=right=0;
    }
} bt[MAX];
int n;
void add(int x,char ch)
{
    if(ch<bt[x].data)
    {
        if(bt[x].left==0)
        {
            bt[x].left=n++;
            bt[bt[x].left].data=ch;

        }
        else
        {
            add(bt[x].left,ch);
        }
    }
    else
    {
        if(bt[x].right==0)
        {
            bt[x].right=n++;
            bt[bt[x].right].data=ch;

        }
        else
            add(bt[x].right,ch);
    }
}
void create(int d)
{
    int i,j,k;
    n=0;
    bt[0].data=leves[d-1][0];
    n++;
    for(i=d-2; i>=0; i--)
    {
        k=strlen(leves[i]);
        for(j=0; j<k; j++)//循环建立
        {
            add(0,leves[i][j]);
        }
    }
}
void preorder(int s)//前序遍历并输出
{
    printf("%c",bt[s].data);
    if(bt[s].left)
        preorder(bt[s].left);
    if(bt[s].right)
        preorder(bt[s].right);
}
void init(int n)//赋初值
{
    int i;
    for(i=0; i<n; i++)
    {
        bt[i].data='\0';
        bt[i].left=0;
        bt[i].right=0;
    }
}
int main()
{
    int depth=0;
    while(~scanf("%s",leves[depth]))
    {
        if(leves[depth][0]=='*'||leves[depth][0]=='$')//判断结束符号
        {
            create(depth);
            preorder(0);
            printf("\n");
            if(leves[depth][0]=='$')
            {
                break;
            }
            init(depth);//初值要在这赋
            memset(leves,'\0',sizeof(leves[0])*MAX);//赋初值
        }
        else
        {
            depth++;
        }
    }
    return 0;
}