二叉查找树

最新推荐文章于 2024-08-16 21:27:26 发布
最新推荐文章于 2024-08-16 21:27:26 发布
阅读量261 收藏 1
点赞数
分类专栏： 数据结构 文章标签： 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45815991/article/details/111870599
版权

二叉查找树

对于树中的每个结点X，它的左子树中所有关键字值小于X的关键字值，而它的右子树中所有关键字值 大于X的关键字值 。

头文件head.h

#ifndef HEAD_H
#define HEAD_H

typedef int ElementType;
typedef struct node* SearchTree;

typedef struct node
{
    ElementType data;
    SearchTree Left;
    SearchTree Right;
}TreeNode;

//清空二叉查找树
SearchTree MakeEmpty(SearchTree T);

//找元素
SearchTree Find(ElementType X, SearchTree T);

//找到最小值 
SearchTree FindMin(SearchTree T);

//找到最大值 
SearchTree FindMax(SearchTree T);

//插入元素
SearchTree Insert(ElementType X, SearchTree T);

//删除元素
SearchTree Delete(ElementType X, SearchTree T);

//中序遍历
void InOrderTree(SearchTree T);

//前序遍历
void PreOrderTree(SearchTree T);

//清除缓冲区
void clean(void);

#endif

二叉查找树的初始化MakeEmpty

与普通的二叉树清空相同。

SearchTree MakeEmpty(SearchTree T)
{
    if (T != NULL)
    {
        MakeEmpty(T->Left);
        MakeEmpty(T->Right);
        free(T);
    }
    return NULL;
}

找到相应的元素Find

/*
 * 函数名：Find
 * 功能：在二叉树找到相应的元素
 * 参数：
 *       X：被查找元素
 *       T：要查找的二叉树
 * 返回值：
 *       找到：返回查找元素结点指针
 *       未找到：返回NULL
 */
SearchTree Find(ElementType X, SearchTree T)
{
    if (T == NULL)
    {
        return NULL;
    }
    else if (X < T->data)
    {
        return Find(X, T->Left);
    }
    else if (X > T->data)
    {
        return Find(X, T->Right);
    }
    else
    {
        return T;
    }
}

找到最小值FindMin

/*
 * 函数名：FindMin
 * 功能：找到二叉查找树中最小元素
 * 参数：
 *      T：二叉树根结点指针
 * 返回值：
 *      空树：返回NULL
 *      非空树：返回最左子树
 */
SearchTree FindMin(SearchTree T)
{
    if (T != NULL)
    {
        while(T->Left)
        {
            T = T->Left;
        }
    }
    return T;
}

同理找到最大元素FindMax

/*
 * 函数名：FindMax
 * 功能：找到二叉查找树中最大元素
 * 参数：
 *      T：二叉树根结点指针
 * 返回值：
 *      空树：返回NULL
 *      非空树：返回最右子树
 */
SearchTree FindMax(SearchTree T)
{
    if (T != NULL)
    {
        while(T->Right)
        {
            T = T->Right;
        }
    }
    return T;
}

插入元素Insert

/*
 * 函数名：Insert
 * 功能：在查找二叉树中插入相应元素（如果有重复的元素就不插入）
 * 参数：
 *      X：要插入的元素
 *      T：二叉树根结点指针
 * 返回值：
 *      插入完成后的二叉树根结点指针
 */
SearchTree Insert(ElementType X, SearchTree T)
{
    if (T == NULL)
    {
        T = (SearchTree)malloc(sizeof(TreeNode));
        if (T == NULL)
        {
            fprintf(stderr, "out of space!\n");
            exit(EXIT_FAILURE);
        }
        T->data = X;
        T->Left = NULL;
        T->Right= NULL;
        return T;
    }
    else if (X < T->data)
    {
        // 如果插入元素小于当前结点，就去它的左子树插入。
        // 注意返回值要给左子树的指针，因为插入后是一棵新树
        T->Left = Insert(X, T->Left); 
    }
    else if (X > T->data)
    {
        T->Right = Insert(X, T->Right);
    }
    else// 如果当前结点元素就是X，直接返回当前结点
    {
        return T;
    }
}

删除元素Delete

最麻烦的就是删除。

  1. 如果结点是一片树叶，那么可以产即删除。
  2. 如果结点有一个儿子，则该结点可以在其父结点调整指针绕过该结点后删除。

在这里插入图片描述

如果要删除4元素代表的结点，应该为：
在这里插入图片描述

  1. 如果要删除的结点有两个儿子，如果删除这个结点就会非常的麻烦。可以转换为删除只有一个儿子的结点的方法。
    一般方法是用其右子树的最小结点中的值覆盖这个结点的值（因为右树元素必大于当前结点元素，所以必大于当前结点的左树元素，而右树最小元素保证了其小于右树所有元素，满足当前结点元素大于所有左树元素小于所有右树元素的条件）再去删除右子树的最小元素的结点。

在这里插入图片描述

如果想要删除2所在元素的结点。可以找到其右子树最小值3，把3赋给2所在结点，再删除3这个结点。
在这里插入图片描述

/*
 * 函数名：Delete
 * 功能：删除相对应元素的位置
 * 参数：
 *      X：要删除的元素
 *      T：二叉查找树根结点指针
 * 返回值：删除结点后的树，其根结点指针
 */
SearchTree Delete(ElementType X, SearchTree T)
{
    SearchTree temp;
    //1. 如果树为空
    if (T == NULL)
    {
        printf("The tree haven't data!\n");
    }
    // 找到X的位置
    else if (X < T->data)
    {
        T->Left = Delete(X, T->Left);
    }
    else if (X > T->data)
    {
        T->Right = Delete(X, T->Right);
    }
    //如果X所在结点有两个儿子
    else if (T->Left && T->Right)
    {
        temp = FindMin(T->Right); //找到右树最小元素
        T->data = temp->data; //将右树最小元素赋结当前结点
        //重新构造右子树
        T->Right = Delete(T->data, T->Right); //递归的删除右树最小元素
    }
    //如果X所在结点小于两个儿子
    else
    {
        temp = T;
        if (T->Left == NULL)//这里也包含了左右树同时为空的情况
        {
            //T指向存在的儿子，因为递归。
            //后面返回会的给到其父亲的左儿子或者右儿子指针
            T = T->Right; 
        }
        else if (T->Right == NULL)
        {
            T = T->Left;
        }
        printf("删除的元素为%d\n", temp->data);
        free(temp);
    }
    //删除完毕
    return T; 
}

操作集operation.c

#include "head.h"
#include <stdio.h>
#include <stdlib.h>

//清空二叉查找树
SearchTree MakeEmpty(SearchTree T)
{
    if (T != NULL)
    {
        MakeEmpty(T->Left);
        MakeEmpty(T->Right);
        free(T);
    }
    return NULL;
}

/*
 * 函数名：Find
 * 功能：在二叉树找到相应的元素
 * 参数：
 *       X：被查找元素
 *       T：要查找的二叉树
 * 返回值：
 *       找到：返回查找元素结点指针
 *       未找到：返回NULL
 */
SearchTree Find(ElementType X, SearchTree T)
{
    if (T == NULL)
    {
        return NULL;
    }
    else if (X < T->data)
    {
        return Find(X, T->Left);
    }
    else if (X > T->data)
    {
        return Find(X, T->Right);
    }
    else
    {
        return T;
    }
}

/*
 * 函数名：FindMin
 * 功能：找到二叉查找树中最小元素
 * 参数：
 *      T：二叉树根结点指针
 * 返回值：
 *      空树：返回NULL
 *      非空树：返回最左子树
 */
SearchTree FindMin(SearchTree T)
{
    if (T != NULL)
    {
        while(T->Left)
        {
            T = T->Left;
        }
    }
    return T;
}
/*
 * 函数名：FindMax
 * 功能：找到二叉查找树中最大元素
 * 参数：
 *      T：二叉树根结点指针
 * 返回值：
 *      空树：返回NULL
 *      非空树：返回最右子树
 */
SearchTree FindMax(SearchTree T)
{
    if (T != NULL)
    {
        while(T->Right)
        {
            T = T->Right;
        }
    }
    return T;
}
/*
 * 函数名：Insert
 * 功能：在查找二叉树中插入相应元素（如果有重复的元素就不插入）
 * 参数：
 *      X：要插入的元素
 *      T：二叉树根结点指针
 * 返回值：
 *      插入完成后的二叉树根结点指针
 */
SearchTree Insert(ElementType X, SearchTree T)
{
    if (T == NULL)
    {
        T = (SearchTree)malloc(sizeof(TreeNode));
        if (T == NULL)
        {
            fprintf(stderr, "out of space!\n");
            exit(EXIT_FAILURE);
        }
        T->data = X;
        T->Left = NULL;
        T->Right= NULL;
        return T;
    }
    else if (X < T->data)
    {
        // 如果插入元素小于当前结点，就去它的左子树插入。
        // 注意返回值要给左子树的指针，因为插入后是一棵新树
        T->Left = Insert(X, T->Left); 
    }
    else if (X > T->data)
    {
        T->Right = Insert(X, T->Right);
    }
    else// 如果当前结点元素就是X，直接返回当前结点
    {
        return T;
    }
}
/*
 * 函数名：Delete
 * 功能：删除相对应元素的位置
 * 参数：
 *      X：要删除的元素
 *      T：二叉查找树根结点指针
 * 返回值：删除结点后的树，其根结点指针
 */
SearchTree Delete(ElementType X, SearchTree T)
{
    SearchTree temp;
    //1. 如果树为空
    if (T == NULL)
    {
        printf("The tree haven't data!\n");
    }
    // 找到X的位置
    else if (X < T->data)
    {
        T->Left = Delete(X, T->Left);
    }
    else if (X > T->data)
    {
        T->Right = Delete(X, T->Right);
    }
    //如果X所在结点有两个儿子
    else if (T->Left && T->Right)
    {
        temp = FindMin(T->Right); //找到右树最小元素
        T->data = temp->data; //将右树最小元素赋结当前结点
        //重新构造右子树
        T->Right = Delete(T->data, T->Right); //递归的删除右树最小元素
    }
    //如果X所在结点小于两个儿子
    else
    {
        temp = T;
        if (T->Left == NULL)//这里也包含了左右树同时为空的情况
        {
            //T指向存在的儿子，因为递归。
            //后面返回会的给到其父亲的左儿子或者右儿子指针
            T = T->Right; 
        }
        else if (T->Right == NULL)
        {
            T = T->Left;
        }
        printf("删除的元素为%d\n", temp->data);
        free(temp);
    }
    //删除完毕
    return T; 
}

//中序遍历
void InOrderTree(SearchTree T)
{
    if (T == NULL)
    {
        printf("#");
        return ;
    }
    InOrderTree(T->Left);
    printf("%d ", T->data);
    InOrderTree(T->Right);
}
//前序遍历
void PreOrderTree(SearchTree T)
{
    if (T == NULL)
    {
        printf("#");
        return ;
    }
    printf("%d ", T->data);
    PreOrderTree(T->Left);
    PreOrderTree(T->Right);
}
//清除缓冲区
void clean(void)
{
    while(getchar() != '\n')
        continue;
}

主函数main.c

#include <stdio.h>
#include <stdlib.h>
#include "head.h"

int main(void)
{
    ElementType data;
    SearchTree T = NULL;
    while (scanf("%d", &data))//输入元素，直到非数字
    {
        T = Insert(data, T);
    }
    //前序遍历
    PreOrderTree(T);
    printf("\n");
    //中序遍历
    InOrderTree(T);
    printf("\n");

    clean();
    printf("输入你要查找的元素:");
    scanf("%d", &data);
    SearchTree record = Find(data, T);
    printf("元素为%d\n", record->data);

    clean();
    printf("输入你要删除的元素:");
    scanf("%d", &data);
    Delete(data, T);
    
    PreOrderTree(T);
    printf("\n");
    InOrderTree(T);
    printf("\n");
    
	//清空
    T = MakeEmpty(T);
    
    PreOrderTree(T);
    printf("\n");
    InOrderTree(T);
    printf("\n");

    return 0;
}

在这里插入图片描述
在这里插入图片描述

改进

    //如果X所在结点有两个儿子
    else if (T->Left && T->Right)
    {
        temp = FindMin(T->Right); //找到右树最小元素
        T->data = temp->data; //将右树最小元素赋结当前结点
        //重新构造右子树
        T->Right = Delete(T->data, T->Right); //递归的删除右树最小元素
    }

这段代码中，FindMin查找最小元素遍历了一次，Delte又遍历了一次，会浪费很多时间，可以写一个DeleteMin代替。

/*
 * 函数名：DeleteMin
 * 功能：删除给定树右子树中最小元素
 * 参数：T：树根指针
 * 返回值：最小元素的值
 */
ElementType DeleteMin(SearchTree T)
{
    SearchTree record = T; //用于记录前一个结点指针
    ElementType temp; //保存返回值
    T = T->Right; //到右子树
    if (T == NULL)//根据Delete，当T的左右都存在时，才调用此函数。故T不可能为NULL
    {
        fprintf(stdout, "error!\n");
        exit(EXIT_FAILURE);
    }
    while(T->Left) //这里就可以看作单链表了（因为没有右结点什么事）
    {
        record = T;
        T = T->Left;
    }
    record->Left = T->Right; //前一个结点指针，指向其右结点，因为左结点必为空
    temp = T->data; //获取最小值
    free(T);
    return temp;
}

操作集operation.c

SearchTree Delete(ElementType X, SearchTree T)
{
    SearchTree temp;
    //1. 如果树为空
    if (T == NULL)
    {
        printf("The tree haven't data!\n");
    }
    // 找到X的位置
    else if (X < T->data)
    {
        T->Left = Delete(X, T->Left);
    }
    else if (X > T->data)
    {
        T->Right = Delete(X, T->Right);
    }
    //如果X所在结点有两个儿子
    else if (T->Left && T->Right)
    {
    /*
        temp = FindMin(T->Right);
        T->data = temp->data;
        T->Right = Delete(temp->data, T->Right);
    */
        T->data = DeleteMin(T); //调用DeleteMin
    }
    //如果X所在结点小于两个儿子
    else
    {
        temp = T;
        if (T->Left == NULL)//这里也包含了左右树同时为空的情况
        {
            //T指向存在的儿子，因为递归。
            //后面返回会的给到其父亲的左儿子或者右儿子指针
            T = T->Right; 
        }
        else if (T->Right == NULL)
        {
            T = T->Left;
        }
        printf("删除的元素为%d\n", temp->data);
        free(temp);
    }
    //删除完毕
    return T; 
}

记得在头文件中加上DeleteMin。
在这里插入图片描述
两次运行结果一致。结果中删除的元素指得当然是右子树的最小结点上的元素。
在这里插入图片描述
可见是3。

CCPigSnail
关注
专栏目录
二叉树-二叉查找树
编程使我快乐
06-15 791
1.树 1.1 有关树的易混概念
二叉查找树 减治法——C++代码
05-24
二叉查找树（Binary Search Tree，BST）是一种特殊的二叉树数据结构，它的每个节点都包含一个键（key）、一个关联的值、一个指向左子树的引用和一个指向右子树的引用。在二叉查找树中，对于任意节点，其左子树中的...
二叉搜索树(Binary Search Tree)
最新发布
cookies_s_的博客
08-16 1108
二叉搜索树实现
二叉查找树与平衡二叉树
热门推荐
金发只是水一下的博客
08-29 8万+
二叉查找树 　　二叉查找树，也称二叉搜索树，或二叉排序树。其定义也比较简单，要么是一颗空树，要么就是具有如下性质的二叉树： （1）若任意节点的左子树不空，则左子树上所有结点的值均小于它的根结点的值； （2） 若任意节点的右子树不空，则右子树上所有结点的值均大于它的根结点的值； （3） 任意节点的左、右子树也分别为二叉查找树； （4） 没有键值相等的节点。 　　如上图所示，是不同形态...
二叉查找树python二叉查找树源码
11-22
二叉查找树（Binary Search Tree，BST），也称为二叉排序树，是一种特殊的二叉树数据结构。它的每个节点都包含一个键（key）、一个关联的值、一个指向左子节点的指针和一个指向右子节点的指针。在二叉查找树中，对于...
JS实现二叉查找树的建立以及一些遍历方法实现
10-20
在计算机科学中，二叉查找树（BST）是一种特殊的二叉树结构，它满足所有节点的左子树都小于该节点，所有节点的右子树都大于该节点。这种特性使得二叉查找树在查找、插入和删除元素时可以提供很高的效率。本文将详细...
最优二叉查找树 动态规划法.cpp.rar
10-14
最优二叉查找树（Optimal Binary Search Tree, OBST）是一种高效的检索数据结构，它根据键值分布的不同，自适应地调整树的形态以达到最小化查找时间的目的。在计算机科学中，动态规划（Dynamic Programming, DP）是...
二叉查找树（BST）
m0_50710793的博客
11-01 413
二叉查找树的定义 二叉查找树：是一种特殊的二叉树，又叫排序二叉树，二叉排序树，二叉搜索树等等。 具体定义如下： 要么二叉查找树是一棵空树 要么二叉查找树由根结点、左子树、右子树组成，其中左子树和右子树都是二叉查找树，且左子树上所有结点的数据域均小于根结点的数据域，右子树上所有结点的数据域均大于根结点的数据域～ （左<根<右） 二叉查找树的基本操作（查找、插入、建树、删除） 搜索基本思路： 1. 如果当前根结点为root，那么查找失败，返回～ 2. 如果要查找的值等于当前根结点的数据域，说明查
二叉查找树(Binary Search Tree)
WeiJun的专栏
07-19 767
二叉查找树（英语：Binary Search Tree），也称二叉搜索树、有序二叉树（英语：ordered binary tree），排序二叉树（英语：sorted binary tree），是指一棵空树或者具有下列性质的二叉树： 若任意节点的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若任意节点的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 任意节
java 如何卸载qq_java二叉树删除如何操作？
weixin_28946193的博客
02-16 147
今天所讲的是二叉树的删除，小伙伴们点进来，肯定是对二叉树有说了解的吧啊，首先学习二叉树删除，建议先了解诶二叉树的建立，遍历，插入和查找，以便小伙伴们能够很好的掌握今天小编所讲的内容，接下来让我们一起来了解下吧。二叉树的删除操作是比较复杂的。首先要找到删除的节点。要删除的结点对象并不一定要进行删除操作。因为通过函数调用得到的只是他的副本。并不会真正的把他删掉。你只要让他不在树上就行了。让删除结点的父...
Java二叉查找树的实现代码详解
Java二叉查找树的实现代码 Java二叉查找树是一种常用的数据结构，它能够高效地存储和检索数据。在本文中，我们将详细地介绍Java二叉查找树的实现代码，并对其进行详细的解释。 一、Java二叉查找树的定义 Java二叉...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

CCPigSnail

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值