题目1201：二叉排序树

题目来源：http://ac.jobdu.com/problem.php?pid=1201

时间限制：1 秒

内存限制：32 兆

特殊判题：否

提交：3039

解决：1279

题目描述：

    输入一系列整数，建立二叉排序数，并进行前序，中序，后序遍历。

输入：

    输入第一行包括一个整数n(1<=n<=100)。
    接下来的一行包括n个整数。

输出：

    可能有多组测试数据，对于每组数据，将题目所给数据建立一个二叉排序树，并对二叉排序树进行前序、中序和后序遍历。
    每种遍历结果输出一行。每行最后一个数据之后有一个空格。

样例输入：

5
1 6 5 9 8

样例输出：

1 6 5 9 8 
1 5 6 8 9 
5 8 9 6 1 

提示：

输入中可能有重复元素，但是输出的二叉树遍历序列中重复元素不用输出。

来源：

2005年华中科技大学计算机保研机试真题

#include <iostream>
#include <cstdio>
#include <cstring>

using namespace std;

struct Binary_Search_Tree_Node
{
    Binary_Search_Tree_Node* pRChildren;
    Binary_Search_Tree_Node* pLChildren;
    int data;
    Binary_Search_Tree_Node()
    {
        pRChildren = pLChildren = NULL;
        data = 0;
    }
};

bool In_BST(Binary_Search_Tree_Node* pRoot, Binary_Search_Tree_Node* &p, int data, Binary_Search_Tree_Node* f)
{
    if(pRoot == NULL)
    {
        p = f;
        return false;
    }
    if(data == pRoot->data)
    {
        p = pRoot;
        return true;
    }
    else if(data > pRoot->data)
        return In_BST(pRoot->pRChildren, p, data, pRoot);
    else if(data < pRoot->data)
        return In_BST(pRoot->pLChildren, p, data, pRoot);
    return false ;
}


void Insert_BST(Binary_Search_Tree_Node* &pRoot, int iData)
{
    Binary_Search_Tree_Node* p = NULL;
    if(!In_BST(pRoot, p, iData, NULL))
    {
        Binary_Search_Tree_Node* tmp = new Binary_Search_Tree_Node();
        tmp->data = iData;
        if(p == NULL)
            pRoot = tmp;
        else if(p->data > iData)
            p->pLChildren = tmp;
        else if(p->data < iData)
            p->pRChildren = tmp;
    }
}

void Pre_Print_Binary_Search_Tree(Binary_Search_Tree_Node* pRoot)
{
    if(pRoot == NULL)
        return ;
    printf("%d ", pRoot->data);
    Pre_Print_Binary_Search_Tree(pRoot->pLChildren);
    Pre_Print_Binary_Search_Tree(pRoot->pRChildren);
}

void InOrder_Print_Binary_Search_Tree(Binary_Search_Tree_Node* pRoot)
{
    if(pRoot == NULL)
        return ;
    InOrder_Print_Binary_Search_Tree(pRoot->pLChildren);
    printf("%d ", pRoot->data);
    InOrder_Print_Binary_Search_Tree(pRoot->pRChildren);
}

void PostOrder_Print_Binary_Search_Tree(Binary_Search_Tree_Node* pRoot)
{
    if(pRoot == NULL)
        return ;
    PostOrder_Print_Binary_Search_Tree(pRoot->pLChildren);
    PostOrder_Print_Binary_Search_Tree(pRoot->pRChildren);
    printf("%d ", pRoot->data);
}

void Delete_Binary_Search_Tree(Binary_Search_Tree_Node* pRoot)
{
    if(pRoot ==  NULL)
        return ;
    if(pRoot->pLChildren == NULL && pRoot->pRChildren == NULL)
    {
        delete pRoot;
        return ;
    }
    Delete_Binary_Search_Tree(pRoot->pLChildren);
    Delete_Binary_Search_Tree(pRoot->pRChildren);
}

int main()
{
    Binary_Search_Tree_Node* pRoot;
    int iData, n;
    while(~scanf("%d", &n))
    {
        pRoot = NULL;
        for(int i = 0; i < n; ++i)
        {
            scanf("%d", &iData);
            Insert_BST(pRoot, iData);
        }
        Binary_Search_Tree_Node* tmp = pRoot;
        Pre_Print_Binary_Search_Tree(tmp);
        printf("\n");
        tmp = pRoot;
        InOrder_Print_Binary_Search_Tree(tmp);
        printf("\n");
        tmp = pRoot;
        PostOrder_Print_Binary_Search_Tree(tmp);
        printf("\n");
        Delete_Binary_Search_Tree(pRoot);
    }
    return 0;
}