二叉搜索树

最新推荐文章于 2024-04-28 15:50:37 发布
最新推荐文章于 2024-04-28 15:50:37 发布
阅读量2.4k 收藏 34
点赞数 8
分类专栏： 【编程之美】 数据结构与算法 文章标签： 递归 二叉树 排序 搜索树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014634338/article/details/39102739
版权

二叉搜索树（Binary Sort Tree）又称二叉查找树（Binary Search Tree），亦称二叉排序树。 它或者是一棵空树；或者是具有下列性质的二叉树： 

（1）若左子树不空，则左子树上所有结点的值均小于它的根结点的值； 

（2）若右子树不空，则右子树上所有结点的值均大于它的根结点的值； 

（3）左、右子树也分别为二叉排序树；



二叉搜索树的结构：

typedef struct BiTNode
{
    int data;        //结点数据
    struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;

二叉搜索树的插入（建立）操作： 

BiTree Insert(BiTree &T,int key)   //插入关键字等于key的数据元素
{
    if(T==NULL)   //插入位置
    {
        T=(BiTree)malloc(sizeof(BiTNode));
        T->data=key;
        T->lchild=T->rchild=NULL;
    }
    else if(T->data>key)
    {
        T->lchild=Insert(T->lchild, key);   //在左子树插入
    }
    else if(T->data<key)
    {
        T->rchild=Insert(T->rchild, key);  //在右子树插入
    }
    return T;   //存在改关键字
}
二叉搜索树的查找操作： 

BiTree Find(BiTree T,int key)  //递归查找二叉排序树中是否存在key
{
    if(T==NULL)   //查找不成功
    {
        return NULL;
    }
    if(key<T->data)
    {
         return Find(T->lchild, key);//在左子树继续查找
    }
    else if(key>T->data)
    {
        return Find(T->rchild, key);   //在右子树继续查找
    }
    else   //查找成功
    {
        return T;
    }
}
二叉搜索树的最小元素与最大元素位置： 

BiTree FindMin(BiTree T)  //在排序树中找最小值
{
    if(T==NULL)
    {
        return NULL;
    }
    else if(T->lchild==NULL)  //找到了
    {
        return T;
    }
    else
    {
        return FindMin(T->lchild);  //一直递归左子树找最小的
    }
}
BiTree FindMax(BiTree T)  //在排序树中找最大值
{
    if(T==NULL)
    {
        return NULL;
    }
    else if(T->rchild==NULL)
    {
        return T;
    }
    else
    {
        return FindMax(T->rchild);
    }
}

二叉搜索树的删除操作：


如果要删除37，51，73，93这些在二叉搜索树中是叶子的结点，那是很容易的，对于要删除的结点只有左子树，或只有右子树的情况，相对也是比较好解决的，那就是结点删除后，将它的左或者右子树整个移到删除结点的位置就可以了，

但是对于要删除的结点既有左子树又有右子树的情况怎么办呢，它们的子子孙孙怎么办呢？


开始的想法，我们当47结点只有一个左子树，那么做法和一个左子树的操作一样，让35及它之下的结点成为58的左子树，然后再对47的右子树所有结点进行插入操作，


这样么效率不高，而且二叉排序树的结构会发生很大变化，有可能增加树的高度，对后续查找会造成影响换一个方法



接下来看代码：

Status DeleteBST(BiTree &T,int key)//删除关键字等于key的数据元素
{
    if(T==NULL) //不存在
    {
        return 0;
    }
    else if(T->data==key)
    {
        return Delete(T);   //找到了
    }
    else if(T->data>key)
    {
        return DeleteBST(T->lchild, key);  //在左子树查找删除
    }
    else
    {
        return DeleteBST(T->rchild, key);  //在右子树查找删除
    }
}


Status Delete(BiTree &p)//删除结点p,并重接它的左或者右子树
{
    BiTree q,s;
    if(p->rchild==NULL)   //只存在左子树
    {
        q=p;
        p=p->lchild;
        free(q);
    }
    else if(p->lchild==NULL)  //只存在右子树
    {
        q=p;
        p=p->rchild;
        free(q);
    }
    else   //左右子树都存在
    {
        q=p;
        s=p->lchild;   //转左，然后向右到尽头（找待删除结点的前驱）
        while (s->rchild)
        {
            q=s;
            s=s->rchild;
        }
        p->data=s->data;
        if(q!=p)
        {
            q->rchild=s->lchild;   //重接q的右子树
        }
        else
        {
            q->lchild=s->lchild;  //重接q的左子树
        }
        free(s);
    }
    return 1;
}

对于删除具有左右孩子的做法感觉似乎有点麻烦，有没有简单的做法呢，答案是肯定有的，我们只需要把复杂的操作转移一下就可以了，我们不再重接左右子树，而是找到该结点左子树的最大结点或者右子树最小结点后，用其值代替要删除掉的结点，然后删除掉要删除节点的左子树的最大结点或者右子树最小结点，例如，删除47，我们找到左子树的最大结点37，然后把47改成37，删除原37那个结点，这样都转换成简单操作了。代码如下：

bool Delete2(BiTree &T,int key)
{
    if (T==NULL)
    {
        return false;
    }
    else if (T->data<key)  //在该结点右子树查找结点key
    {
        return Delete2(T->rchild,key);
    }
    else if(T->data>key)  //在该结点左子树查找结点key
    {
        return Delete2(T->lchild, key);
    }
    else  //找到了
    {
        if (T->lchild && T->rchild) //同时有左右子树
        {
            BiTree temp=FindMax(T->lchild); //找左子树最大的值
            T->data=temp->data; //用左子树最大的值代替要删除结点的值
            return Delete2(T->lchild,temp->data); //删除左子树最大值所对应的结点
        }
        else
        {
            if (!T->lchild) //只左孩子为空
            {
                T=T->rchild;
            }
            else if(!T->rchild) //只右孩子为空
            {
                T=T->lchild;
            }
            return true;
        }
    }
}


总程序参看代码：

#include <stdio.h>
#include <stdlib.h>
typedef struct BiTNode
{
    int data;        //结点数据
    struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;
BiTree Find(BiTree T,int key)  //递归查找二叉排序树中是否存在key
{
    if(T==NULL)   //查找不成功
        return NULL;
    if(key<T->data)
        return Find(T->lchild, key);//在左子树继续查找
    else if(key>T->data)
        return Find(T->rchild, key);   //在右子树继续查找
    else   //查找成功
        return T;
}
bool Insert(BiTree &T,int key)   //插入关键字等于key的数据元素
{
    if(T==NULL)   //插入位置
    {
        T=(BiTree)malloc(sizeof(BiTNode));
        T->data=key;
        T->lchild=T->rchild=NULL;
        return true;
    }
    else if(T->data>key)
        return Insert(T->lchild, key);   //在左子树插入
    else if(T->data<key)
        return Insert(T->rchild, key);  //在右子树插入
    return false;   //存在改关键字
}
BiTree FindMin(BiTree T)  //在排序树中找最小值
{
    if(T==NULL)
        return NULL;
    else if(T->lchild==NULL)  //找到了
        return T;
    else
        return FindMin(T->lchild);  //一直递归左子树找最小的
}
BiTree FindMax(BiTree T)  //在排序树中找最大值
{
    if(T==NULL)
        return NULL;
    else if(T->rchild==NULL)
        return T;
    else
        return FindMax(T->rchild);
}
bool Delete(BiTree &p)//删除结点p,并重接它的左或者右子树
{
    BiTree q,s;
    if(p->rchild==NULL)   //只存在左子树
    {
        q=p;
        p=p->lchild;
        free(q);
        return true;
    }
    else if(p->lchild==NULL)  //只存在右子树
    {
        q=p;
        p=p->rchild;
        free(q);
        return true;
    }
    else   //左右子树都存在
    {
        q=p;
        s=p->lchild;   //转左，然后向右到尽头（找待删除结点的前驱）
        while (s->rchild)
        {
            q=s;
            s=s->rchild;
        }
        p->data=s->data;
        if(q!=p)
        {
            q->rchild=s->lchild;   //重接q的右子树
        }
        else
        {
            q->lchild=s->lchild;  //重接q的左子树
        }
        free(s);
        return true;
    }
}
bool DeleteBST(BiTree &T,int key)//删除关键字等于key的数据元素
{
    if(T==NULL) //不存在
        return false;
    else if(T->data==key)
        return Delete(T);   //找到了
    else if(T->data>key)
        return DeleteBST(T->lchild, key);  //在左子树查找删除
    else
        return DeleteBST(T->rchild, key);  //在右子树查找删除
}
bool Delete2(BiTree &T,int key)
{
    if (T==NULL)
        return false;
    else if (T->data<key)  //在该结点右子树查找结点key
        return Delete2(T->rchild,key);
    else if(T->data>key)  //在该结点左子树查找结点key
        return Delete2(T->lchild, key);
    else  //找到了
    {
        if (T->lchild && T->rchild) //同时有左右子树
        {
            BiTree temp=FindMax(T->lchild); //找左子树最大的值
            T->data=temp->data; //用左子树最大的值代替要删除结点的值
            return Delete2(T->lchild,temp->data); //删除左子树最大值所对应的结点
        }
        else
        {
            if (!T->lchild) //只左孩子为空
                T=T->rchild;
            else if(!T->rchild) //只右孩子为空
                T=T->lchild;
            return true;
        }
    }
}
void PreOrderTraverse(BiTree T)   //递归前序
{
    if(T==NULL)
        return;
    printf("%d ",T->data);
    PreOrderTraverse(T->lchild);
    PreOrderTraverse(T->rchild);
}

int main()
{
    BiTree T=NULL;
    int n;
    scanf("%d",&n);
    for (int i=0; i<n; i++)
    {
        int key;
        scanf("%d",&key);
        Insert(T, key);
    }
    printf("删除前前序序列:\n");
    PreOrderTraverse(T);
    BiTree Min,Max;
    Min=FindMin(T);
    Max=FindMax(T);
    printf("Min:%d\n",Min->data);
    printf("Min:%d\n",Max->data);
    DeleteBST(T, 47);
    Delete2(T, 37);
    printf("删除前前序序列:\n");
    PreOrderTraverse(T);
    return 0;
}
//16
//62 58 88 47 73 99 35 51 93 29 37 49 56 36 48 50



zthgreat
关注
  • 8
    点赞
  • 踩
  • 34
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
二叉搜索树实例练习
09-05
二叉搜索树（Binary Search Tree，BST），是一种特殊的二叉树结构，它的每个节点都包含一个键（key）、一个关联的值、一个指向左子树的引用和一个指向右子树的引用。在二叉搜索树中，对于任意节点： 1. 节点的左...
Java创建二叉搜索树,实现搜索,插入,删除的操作实例
08-28
Java 创建二叉搜索树、实现搜索、插入、删除的操作实例 Java 创建二叉搜索树是指通过 Java 语言实现一个二叉搜索树数据结构，该树具有查找、插入、删除等操作的功能。二叉搜索树是一种特殊的二叉树，每个节点的值...
二叉排序树（二叉查找树、二叉搜索树）（图解+完整代码）
热门推荐
weixin_54186646的博客
04-25 8万+
图解二叉排序树（二叉查找树、二叉搜索树）的插入操作、查找操作、删除操作以及完整的代码实现
【二叉搜索树】二叉搜索树的用法以及实现
最新发布
m0_68617301的博客
04-28 1114
二叉搜索树的用法以及实现
【Java 数据结构】实现一个二叉搜索树
程序猿教你打篮球的博客
01-09 6928
本期主要讲解： 1、认识二叉搜索树 2、实现一个二叉搜索树 2.1 成员变量 2.2 insert 方法 2.3 search 方法 2.4 remove 方法(重点) 3、二叉搜索树总结
二叉搜索树详解
拂晓123的博客
06-17 5829
写在前面        本文主要分为三个部分。        第一部分介绍了二叉搜索树的基本性质。        第二部分全面详细地讲述了二叉搜索树的各种基本操作...
java二叉搜索树详解
m0_57180439的博客
02-21 2098
文章目录一、概念二、相关操作1.查找2.插入2.删除实现 提示：以下是本篇文章正文内容，下面案例可供参考 一、概念 二叉搜索树又称二叉排序树 它或者是一棵空树，或者是具有以下性质的二叉树: 1.若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 2.若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 3.它的左右子树也分别为二叉搜索树 （图片来自比特就业课） 二、相关操作 1.查找 （图片来自比特就业课） 代码如下（示例）： 2.插入 代码如下（示例）： 2.删除 实现 ....
二叉搜索树(二叉排序树)
爱敲代码的三毛的博客
09-09 4万+
一.概念 二叉搜索树又称二叉排序树，具有以下性质： 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 它的左右子树也分别为二叉搜索树 注意：二叉搜索树中序遍历的结果是有序的 二、基本操作 1.查找元素 思路：二叉搜索树的左子树永远是比根节点小的，而它的右子树则都是比根节点大的值。当前节点比要找的大就往左走，当前元素比要找的小就往右走 public Node search(int key) { if(root ==
判断二叉树是否为二叉搜索树
明朗晨光的专栏
07-01 5751
利用二叉树递归套路判断是否为二叉搜索树
二叉搜索树（BinarySearchTree）
潜心钻研技术
03-05 1493
二叉搜索树（BinarySearchTree） 文章目录二叉搜索树（BinarySearchTree）二叉搜索树的概念如何定义 二叉搜索树的节点 && 二叉搜索树查找插入删除二叉搜索树的缺点二叉搜索树的应用 二叉搜索树的概念 搜索二叉树满足一下条件： 是一棵二叉树 这可树上的任意一个节点满足：若他的右子树不为空，则右子树上的所有节点的值大于该节点的值 这可树上的任意一个节点满足：若他的左子树不为空，则左子树上的所有节点的值小于该节点的值 它的的左子树和右子树也是二叉搜索树 例如下图就是一
二叉搜索树代码实现
weixin_66404215的博客
01-29 1633
二叉搜索树代码实现
Java二叉搜索树
m0_64318128的博客
11-05 1416
二叉搜索树的概念、性质，二叉搜索树的实现
树-98. 验证二叉搜索树-PYTHON
01-20
在二叉搜索树（Binary Search Tree，BST）中，每个节点的值必须满足以下规则：对于任意节点，其左子树中的所有节点的值都小于该节点的值，而其右子树中的所有节点的值都大于该节点的值。在给定的题目“树-98. 验证...
java实现 二叉搜索树功能
08-27
Java 实现二叉搜索树功能 二叉搜索树是一种特殊的二叉树，它的每个节点都含有一个Comparable的键值，且所有的键值都是唯一的，节点的键值也可以是基本类型，如int、long等，也可以是自定义的对象类型，只要实现了...
平衡二叉树（AVL）图解与实现
小张的专栏
10-31 6万+
个人技术博客：http://blog.ztgreat.cn 平衡二叉树（Balanced BinaryTree）又被称为AVL树。它具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。   平衡二叉树一般是一个有序树，它具有二叉树的所有性质，其遍历操作和二叉树的遍历操作相同。但是由于其对二叉树施加了额外限制，因而其添加、删除操作都必须...
伸展树(Splay tree)图解与实现
小张的专栏
11-02 4万+
个人技术博客：http://blog.ztgreat.cn 一、伸展树    本文介绍了二叉查找树的一种改进数据结构–伸展树（Splay Tree）。它的主要特点是不会保证树一直是平衡的，但各种操作的平摊时间复杂度是O(log n)，因而，从平摊复杂度上看，二叉查找树也是一种平衡二叉树。另外，相比于其他树状数据结构（如红黑树，AVL树等），伸展树的空间要求与编程复杂度要小得多。 伸展树...
扩展欧几里得算法
小张的专栏
10-18 1万+
欧几里得算法 欧几里德算法又称辗转相除法，用于计算两个整数a,b的最大公约数。基本算法：设a=qb+r，其中a，b，q，r都是整数，则gcd(a,b)=gcd(b,r)，即gcd(a,b)=gcd(b,a%b)。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值