04-树7 二叉搜索树的操作集

/*=====================================================================================
#       COPYRIGHT NOTICE
#       Copyright (c) 2016

#
#       @Author       :Zehao Wang
#       @Email         :zehaowang@163.com
#       @from            ：https://pta.patest.cn/pta/test/1342/exam/3/question/20490
#       @Last modified         :2016-12-04
#       @Description    :实现二叉搜索树的操作集
========================================================================================*/
#include <stdio.h>
#include <stdlib.h>

typedef int ElementType;
typedef struct TNode *Position;
typedef Position BinTree;
struct TNode {
    ElementType Data;
    BinTree Left;
    BinTree Right;
};

void PreorderTraversal(BinTree BT); /* 先序遍历，由裁判实现，细节不表 */
void InorderTraversal(BinTree BT);  /* 中序遍历，由裁判实现，细节不表 */

BinTree Insert(BinTree BST, ElementType X);
BinTree Delete(BinTree BST, ElementType X);
Position Find(BinTree BST, ElementType X);
Position FindMin(BinTree BST);
Position FindMax(BinTree BST);

int main()
{
    BinTree BST, MinP, MaxP, Tmp;
    ElementType X;
    int N, i;

    BST = NULL;
    scanf("%d", &N);
    for (i = 0; i<N; i++) {
        scanf("%d", &X);
        BST = Insert(BST, X);
    }
    printf("Preorder:"); PreorderTraversal(BST); printf("\n");
    MinP = FindMin(BST);
    MaxP = FindMax(BST);
    scanf("%d", &N);
    for (i = 0; i<N; i++) {
        scanf("%d", &X);
        Tmp = Find(BST, X);
        if (Tmp == NULL) printf("%d is not found\n", X);
        else {
            printf("%d is found\n", Tmp->Data);
            if (Tmp == MinP) printf("%d is the smallest key\n", Tmp->Data);
            if (Tmp == MaxP) printf("%d is the largest key\n", Tmp->Data);
        }
    }
    scanf("%d", &N);
    for (i = 0; i<N; i++) {
        scanf("%d", &X);
        BST = Delete(BST, X);
    }
    printf("Inorder:"); InorderTraversal(BST); printf("\n");

    return 0;
}
/* 你的代码将被嵌在这里 */

BinTree Insert(BinTree BST, int X)
{
    if (!BST)
    {
        BST = (struct TNode*)malloc(sizeof(struct TNode));
        BST->Data = X;
        BST->Left = NULL;
        BST->Right = NULL;
    }
    else
    {
        if (X < BST->Data)
            BST->Left=Insert(BST->Left, X);
        else
            BST->Right=Insert(BST->Right, X);
    }
    return BST;
}

void PreorderTraversal(BinTree BT)
{
if(BT)
    {
        printf(" %d", BT->Data);
        PreorderTraversal(BT->Left);
        PreorderTraversal(BT->Right);
    }
}

Position FindMin(BinTree BST)
{
    if (BST->Left == NULL)
        return BST;
    else
    {
        BST = BST->Left;
        FindMin(BST);
    }
}

Position FindMax(BinTree BST)
{
    if (BST->Right == NULL)
        return BST;
    else
    {
        BST = BST->Right;
        FindMax(BST);
    }
}

Position Find(BinTree BST, ElementType X)
{
    if (!BST)
        return NULL;
    else
    {
        if (BST->Data == X)
            return BST;
        else if (BST->Data > X)
            return Find(BST->Left, X);
        else
            return Find(BST->Right, X);

    }
}
BinTree Delete(BinTree BST, ElementType X)
{
    Position BST1;
    if (!BST)
        printf("Not found\n");
    else
    {
        if (X < BST->Data)
            BST->Left=Delete(BST->Left, X);
        else if (X > BST->Data)
            BST->Right=Delete(BST->Right, X);
        else//找到了
        {
            //第一种情况，左儿子右儿子都存在
            if (BST->Left&&BST->Right)
            {
                BST1 = FindMin(BST->Right);//寻找右子树中的最小值（或左子树中的最大值）
                BST->Data = BST1->Data;
                BST->Right=Delete(BST->Right, BST1->Data);
            }
            //第二种情况，只有一个儿子或者没有儿子
            else
            {
                BST1 = BST;
                if (!BST->Left)//只有一个右儿子或没儿子
                {
                    BST = BST->Right;
                }
                else if (!BST->Right)
                {
                    BST = BST->Left;
                }
                free(BST1);
            }

        }       
    }
    return BST;

}

void InorderTraversal(BinTree BT)
{
    if (!BT)
        return;
    else
    {
        InorderTraversal(BT->Left);
        printf(" %d",BT->Data);
        InorderTraversal(BT->Right);
    }
}
/*============================================================================================
注：此题很基础，难度不大。只需注意Delete的操作即可。详细分析可见《数据结构》陈越主编P122—P125
页的讲解。
==============================================================================================*/