二叉搜索树——插入、查找、删除

已于 2022-05-06 15:45:13 修改
阅读量774 收藏 8
点赞数
分类专栏： 算法与数据结构 文章标签： 数据结构
于 2020-03-26 12:26:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45728685/article/details/105115892
版权

二叉搜索树

二叉搜索树的特点

  • 根节点的值大于左结点的值，小于右结点的值

  • 根节点的左、右子树也是一个二叉搜索树

  • 没有重复值

  • 中序遍历得到的序列是从小到大排列的

  • 二叉树的存储结构

typedef struct tree
{
    int data;
    struct tree *leftchild;
    struct tree *rightchild;
} BiNode, *BiTree;
typedef struct Binary_Search_Tree
{
    BiTree root;
} BST,*pBST;

这里我多定义了一个结构,来操纵根节点，这个结构看个人习惯，可有可无。

二叉搜索树的算法

以下建立的二叉搜索树如图

在这里插入图片描述

二叉搜索树的建立/插入

插入只有在位置为空的时候才插入，并不会在位置不为空的时候抢占其他结点的位置。

void insert_Binode(pBST pB, int val)
{
    BiTree pNew = (BiTree)malloc(sizeof(BiNode));//创建一个新的树结点同时初始化
    pNew->data = val;
    pNew->leftchild = NULL;
    pNew->rightchild = NULL;

    if (pB->root == NULL)							//树根节点为空
    {
        pB->root= pNew;
    }else
    {
        BiTree temp = pB->root;		//创建一个临时结点来遍历二叉搜索树中的结点来进行值比较
        while(temp!=NULL)			
        {
            if(val>temp->data)			//大于根节点,说明要插入右子树
            {
                if(temp->rightchild == NULL)//根节点的右子树结点为空,说明可以插入
                {
                    temp->rightchild = pNew;
                    return;
                }
                else
                    temp=temp->rightchild;	//不为空接着遍历比较
            }
            else
            {
                if (temp->leftchild == NULL)
                {
                    temp->leftchild = pNew;//小于根节点,说明要插入右子树
                    return;
                }
                else
                    temp=temp->leftchild;
            }
        }
    }

}
二叉搜索树的查找

用跟插入一样的迭代方法可能更好理解,我第一次用的是递归方法.

int search_Binode(BiTree pBC,int val)
{
    if(pBC==NULL)
    {
        return 0;
    }
    if(pBC->data==val)
    {
        return 1;
    }else if(pBC->data<val) //val更大在右子树,
    {
        return search_Binode(pBC->rightchild, val);//接着在右子树看是否=val
    }else
    {
        return search_Binode(pBC->leftchild, val);
    }
}

int search_Binode(BiTree pBC,int val)
{
    BiTree p=pBC;
    if(pBC==NULL)		//根节点为空
    {
        return 0;
    }
    while(p!=NULL)
    {
    	if(p->data==val)	//找到了返回1
    	{
        return 1;
    	}else if(pBC->data<val) //val更大在右子树
    	{
        	p=p->rightchild    //更新p
   		}else
   		{
        	p=p->leftchild
    	}
    }
}
二叉搜索树删除结点

删除结点更复杂一点，需要讨论三种情况

  • 删除节点为叶子节点

  • 删除节点只有左子树或者右子树

  • 删除节点既有右子树又有左子树

在这里插入图片描述

从图里可以看出第一种、第二种情况都是将待删除结点的父节点指向待删除结点的子结点（待删除结点为叶子节点可以认为它子结点为NULL）

代码书写上我一般把第一个和第二个情况一起写(只考虑了第一种第二种情况)

void delete_Binode(pBST pB, int val)
{
    if(pB->root==NULL)
    {
        return;
    }else{
        BiTree temp = pB->root;
        BiTree temp_father = NULL;
        BiTree temp_child = NULL;
        while (temp->data != val && temp != NULL)
        {
            if(val>temp->data)
            {
                temp_father = temp;
                temp = temp->rightchild;
            }else{
                temp_father = temp;
                temp = temp->leftchild;
            }
        }
        if(temp==NULL)
        {
            return;
        }else
        {
            if (temp->leftchild != NULL)    //判断要删除结点是只有一个左子结点还是只有一个右子结点												还是没有左右子节点
                temp_child = temp->leftchild;
            else if (temp->rightchild != NULL)
                temp_child = temp->rightchild;
            else	
                temp_child = NULL;			//待删除结点为叶子节点则其子结点为空
            if(temp_father->leftchild==temp)//把要删除结点的父节点指向要删除结点的子结点,先判断是													父节点的哪个结点
                temp_father->leftchild = temp_child;
            else
                temp_father->rightchild = NULL;
        }
	}
}

第三种情况需要做的是

左子树最大的结点或者右子树最小的结点覆盖待删除结点。然后再把左子树最大节点或者右子树最小节点删除

void delete_Binode(pBST pB, int val)
{
    if(pB->root==NULL)
    {
        return;
    }else{
        BiTree temp = pB->root;
        BiTree temp_father;
        BiTree temp_child;
        while (temp->data != val && temp != NULL)
        {
            if(val>temp->data)
            {
                temp_father = temp;
                temp = temp->rightchild;
            }else{
                temp_father = temp;
                temp = temp->leftchild;
            }
        }
        if(temp==NULL)
        {
            return;
        }
        
        if (temp->rightchild != NULL && temp->leftchild != NULL)//要删除结点有两个子结点
        {
            temp_father = temp;				//准备好两个节点用来找要删除结点的左子树最大节点
            temp_child = temp->leftchild;	//定位到左子树
            while(temp_child->rightchild!=NULL)  //找左子树的最大结点——>一直取右子树结点
            {
                temp_father = temp_child;
                temp_child = temp_child->rightchild;
            }
            temp->data = temp_child->data;
            if(temp_child->leftchild!=NULL)	//找到最大结点的时候要考虑两种情况,看下图更好理解
            {
                temp_father->leftchild = temp_child->leftchild;
            }else{
            temp_father->rightchild = NULL;}
        }

在这里插入图片描述

（v表示是左子树的最大节点,树的前部分结构没有画出,就画出了左子树最大节点那一小部分）

如果左子树最大结点是第二类，就非常方便此时child指向的就是左子树最大节点，可以直接覆盖删除

但是如果是第一类，覆盖之后直接删除就会导致有一个结点丢失，所以就需要判断是否左子树最大结点的左节点是否为空，如果不为空需要把结点接在最大节点位置

如果是第二类，直接把父节点的右孩子指针域置空就删除了。

完整代码
#include <stdio.h>
#include <stdbool.h>
#include <windows.h>
#include <malloc.h>
typedef struct tree
{
    int data;
    struct tree *leftchild;
    struct tree *rightchild;
} BiNode, *BiTree;
typedef struct Binary_Search_Tree
{
    BiTree root;
} BST,*pBST;
void create_searchtree(BiTree *);
void insert_Binode(pBST pB, int val);
int search_Binode(BiTree pBC, int val);
void delete_Binode(pBST pBC, int val);
void Midtraverse_tree(BiTree pBC);
int main()
{
    pBST pB=(pBST)malloc(sizeof(BST));  //要记得初始化,这里踩了坑,不初始化地址只读,程序无法运行
    pB->root = NULL;
    int i;
    int a[7] = {6, 3, 8, 2, 5, 1, 7};
    for (i = 0; i<7;i++)
    {
        insert_Binode(pB, a[i]);
    }
    Midtraverse_tree(pB->root);
    printf("\n");
    delete_Binode(pB,3);
    Midtraverse_tree(pB->root);
}

void Midtraverse_tree(BiTree pBC)
{
    if (pBC == NULL)
    {
        return;
    }
    else
    {
        Midtraverse_tree(pBC->leftchild);
        printf("%d", pBC->data);
        Midtraverse_tree(pBC->rightchild);
    }
}
void insert_Binode(pBST pB, int val)
{
    BiTree pNew = (BiTree)malloc(sizeof(BiNode));
    pNew->data = val;
    pNew->leftchild = NULL;
    pNew->rightchild = NULL;

    if (pB->root == NULL)
    {
        pB->root= pNew;
    }else
    {
        BiTree temp = pB->root;
        while(temp!=NULL)
        {
            if(val>temp->data)
            {
                if(temp->rightchild == NULL)
                {
                    temp->rightchild = pNew;
                    return;
                }
                else
                    temp=temp->rightchild;
            }
            else
            {
                if (temp->leftchild == NULL)
                {
                    temp->leftchild = pNew;
                    return;
                }
                else
                    temp=temp->leftchild;
            }
        }
    }

}

int search_Binode(BiTree pBC,int val)
{
    if(pBC==NULL)
    {
        return 0;
    }
    if(pBC->data==val)
    {
        return 1;
    }else if(pBC->data<val)
    {
        return search_Binode(pBC->rightchild, val);
    }else
    {
        return search_Binode(pBC->leftchild, val);
    }
}

void delete_Binode(pBST pB, int val)
{
    if(pB->root==NULL)
    {
        return;
    }else{
        BiTree temp = pB->root;
        BiTree temp_father;
        BiTree temp_child;
        while (temp->data != val && temp != NULL)
        {
            if(val>temp->data)
            {
                temp_father = temp;
                temp = temp->rightchild;
            }else{
                temp_father = temp;
                temp = temp->leftchild;
            }
        }
        if(temp==NULL)
        {
            return;
        }
        
        if (temp->rightchild != NULL && temp->leftchild != NULL)//要删除结点有两个子结点
        {
            temp_father = temp;
            temp_child = temp->leftchild;
            while(temp_child->rightchild!=NULL)         //找左子树的最大结点
            {
                temp_father = temp_child;
                temp_child = temp_child->rightchild;
            }
            temp->data = temp_child->data;
            if(temp_child->leftchild!=NULL)
            {
                temp_father->leftchild = temp_child->leftchild;
            }else{
            temp_father->rightchild = NULL;}
        }
        else
        {
            if (temp->leftchild != NULL)    //判断要删除结点是只有一个左子结点还是只有一个右子结点还是没有左右子节点
                temp_child = temp->leftchild;
            else if (temp->rightchild != NULL)
                temp_child = temp->rightchild;
            else
                temp_child = NULL;
            if(temp_father->leftchild==temp)//把要删除结点的父节点指向要删除结点的子结点,先判断是父节点的哪个结点
                temp_father->leftchild = temp_child;
            else if (temp_father->rightchild == temp)
                temp_father->rightchild = temp_child;
        }
}
}
Acwisher
关注
  • 0
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【数据结构】实现二叉搜索树的查找、插入和删除功能（思路+图文+代码详解）
WengJM的博客
11-23 2432
二叉搜索树的查找、插入和删除
二叉搜索（查找）树的查找/插入/删除以及二叉树搜索树的建立等基本操作的详细介绍
qq_45768060的博客
05-18 2112
二叉搜索树（BST，Binary Search Tree）， 也称二叉排序树或二叉查找树 定义 二叉搜索树：一棵二叉树，可以为空；如果不为空，满足以下性质： 非空左子树的所有结点的值小于其根结点的值。 非空右子树的所有结点的值大于其根结点的值。 左、右子树都是二叉搜索树。 ...
二叉搜索树详解--实现插入和删除
wtl666_6的博客
10-31 6747
二叉搜索树 bst树
二叉搜索树
xbhinsterest11的博客
05-18 1300
搜索二叉树的实现（细节满满）
是否完全二叉搜索树 （树节点插入）
qq_45141428的博客
05-13 572
将一系列给定数字顺序插入一个初始为空的二叉搜索树（定义为左子树键值大，右子树键值小），你需要判断最后的树是否一棵完全二叉树，并且给出其层序遍历的结果。 输入格式： 输入第一行给出一个不超过20的正整数N；第二行给出N个互不相同的正整数，其间以空格分隔。 输出格式： 将输入的N个正整数顺序插入一个初始为空的二叉搜索树。在第一行中输出结果树的层序遍历结果，数字间以1个空格分隔，行的首尾不得有多余空格。第二行输出YES，如果该树是完全二叉树；否则输出NO。 输入样例1： 9 38 45 42 24 58 30 6
二叉查找树 减治法——C++代码
05-24
在二叉查找树的应用中，减治法通常用于递归地处理树的结构，例如在搜索、插入和删除操作中，我们首先比较目标值与当前节点的键，然后根据比较结果决定是在左子树还是右子树继续操作。 在C++中实现二叉查找树，一般...
课程设计——二叉查找树
03-13
这种特性使得二叉查找树在插入、删除和查找等操作上具有较高的效率。 在这个“课程设计——二叉查找树”项目中，开发者创建了一个桌面应用程序，用于实现对二叉查找树的操作。用户可以通过界面进行交互，进行查找...
数据结构二叉树实验——构造二叉搜索树
06-05
这种特性使得二叉搜索树非常适合于查找、插入和删除操作，其时间复杂度在最佳情况下可以达到O(log n)。 在实验描述中提到，首先，我们需要读取第一行来确定后续将要插入的节点数量。这是构建二叉搜索树的第一步，...
【数据结构】——搜索二叉树的插入，查找和删除（递归&非递归）
02-26
2. 非递归查找：同样可以使用栈来实现，从根节点开始，按照二叉搜索树的性质逐层比较，直到找到目标节点或遍历完所有节点。 三、搜索二叉树的删除操作 删除操作相对复杂，因为可能有三种情况： 1. 要删除的节点...
红黑树和二叉搜索树的C语言实现及性能比较
04-03
这种特性使得二叉搜索树在查找、插入和删除操作上具有O(log n)的平均时间复杂度，但最坏情况下（树退化成链表）时间复杂度可能达到O(n)。 红黑树是为了解决二叉搜索树在最坏情况下的性能问题而提出的。它是一种自...
二叉搜索树的插入、查找、删除
m0_55752775的博客
01-14 960
二叉搜索树的插入、查找、删除
二叉搜索树的插入和删除
u012093557的博客
06-06 477
1、什么是二叉搜索树 若它的左子树不空，则左子树上所有节点的值均小于它的根节点的值； 若它的右子树不空，则右子树上所有节点的值均大于它的根节点的值； 它的左、右子树也分别为二叉排序树。 2、插入节点 二叉搜索数如何插入节点呢，我们来看看二叉搜索树的性质， 首先二叉搜索树无重复值；如果插入值已经存在，则不插入。 二叉搜索数根节点大于左子树所有节点，小于右子树所有节点，插入值如果大于根节点值，则插入右子树；插入值如果小于根节点值，则插入左子树。 如果根节点为空，那么创建节点，根节点为插入节点 例：现在想插图5
二叉搜索树:查找,插入,删除操作
NIHANA_HR的博客
05-15 805
什么是二叉搜索树 二叉搜索树是由二叉树组织的,如下:和普通二叉树相比多了parent结点,这样可以匹配搜索二叉树性质方便实现相应的功能;二叉搜索树有那些性质呢: 对任何结点x,其左子树中的关键字最大不超过x.key,其右子树中的关键字最小不低于x.key. class Node { public: int key; node*left; node*right; node*parent; }; 我们可以使用中序遍历方法遍历这颗树,这样结果就是有序的 上图所示搜索二叉树中序遍历结果为:1
数据结构 | 第十四章：搜索树 | 二叉搜索树的查找、插入、删除
知识库搭建ing
01-11 900
《数据结构、算法与应用（C++语言描述）》第十四章：搜索树，结合课程重点的自留笔记。
二叉搜索树的插入、删除
w903414的博客
01-02 1368
1.插入 题目描述： 给定二叉搜索树（BST）的根节点和要插入树中的值，将值插入二叉搜索树。 返回插入后二叉搜索树的根节点。 输入数据 保证 ，新值和原始二叉搜索树中的任意节点值都不同。 注意，可能存在多种有效的插入方式，只要树在插入后仍保持为二叉搜索树即可。 你可以返回 任意有效的结果 。 链接：https://leetcode-cn.com/problems/insert-into-a-binary-search-tree 2. 删除 给定一个二叉搜索树的根节点 root 和一个值 key，删除二叉搜索
二叉搜索树的插入与删除(C语言)
m0_51955470的博客
11-15 317
代码如下: BinTree Insert( BinTree BST, ElementType X ) { if( !BST ){ /* 若原树为空，生成并返回一个结点的二叉搜索树 */ BST = (BinTree)malloc(sizeof(struct TNode)); BST->Data = X; BST->Left = BST->Right = NULL; } else { /* 开始找要插入元素的位置 */
二叉查找树的查找、插入、删除、释放等基本操作的实现（C语言）
大树的专栏
06-14 8977
二叉查找树是一种特殊性质的二叉树，该树中的任何一个节点，它的左子树（若存在）的元素值小于节点的元素值，右子树（若存在）的元素值大于节点的元素值。 实现了二叉树查找树的实现以及基本操作，包括查找、插入、删除、初始化、释放等。 源码下载地址：http://download.csdn.net/detail/mcu_tian/9548788 二叉查找树节点的结构定义 相比二叉树，二叉查找树的元素结
利用C语言实现二叉搜索树的遍历、查找、插入、删除
热门推荐
非专业业余程序员
03-18 1万+
IDE：codebloks，编译器：gcc5.1.0 二叉搜索树和我们通常的二叉树还是有一定的区别，顾名思义，一颗二叉搜索树以一颗二叉树来组织，其中每一个结点就是一个对象。除了key（关键字）和卫星数据外，每个节点还包括left（左孩子指针）、right（右孩子指针）和p。如果孩子结点不存在则为NULL。 二叉搜索树的性质如下： 设x是二叉搜索树中的一...
算法学习9——二叉搜索树
最新发布
05-19
二叉搜索树，也叫二叉查找树（BST，Binary Search Tree），是一种特殊的二叉树。相对于普通的二叉树，它有一个特点：所有左子树的节点都比根节点小，所有右子树的节点都比根节点大。因此，它可以快速地进行查找、插入、删除等操作。 具体来说，二叉搜索树的定义如下： - 节点的左子树中所有节点的值都小于该节点的值。 - 节点的右子树中所有节点的值都大于该节点的值。 - 左右子树也都是二叉搜索树。 如下图所示，就是一个二叉搜索树的例子： ``` 8 / \ 3 10 / \ \ 1 6 14 / \ / 4 7 13 ``` 在这个树中，每个节点都满足左子树的节点值小于该节点的值，右子树的节点值大于该节点的值。比如，节点 3 的左子树是 1 和 6，右子树是 4 和 7，都满足要求。 二叉搜索树的主要操作包括查找、插入和删除。 查找操作可以通过递归或者循环实现。递归实现如下： ``` def search(root, val): if not root or root.val == val: return root if root.val > val: return search(root.left, val) else: return search(root.right, val) ``` 插入操作需要先查找到插入的位置，然后创建一个新节点插入到该位置： ``` def insert(root, val): if not root: return TreeNode(val) if root.val > val: root.left = insert(root.left, val) else: root.right = insert(root.right, val) return root ``` 删除操作比较复杂，需要考虑多种情况。如果要删除的节点只有一个子节点，直接将其子节点替换上来即可。如果要删除的节点有两个子节点，可以找到其右子树中的最小节点（或者左子树中的最大节点）来替换该节点，然后再删除该最小节点（或者最大节点）。 ``` def delete(root, val): if not root: return None if root.val == val: if not root.left: return root.right elif not root.right: return root.left else: # 找到右子树中的最小节点 p = root.right while p.left: p = p.left root.val = p.val root.right = delete(root.right, p.val) elif root.val > val: root.left = delete(root.left, val) else: root.right = delete(root.right, val) return root ``` 需要注意的是，在删除节点时，要保证删除后的树仍然是二叉搜索树。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值