二叉搜索树的查找、插入、删除操作

最新推荐文章于 2024-08-24 19:19:23 发布

f-f-g

最新推荐文章于 2024-08-24 19:19:23 发布

阅读量169

点赞数

分类专栏：数据结构-练习集文章标签：算法数据结构 c语言 Powered by 金山文档

本文链接：https://blog.csdn.net/qq_54731568/article/details/129593337

版权

数据结构-练习集专栏收录该内容

37 篇文章 2 订阅

订阅专栏

一、二叉搜索树的链式存储

typedef struct TNode *Position;
typedef Position BinTree;
struct TNode{
    ElementType Data;//结点数据 
    BinTree Left;//指向左子树 
    BinTree Right;//指向右子树 
};

二、查找

1.按值查找

/*----------递归查找-----------*/ 
Position Find(BinTree BST,ElementType X)
{
    if(!BST)return NULL;//查找失败 
    
    if(X>BST->Data )
        return Find(BST->Right ,X);//在右子树中递归查找 
    else if(X<BST->Data )
        return Find(BST->Left ,X);//在左子树中递归查找 
    else
        return BST;//找到了，返回当前结点的地址 
 } 
/*----------迭代查找-----------*/ 
Position Find(BinTree BST,ElementType X)
{
    while(BST){
        if(X>BST->Data )
            BST=BST->Right ;//向右子树中移动，继续查找 
        else if(X<BST->Data )
            BST=BST->Left ;//向左子树中移动，继续查找
        else break; //找到了或者不存在，跳出循环 
    }
    return BST;//返回找到的结点地址或者NULL 
}

2.最大最小元素

/*----------查找最小元素的递归函数-----------*/ 
Position FindMin(BinTree BST)
{
    //最小元素在树的最左端
    if(!BST)return NULL;//空树
    else if(!BST->Left )return BST;//找到了 
    else return FindMin(BST->Left ); //沿着左子树递归查找 
 } 


/*----------查找最大元素的迭代函数-----------*/ 
Position FindMax(BinTree BST)
{
    //最大元素在最右端
    if(BST)
        while(BST->Right )
            BST=BST->Right ;//沿着右子树递归查找 
    return BST; //找到了或者为NULL 
}

三、插入

/*----------插入递归算法-----------*/
BinTree Insert(BinTree BST,ElementType X)
{
    if(!BST){
        //空结点，分配空间并插值 
        BST=(BinTree)malloc(sizeof(struct TNode));
        BST->Data =X;
        BST->Left =BST->Right =NULL; 
    }else {
        //查找要插入的位置 
        if(X<BST->Data )
            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 tmp;
    if(!BST)
        printf("未找到要删除的元素\n");
    else{//查找要删除的结点位置 
        if(X<BST->Data )
            BST->Left =Delete(BST->Left ,X);
        else if(X>BST->Data )
            BST->Right =Delete(BST->Right ,X);
        else{//X=BST->Data,要删除的结点为BST 
            //如果BST有左右两个子结点
            if(BST->Left &&BST->Right ){
                //从左子树中找最大元素来填充删除结点
                tmp=FindMax(BST->Left );
                BST->Data =tmp->Data ;
                //从左子树中删除最大元素 
                BST->Left =Delete(BST->Left ,BST->Data );
            } 
            else{//被删除结点有一个或无子节点 
                tmp=BST;
                if(!BST->Left )//没有左子树（只有右孩子或无子节点） 
                    BST=BST->Right ;
                else //有左子树 
                    BST=BST->Left ;
                free(tmp); 
            }
        }
    }
    return BST;
}

无、完整代码：

//二次搜索树
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>

#define NoInfo 0

typedef int ElementType;
//二叉树链式存储 
typedef struct TNode *Position;
typedef Position BinTree;
struct TNode{
    ElementType Data;//结点数据 
    BinTree Left;//指向左子树 
    BinTree Right;//指向右子树 
}; 

/*----------递归查找-----------*/ 
Position Find(BinTree BST,ElementType X)
{
    if(!BST)return NULL;//查找失败 
    
    if(X>BST->Data )
        return Find(BST->Right ,X);//在右子树中递归查找 
    else if(X<BST->Data )
        return Find(BST->Left ,X);//在左子树中递归查找 
    else
        return BST;//找到了，返回当前结点的地址 
 } 
 
/*----------迭代查找-----------*/ 
//Position Find(BinTree BST,ElementType X)
//{
//    while(BST){
//        if(X>BST->Data )
//            BST=BST->Right ;//向右子树中移动，继续查找 
//        else if(X<BST->Data )
//            BST=BST->Left ;//向左子树中移动，继续查找
//        else break; //找到了或者不存在，跳出循环 
//    }
//    return BST;//返回找到的结点地址或者NULL 
//}

/*----------查找最小元素的递归函数-----------*/ 
Position FindMin(BinTree BST)
{
    //最小元素在树的最左端
    if(!BST)return NULL;//空树
    else if(!BST->Left )return BST;//找到了 
    else return FindMin(BST->Left ); //沿着左子树递归查找 
 } 


/*----------查找最大元素的迭代函数-----------*/ 
Position FindMax(BinTree BST)
{
    //最大元素在最右端
    if(BST)
        while(BST->Right )
            BST=BST->Right ;//沿着右子树递归查找 
    return BST; //找到了或者为NULL 
}



/*----------插入递归算法-----------*/
BinTree Insert(BinTree BST,ElementType X)
{
    if(!BST){
        //空结点，分配空间并插值 
        BST=(BinTree)malloc(sizeof(struct TNode));
        BST->Data =X;
        BST->Left =BST->Right =NULL; 
    }else {
        //查找要插入的位置 
        if(X<BST->Data )
            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 tmp;
    if(!BST)
        printf("未找到要删除的元素\n");
    else{//查找要删除的结点位置 
        if(X<BST->Data )
            BST->Left =Delete(BST->Left ,X);
        else if(X>BST->Data )
            BST->Right =Delete(BST->Right ,X);
        else{//X=BST->Data,要删除的结点为BST 
            //如果BST有左右两个子结点
            if(BST->Left &&BST->Right ){
                //从左子树中找最大元素来填充删除结点
                tmp=FindMax(BST->Left );
                BST->Data =tmp->Data ;
                //从左子树中删除最大元素 
                BST->Left =Delete(BST->Left ,BST->Data );
            } 
            else{//被删除结点有一个或无子节点 
                tmp=BST;
                if(!BST->Left )//没有左子树（只有右孩子或无子节点） 
                    BST=BST->Right ;
                else //有左子树 
                    BST=BST->Left ;
                free(tmp); 
            }
        }
    }
    return BST;
}
//先序遍历 
void PreorderTraversal(BinTree BT)
{
    if(BT){
        printf("%d ",BT->Data );
        PreorderTraversal(BT->Left );
        PreorderTraversal(BT->Right );
    } 
}
//求二叉树的高度
int GetHeight(BinTree BST)
{
    int HL,HR,MaxH;
    if(BST){
        HL=GetHeight(BST->Left );//左子树的高度 
        HR=GetHeight(BST->Right );//右子树的高度 
        MaxH = HL>HR ? HL : HR;
        return (MaxH+1);//返回树的高度 
    }
    else return 0;//空树高度为0 
 } 

void PrintResult(BinTree BST)
{
    int height=GetHeight( BST);
    printf("树的高度为:%d\n",height);
    printf("先序遍历：");
    PreorderTraversal(BST);
    printf("\n");
}

int main()
{
    BinTree BST=NULL,T=NULL;
        
    //插入 
    ElementType X;
    printf("请输入根结点："); 
    scanf("%d",&X);
    BST=Insert(BST ,X);
    T=BST; //记录根节点 
    printf("请输入6个需要插入的元素：");
    int i=0;
    for(i=0;i<6;i++){
        scanf("%d",&X);
        BST=Insert(T ,X);
    }
    PrintResult(BST); 
    
    printf("BST=%d\n",BST->Data  );
    Position p;
    p= FindMin(BST);
    printf("最小元素为:%d\n",p->Data );
    p= FindMax(BST );
    printf("最大元素为:%d\n",p->Data );
    
    //删除
    printf("请输入需要删除的元素：");
    scanf("%d",&X);
    BST=Delete(T,X);
    PrintResult(BST);
    
    return 0;
 }

运行：