二叉搜索树的基本操作

最新推荐文章于 2024-03-08 22:02:29 发布
最新推荐文章于 2024-03-08 22:02:29 发布
阅读量199 收藏
点赞数
分类专栏： 数据结构和算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41112517/article/details/80381593
版权 
#pragma once
typedef int DataType;

typedef struct BSTreeNode
{
    struct BSTreeNode* _pLeft;
    struct BSTreeNode* _pRight;
    DataType _data;
}BSTNode;

#include<assert.h>
#include<stdio.h>
#include<stdlib.h>

BSTNode* BuyBSTreeNode(DataType data)
{
    BSTNode* pNewNode = (BSTNode*)malloc(sizeof(BSTNode));
    if(NULL == pNewNode)//申请失败的话
    {
        assert(0);
        return NULL;
    }
    pNewNode->_data =  data;
    pNewNode->_pLeft = NULL;
    pNewNode->_pRight = NULL;
    return pNewNode;
}
void BSTreeInit(BSTNode** pRoot)
{
    assert(pRoot);
    *pRoot = NULL;

}

void BSTreeInsert(BSTNode** pRoot,DataType data)//非递归的
{
    BSTNode* pCur = NULL;
    BSTNode* pParent = NULL;
    assert(pRoot);
    if(*pRoot == NULL)
    {

        *pRoot = BuyBSTreeNode(data);
        return;
    }
    //1、找待插入节点的插入位置
    pCur = *pRoot;//从根的位置找
    while(pCur)
    {
        if(data < pCur->_data)
        {
            pParent = pCur;
            pCur = pCur->_pLeft;//往左边走
        }
        else if(data >pCur->_data)
        {
            pParent = pCur;
            pCur = pCur->_pRight;//往后边走
        }
        else//说明已经存在了
            return;
    }
    //2、插入新节点
    pCur = BuyBSTreeNode(data);
    if(data < pParent->_data)//如果插入的新数据小于双亲的数据往左边插
        pParent->_pLeft = pCur;
    else
        pParent->_pRight = pCur;
}
void BSTreeInsert(BSTNode** pRoot,DataType data)//递归的
{
    assert(pRoot);//保证树存在
    if(NULL == *pRoot)//树是空的
        *pRoot = BuyBSTreeNode(data);
    else
    {
        if(data < (*pRoot)->_data)//要插入的数据小于根节点的data，往左边插
            BSTreeInsert(&(*pRoot)->_pLeft,data);
        else if(data > (*pRoot)->_data)//往右边插
            BSTreeInsert(&(*pRoot)->_pRight,data);
        else //已经找到了
            return;
    }


}

void BSTreeDelete(BSTNode** pRoot,DataType data)//删除结点（非递归的）
{
    BSTNode* pCur = NULL;
    BSTNode* pParent = NULL;
    assert(pRoot);
    pCur = *pRoot;
    //1、找待删除结点在二叉搜索树中的位置
    while(pCur)
    {
        if(data == pCur->_data)
            break;
        else if(data < pCur->_data)
        {
            pParent = pCur;
            pCur = pCur->_pLeft;
        }
        else
        {
            pParent = pCur;//保存双亲
            pCur = pCur->_pRight;
        }
    }
    if(pCur == NULL)
        return;
    //只有右孩子 或者 是叶子节点
    if(pCur->_pLeft == NULL)
    {
        if(pCur == *pRoot)
        {
            *pRoot = pCur->_pRight;

        }
        else
        {
            //检测待删除结点是其双亲的左还是右
            if(pParent->_pLeft == pCur)//pCur是双亲的左孩子
            pParent->_pLeft = pCur->_pRight;
            else//是双亲的右孩子
            pParent->_pRight = pCur->_pRight;
        }

    }
    else if(NULL == pCur->_pRight)//只有左孩子
    {

        if(pCur == *pRoot)//如果删除的是根
            *pRoot = pCur->_pLeft;//根指向当前的左子树
        else//不是根
        {
            if(pParent->_pLeft == pCur)//如果是双亲的左孩子
                pParent->_pLeft = pCur->_pLeft;
            else//双亲的右孩子
                pParent->_pRight = pCur->_pLeft;    
        }
    }
    else
    {
        //左右孩子都存在
         //在右子树中找最左侧的结点，也就是最小的结点。
        BSTNode* pDel = pCur->_pRight;//先让它走到右子树的那边，然后再找最左边的结点
        pParent = pCur;
        while(pDel->_pLeft)
        {   
            pParent = pDel;
            pDel = pDel->_pLeft;

        }
        pCur->_data = pDel->_data;//在右子树中删除pDel
        if(pDel == pParent->_pLeft)//要删除的pDel是双亲的左孩子
            pParent->_pLeft = pDel->_pRight;
        else
            pParent->_pRight = pDel->_pRight;
        pCur = pDel;
    }
    free(pCur);
}

void BSTreeDelete(BSTNode** pRoot,DataType data)//删除结点（递归的）
{

    assert(pRoot);//保证树存在
    if(NULL == *pRoot)//树是空的
        return;
    else
    {
        if(data < (*pRoot)->_data)//要插入的数据小于根节点的data，在左边删除data
            BSTreeDelete(&(*pRoot)->_pLeft,data);
        else if(data > (*pRoot)->_data)//在右边删除data
            BSTreeDelete(&(*pRoot)->_pRight,data);
        else //在根的位置
        {
            //左孩子为空，只有右孩子或者叶子节点
            BSTNode* pDel = *pRoot;
            if(NULL == pDel->_pLeft)
            {
                *pRoot = pDel->_pRight;
                free(pDel);     
            }
            else if(NULL == pDel->_pRight)  //只有左孩子
            {

                *pRoot = pDel->_pLeft;
                free(pDel);

            }
            else//左右孩子都存在
            {
                pDel = (*pRoot)->_pRight;//在右子树中找替代结点

                while(pDel->_pLeft)//在右子树中找最左边的结点
                    pDel = pDel->_pLeft;//一直在左边找

                (*pRoot)->_data = pDel->_data;//替代结点的数据交给待删除结点

                BSTreeDelete(&(*pRoot)->_pRight,pDel->_data);//pDel在pRoot的右子树中，然后再在pRoot的右子树中删除pDel的data

            }
        }
    }
}

BSTNode* BSTreeFind(BSTNode* pRoot,DataType data)//非递归
{
    BSTNode* pCur = pRoot;
    while(pCur)
    {
        if(data = pCur->_data)
            return pCur;
        else if(data < pCur->_data)
            pCur = pCur->_pLeft;
        else
            pCur = pCur->_pRight;
    }
    return NULL;
}

BSTNode* BSTreeFind(BSTNode* pRoot,DataType data)//递归的
{
    if(NULL == pRoot)//这个树为空
        return NULL;
    else//这个树不为空
    {
        if(data == pRoot->_data)// 删除的结点是不是根节点
            return pRoot;
        else if(data < pRoot->_data)//要找的这个是数小于根节点的data。在左子树中找
            return BSTreeFind(pRoot->_pLeft,data);//在左子树中递归找data
        else
            return BSTreeFind(pRoot->_pRight,data);//在右子树中递归找data

    }

}

void InOrder(BSTNode* pRoot)//中序遍历
{
    if(pRoot)//如果这个树不为空
    {
        InOrder(pRoot->_pLeft);
        printf("%d ",pRoot->_data);
        InOrder(pRoot->_pRight);
    }

}
void BSTreeDestroy(BSTNode** pRoot)
{
    assert(pRoot);
    if(*pRoot)
    {
        BSTreeDestroy(&(*pRoot)->_pLeft);//先销毁左子树
        BSTreeDestroy(&(*pRoot)->_pRight);//销毁右子树
        free(*pRoot);
        *pRoot = NULL;   
    }

}



void TestBSTree()
{
    int a[] = {5,3,4,1,7,8,2,6,0,9};
    int i = 0;
    BSTNode* pRoot;
    BSTreeInit(&pRoot);
    for(;i < sizeof(a)/sizeof(a[0]);++i)
    {
        BSTreeInsert(&pRoot,a[i]);
    }
    printf("中序遍历的结果：");
    InOrder(pRoot);
    printf("\n");

    BSTreeInsert(&pRoot,10);

    BSTreeDelete(&pRoot,2);

    printf("中序遍历的结果：");
    InOrder(pRoot);
    printf("\n");

    BSTreeDelete(&pRoot,1);
    printf("中序遍历的结果：");
    InOrder(pRoot);
    printf("\n");
    //分别删除5 和 7
    BSTreeDelete(&pRoot,5);
    //BSTreeDelete(&pRoot,7);

    printf("中序遍历的结果：");
    InOrder(pRoot);
    printf("\n");

    BSTreeDestroy(&pRoot);
    //BSTreeDelete(&pRoot,2);
}

//1、删除的该结点左右孩子均为空（叶子）-----直接删除
//2、删除的该结点只有左孩子------直接删除
//3、删除的该结点只有右孩子------直接删除
        /*（1）待删除的结点没有双亲
        （2）待删除节点是其双亲的左或者右
                    （1）是双亲的左：pParent->left = pCur->right
                    （2）是双亲的右：pParent->right = pCur->right*/
//4、删除的该结点左右孩子都存在：一、在左子树或者右子树找替代结点
                        //（1）、左子树中找替代---找左子树中最大的结点
                        //（2）、右子树中找替代---找右子树中最小的结点

                    //二、将替代结点中的数据交给待删除结点（pDel）

                    //三、连接起来
                            /*（1）pDel为其双亲的左孩子
                            （2）pDel为其双亲的右孩子*/
追梦小蚂蚁
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉搜索树+C++程序+对二叉搜索树的基本操作
02-16
二叉搜索树+C++程序+对二叉搜索树的基本操作：包括查找、插入、删除元素。 文件是标准cpp文件，可以在devc++上成功运行，在vs上运行，稍加编辑便可以。 建议用devc，此软件使用方便。
二叉树的构建
li123128的博客
11-10 3310
二叉树是一种非常重要的数据结构。本文总结了二叉树的常见操作：二叉树的构建，查找，删除，二叉树的遍历(包括前序遍历、中序遍历、后序遍历、层次遍历)，二叉搜索树的构造等。
数据结构，二叉搜索树的详解
我的主页
04-24 776
本期讲解：二叉搜索树是怎样形成的，怎样查找二叉搜索树的结点，插入结点以及删除结点。
C语言 二叉搜索树（建立、插入、查找和删除等基本操作）
m0_73070900的博客
06-03 2924
以上是关于二叉搜索树的一些基础知识和操作流程。二叉搜索树是一种常用的数据结构，在实际开发中应用广泛。它可以快速地实现数据的查找、插入和删除等操作，并且具有遍历操作，可以对 BST 中的数据进行排序。在工程实践中，二叉搜索树可以用于实现字典、关键字索引和数据压缩等场景。当然，BST 也有一些缺点，主要是在遇到极端情况时，比如树的深度很大，会出现退化，在某些操作上的时间复杂度会退化成 O(n)，不再具有快速的操作效率。为了解决这个问题，需要进行 AVL 树或红黑树等平衡二叉搜索树的优化。
数据结构和算法学习记录——二叉搜索树的插入操作、删除操作
li13437542099的博客
04-20 1146
这样处理的好处是：左子树的最大值一定不是有两个孩子节点的情况、而右子树的最小值也一定不是有两个孩子节点的情况。我们已经知道了没有孩子节点的情况和只有一个孩子节点的情况该怎么删除了，当有两个孩子节点的情况时，就考虑能不能把它变成只有一个孩子节点的情况来处理呢？当找到了新节点应该插入的位置时，需要通过找到上一个节点的地址，来将上一个节点的左子树指针或者右子树指针指向新节点。是可以实现的：用另一节点替代被删除的节点，这个节点应是右子树的最小元素或者左子树的最大元素。它形成的二叉搜索树是怎样的呢？
二叉搜索树（查找、插入、删除的讲解实现+图文并茂）
bang___bang_的博客
05-25 7974
本文讲解并模拟实现二叉搜索树，详解它的查找、插入、删除及实现，并对二叉搜索树的应用场景进行描述，最后进行了性能分析！
二叉搜索树实例练习
09-05
二叉搜索树（Binary Search Tree，BST），是一种特殊的...通过掌握其基本性质和操作，我们可以解决如判断序列是否对应相同二叉搜索树等实际问题。在编程实践中，理解二叉搜索树的内部工作原理和遍历方法是至关重要的。
java实现 二叉搜索树功能
08-27
二叉搜索树是一种特殊的二叉树，它的每个节点都含有一个Comparable的键值，且所有的键值都是唯一的，节点的键值也可以是基本类型，如int、long等，也可以是自定义的对象类型，只要实现了Comparable接口。二叉搜索树...
Python实现二叉搜索树
09-21
二叉搜索树（Binary Search Tree，BST）是一种特殊的二叉树数据结构，其特性在于每个节点的左子树上的所有节点的值均小于该节点的值，而右子树上所有节点的值均大于该节点的值。这种结构使得二叉搜索树在搜索、插入...
二叉搜索树_二叉搜索树_源码
10-04
源代码文件很可能是用C语言编写的，用于演示如何实现二叉搜索树的基本操作。C语言是一种底层、高效的编程语言，常用于实现数据结构和算法。 在二叉搜索树的实现中，通常会包含以下关键函数： 1. **创建节点**：`...
二叉查找树的查找、删除、插入等基本操作（C语言）
06-14
该源码使用C实现了最二叉查找树的基本操作，比如删除、查找，插入等。
701.二叉搜索树中的插入操作
Jiu_R的博客
11-25 162
二叉搜索树中的插入操作 思路1：递归 对于二叉搜索树，特点是有序；当需要插入元素，自然找到插入位置时需要new一个结点，那如何使该结点和父节点产生联系呢？ ①利用返回值（只处理当前节点） //二叉搜索树本身有序，因此无需遍历整棵树，插入位置根据当前节点和val的大小关系可以判断出接下来往哪走 //通过递归函数返回值完成新加入节点的父子关系赋值操作，下一层将加入节点返回，本层用root->left或者root->right将其接住 TreeNode* insertIntoBST(TreeNod.
【算法】二叉搜索树的插入、删除、转换操作
StudyWinter的博客
02-29 963
对应的节点，并保证二叉搜索树的性质不变。返回二叉搜索树（有可能被更新）的根节点的引用。如果前一个节点小于当前节点，则将插入数据放到前一个节点的右子树上；二叉树是一棵满足「每个节点的左右两个子树的高度差的绝对值不超过 1 」的二叉树。一个正确的答案是 [5,4,6,2,null,null,7], 如下图所示。给定需要删除的节点值是 3，所以我们首先找到 3 这个节点，然后删除它。如果前一个节点大于当前节点，则将插入数据放到前一个节点的左子树上；另一个正确答案是 [5,2,6,null,4,null,7]。
二叉树——二叉搜索树中的插入操作
ljh5930的博客
03-01 936
给定二叉搜索树（BST）的根节点 root 和要插入树中的值 value ，将值插入二叉搜索树。返回插入后二叉搜索树的根节点。输入数据 保证 ，新值和原始二叉搜索树中的任意节点值都不同。注意，可能存在多种有效的插入方式，只要树在插入后仍保持为二叉搜索树即可。你可以返回 任意有效的结果。
二叉查找树的基本操作（c语言）
最新发布
wuqingshun314159的博客
03-08 1225
其次插入还必须满足二叉查找树的性质**左子树小于根节点，根节点小于右子树。**于是我们从根节点开始找，**如果插入元素小于根节点，则从左边插入，如果插入元素大于根节点，则从右边插入。，但是即使这样也要保证二叉查找树的基本性质**左子树小于根节点，根节点小于右子树。**这样我们分三种情况讨论。，若任意节点的左子树不空，则左子树上所有节点的值均小于它的根节点的值。，若任意节点的右子树不空，则右子树上所有节点的值均大于它的根节点的值。结点的值，只是让值相等，不改变树形的结构（与情况2完全相等的操作区别）
二叉查找树的基本操作
amf12345的博客
08-15 514
二叉查找树的基本操作有查找、插入、建树、删除 查找操作 在之前介绍的二叉树的查找操作时，由于无法确定二叉树的具体特性，因此只能对左右子树都进行递归遍历，但是二叉查找树的性质决定了可以只选择其中的一种进行遍历，因此查找将会是从树根到查找结点的一条路径，故最坏复杂度为O(h),其中h是二叉查找树的高度，于是可以得到查找操作的基本思路 如果当前根结点root为空，说明查找失败，返回 如果需...
《数据结构与算法》之课程实验
ProgramNovice的博客
12-28 641
《数据结构与算法》之课程实验BSTree and AVLTreeBSTreeAVLTreeTop-K problemDijkstra 电子科技大学《数据结构与算法》课程的3个实验，这里只展示代码，想要运行还得要对应的数据，用txt文件才能在命令行窗口调用运行。 BSTree and AVLTree BSTree #include<stdio.h> #include<stdlib.h> #include<iostream> #include<math.h> us
二叉搜索树(BST)的基本操作
姿势水平
11-27 1424
二叉树的一个重要应用是查找其中的元素，二叉搜索树则是针对数据的动态查找而设计的一种高效的数据结构类型。二叉搜索树是一种特殊的二叉树，它可以为空；如果不为空，满足以下性质：1. 非空 左子树 的所有键值小于其根结点的键值。2. 非空 右子树 的所有键值大于其根结点的键值。3. 左右子树都是二叉搜索树。 由于定义的不同，二叉搜索树也有一些不同于二叉树的操作函数，本文实现了二叉搜索树的指定元素查找、最小元素查找、最大元素查找、插入和删除元素等功能。
二叉查找树中的插入查找和删除
热门推荐
naget的博客
09-05 1万+
上一篇文中，通过二分查找，我们实现了对数级别的查找方案，但因为使用了数组这一数据结构，插入时需要移动大量的元素，导致插入动作任然很慢。为了减少移动的元素，我们这次使用链表，为了保持二分查找的效率，我们将二者结合起来——二叉查找树。 一个二叉查找树就是一个二叉树，每个节点上包含有一个键一个值一个指向左节点的链接一个指向右节点的链接（这个图中的数字代表键，值没有显示）。而且每个结点的键都大于其左...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值