6-12 二叉搜索树的操作集 (30分)

最新推荐文章于 2021-07-29 13:31:22 发布

CCPigSnail

最新推荐文章于 2021-07-29 13:31:22 发布

阅读量284

点赞数

分类专栏： PTA 文章标签：数据结构二叉树

本文链接：https://blog.csdn.net/qq_45815991/article/details/106479540

版权

PTA 专栏收录该内容

48 篇文章 7 订阅

订阅专栏

本题要求实现给定二叉搜索树的5种常用操作。

函数接口定义：

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 );

其中BinTree结构定义如下：

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

函数Insert将X插入二叉搜索树BST并返回结果树的根结点指针；
函数Delete将X从二叉搜索树BST中删除，并返回结果树的根结点指针；如果X不在树中，则打印一行Not Found并返回原树的根结点指针；
函数Find在二叉搜索树BST中找到X，返回该结点的指针；如果找不到则返回空指针；
函数FindMin返回二叉搜索树BST中最小元结点的指针；
函数FindMax返回二叉搜索树BST中最大元结点的指针。

裁判测试程序样例：

#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;
}
/* 你的代码将被嵌在这里 */

输入样例：

10
5 8 6 2 4 1 0 10 9 7
5
6 3 10 0 5
5
5 7 0 10 3

输出样例：

Preorder: 5 2 1 0 4 8 6 7 10 9
6 is found
3 is not found
10 is found
10 is the largest key
0 is found
0 is the smallest key
5 is found
Not Found
Inorder: 1 2 4 6 8 9

Position Find( BinTree BST, ElementType X ) 
{
    if(BST==NULL)
        return NULL;
    if(X<BST->Data)
        return Find(BST->Left,X);
    else if(X>BST->Data)
        return Find(BST->Right,X);
    else
        return BST;
}
Position FindMin( BinTree BST )//尾递归
{
    if(BST==NULL)
        return NULL;
    else if(BST->Left==NULL)
        return BST;
    else
        return FindMin(BST->Left);
}

Position FindMax( BinTree BST )//非递归方法
{
    if(BST!=NULL)
    {   
        while(BST->Right!=NULL)
            BST=BST->Right;
    }   
    return BST;
}
BinTree Insert( BinTree BST, ElementType X )
{
    if(BST==NULL)
    {
        BST=(BinTree)malloc(sizeof(struct TNode));
        if(BST==NULL)
        {   
            exit(EXIT_FAILURE);
        }
        else
        {   
            BST->Data=X;
            BST->Left=BST->Right=NULL;
        }
    }
    else if(X<BST->Data)//如果X比当前结点的小，就去左边找
        BST->Left=Insert(BST->Left,X);
    else if(X>BST->Data)
        BST->Right=Insert(BST->Right,X);
    return BST;
}
BinTree Delete( BinTree BST, ElementType X )
{
    Position record=NULL;
    if(BST==NULL)//如果找到最后，或者刚开始就是空，那就是没找到
    {
        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)//这种情况是找到了，但如果左右结点都不为空
    {
        record=FindMin(BST->Right);//去右子树找到最小值
        BST->Data=record->Data;//拿这个值替换掉要删除的值
        BST->Right=Delete(BST->Right,BST->Data);//再去右子树删这个值，因为它是在原先最>小值的位置，所以它不可能有左儿子。
    }
    else//找到了，但是左右结点有一个为空，或者都是空
    {
        record=BST;//记录要删的结点
        if(BST->Left==NULL)//左为空
            BST=BST->Right;//当前结点指针就指向右值
        else if(BST->Right==NULL)//右为空，当前结点指针就指向左值
            BST=BST->Left;
        free(record);//释放内存
    }
    return BST;
}

Insert

插入完全就是按照规则了，比当前结点大的在右子树，小的在左子树。
在这里插入图片描述

Delete

如果节点是叶子，那么直接删除就可以，如果节点有一个儿子，可以让其父结点绕过其直接指向这个儿子。
在这里插入图片描述
更麻烦的是有两个儿子的结点。我们一般默认是用其右子树中的最小值去替换，然后再去删掉这个原先是最小值的结点。因为最小值，所以其肯定没有左儿子。

#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 );
void f(BinTree BST);/*释放*/

int main(void)
{
    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");

    f(BST);
    return 0;
}
/* 你的代码将被嵌在这里 */
void f(BinTree BST)
{
    if(BST==NULL)
        return ;
    else
    {
        f(BST->Left);
        f(BST->Right);
    }
    free(BST);

}
void PreorderTraversal( BinTree BT )
{
    if(BT==NULL)
        return;
    printf(" %d",BT->Data);
    PreorderTraversal( BT->Left );
    PreorderTraversal( BT->Right );
}
void InorderTraversal( BinTree BT )
{
    if(BT==NULL)
        return;
    InorderTraversal( BT->Left );
    printf(" %d",BT->Data);
    InorderTraversal( BT->Right );
}
Position Find( BinTree BST, ElementType X ) 
{
    if(BST==NULL)
        return NULL;
    if(X<BST->Data)
        return Find(BST->Left,X);
    else if(X>BST->Data)
        return Find(BST->Right,X);
    else
        return BST;
}
Position FindMin( BinTree BST )//尾递归
{
    if(BST==NULL)
        return NULL;
    else if(BST->Left==NULL)
        return BST;
    else
        return FindMin(BST->Left);
}

Position FindMax( BinTree BST )//非递归方法
{
    if(BST!=NULL)
    {   
        while(BST->Right!=NULL)
            BST=BST->Right;
    }   
    return BST;
}
BinTree Insert( BinTree BST, ElementType X )
{
    if(BST==NULL)
    {
        BST=(BinTree)malloc(sizeof(struct TNode));
        if(BST==NULL)
        {   
            exit(EXIT_FAILURE);
        }
        else
        {   
            BST->Data=X;
            BST->Left=BST->Right=NULL;
        }
    }
    else if(X<BST->Data)//如果X比当前结点的小，就去左边找
        BST->Left=Insert(BST->Left,X);
    else if(X>BST->Data)
        BST->Right=Insert(BST->Right,X);
    return BST;
}
BinTree Delete( BinTree BST, ElementType X )
{
    Position record=NULL;
    if(BST==NULL)//如果找到最后，或者刚开始就是空，那就是没找到
    {
        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)//这种情况是找到了，但如果左右结点都不为空
    {
        record=FindMin(BST->Right);//去右子树找到最小值
        BST->Data=record->Data;//拿这个值替换掉要删除的值
        BST->Right=Delete(BST->Right,BST->Data);//再去右子树删这个值，因为它是在原先最>小值的位置，所以它不可能有左儿子。
    }
    else//找到了，但是左右结点有一个为空，或者都是空
    {
        record=BST;//记录要删的结点
        if(BST->Left==NULL)//左为空
            BST=BST->Right;//当前结点指针就指向右值
        else if(BST->Right==NULL)//右为空，当前结点指针就指向左值
            BST=BST->Left;
        free(record);//释放内存
    }
    return BST;
}