数据结构与算法学习笔记6：BST二叉搜索树

已于 2022-05-05 17:09:37 修改
阅读量487 收藏 1
点赞数 1
分类专栏： 数据结构与算法学习笔记 文章标签： c++ 数据结构 算法 学习
于 2022-05-05 17:07:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/h0327x/article/details/124592925
版权

数据结构与算法学习笔记6：BST

二叉搜索树 BST

BST的创建

  • 创建思路：

    • 如果树为空，那么来了就是根
    • 非空，新结点和父节点比较，比父节点大进右子树，比父节点小进左子树

  • 创建代码

    void AddNode(BinaryTree **pTree,int nNum){
    //数值放入节点
    BinaryTree *pTemp = NULL;
    pTemp = (BinaryTree*)malloc(sizeof(BinaryTree));
    pTemp->nValue = nNum;
    pTemp->pLeft = NULL;
    pTemp->pRight = NULL;

    //放入树中
    if(*pTree == NULL){ //当前树空，直接作为根节点
        *pTree = pTemp;
        return;
    }
    BinaryTree *pNode = *pTree;
    while (pNode) {
        if (pNode->nValue > nNum) {
            if (pNode->pLeft == NULL) {
                pNode->pLeft = pTemp;
                return;
            }
            pNode = pNode->pLeft;
        }else if (pNode->nValue < nNum) {
            if (pNode->pRight == NULL) {
                pNode->pRight = pTemp;
                return;
            }
            pNode = pNode->pRight;
        }else {
            printf("date error.\n");
            free(pTemp);
            pTemp = NULL;
            return;
        }
    }
}

BinaryTree *CreateBST(){
    int nNum;
    int nLength;
    int i;

    BinaryTree *pTree = NULL;
    printf("请输入节点个数：\n");
    scanf("%d",&nLength);

    for (i = 0; i < nLength; i++) {
        scanf("%d",&nNum);
        //节点添加
        AddNode(&pTree,nNum);
    }
    return pTree;
}

BST的删除

  • 删除思路：

    • ① 查找（找要删除的节点及其父亲 or 找到父亲，如果不找到父亲节点，那么删除后就找不回去了）

    • ② 删除（子节点数量分析）

      • 1）0，删除
      • 2）1，当前节点的父节点和子节点进行连接（爷孙连接），删除
      • 3）2，找右子树的最小或者左子树的最大，进行替换删除（先覆盖，再删除）
        • PS：2个孩子的情况是覆盖后再删除，那么这个删除的部分和0，1的删除情况又相同，代码相等，因此可以在写代码的时候先写2个孩子的，将其转变为0，1的情况，降低代码冗余。

  • 代码：

    void Search(BinaryTree *pTree,int nNum,BinaryTree **pDel,BinaryTree **pDelFather){
    while (pTree) {
        if(pTree->nValue == nNum){
            *pDel = pTree;
            return;
        }
        else if(pTree->nValue > nNum){
            //左侧
            *pDelFather = pTree;
            pTree = pTree->pLeft;
        }
        else {
            //右侧
            *pDelFather = pTree;
            pTree = pTree->pRight;
        }
    }
    *pDelFather = NULL;
}

void DeleteBSTNode(BinaryTree **pTree,int nNum){
    //查找
    BinaryTree *pDel = NULL;
    BinaryTree *pDelFather = NULL;
    //搜索
    Search(*pTree,nNum,&pDel,&pDelFather);
    //删除
    if(pDel == NULL)    return;     //未找到，不用删
    BinaryTree *pMark = NULL;       //标记
        //两个孩子情况的处理
        if(pDel->pLeft != NULL && pDel->pRight != NULL){
            //左的最右or右的最左来进行替换
            pMark = pDel;
            //本代码选择左的最右
            pDelFather = pDel;
            pDel = pDel->pLeft;
            while (pDel->pRight != NULL) {
                pDelFather = pDel;
                pDel = pDel->pRight;
            }
            //值覆盖
            pMark->nValue = pDel->nValue;
        }
    //0个or1个孩子的处理
    if(pDelFather == NULL){     //被删除节点是根，换根的情况
        *pTree = pDel->pLeft ? pDel->pLeft : pDel->pRight;
            //左孩子非空则左孩子成为新根，右孩子非空则右孩子成为新根
        free(pDel);
        pDel = NULL;
        return;
    } 
    else{       //被删除节点非根，需要判断爷孙相连是左侧还是右侧相连
        if (pDel == pDelFather->pLeft) {
            pDelFather->pLeft = pDel->pLeft ? pDel->pLeft : pDel->pRight;
        }else {
            pDelFather->pRight = pDel->pLeft ? pDel->pLeft : pDel->pRight;
        }
        free(pDel);
        pDel = NULL;
        return;
    }
}

如何将一棵排序二叉树转变为有序的双向链表？

img

  • 思路：

    • 中序遍历，right指向下一个，left指向上一个

  • 代码：

    void BstToList(BinaryTree *pTree,BinaryTree **pHead,BinaryTree **pTail){
    if (pTree == NULL) return;  //空的话就不需要处理了
    //处理左子树
    BstToList(pTree->pLeft, pHead, pTail);
    //处理节点  加到链表中  
    if (*pHead == NULL) {   //链表为空 直接做表头
        *pHead = pTree;
    }
    else{   //链表不为空  原来尾的下一个（Right）就是当前节点，当前节点的前一个就是原来的尾
        (*pTail)->pRight = pTree;
        pTree->pLeft = *pTail;
    }
    *pTail = pTree; //新来节点成为新的尾
    //处理右子树
    BstToList(pTree->pRight, pHead, pTail);
}

void Print(BinaryTree *pHead){
    while (pHead) {
        printf("%d  ",pHead->nValue);
        pHead = pHead->pRight;
    }
}

BST的旋转

右旋（左的左引起的不平衡时进行）
image-20220505140505467 image-20220505154734212
父子关系：

  • A的左孩子 = E ；B的右孩子 = A ； X的孩子 = B

  • E的父亲 = A；A的父亲 = B；B的父亲 = X

    //右旋代码
void RightRotate(BinaryTree *pNode){
    if (pNode == NULL || pNode->pLeft == NULL) return;
    BinaryTree *pMark = pNode->pLeft;
    //三个孩子的关系
    pNode->pLeft = pMark->pRight;
    pMark->pRight = pNode;
    if (pNode->pFather == NULL) {
        pTree = pMark;
    }else{
        if (pNode == pNode->pFather->pLeft) {
            pNode->pFather->pLeft = pMark;
        }
        else{
            pNode->pFather->pRight = pMark;
        }
    }
    //三个父亲的关系
    if (pNode->pLeft != NULL) {
        pNode->pLeft->pFather = pNode;
    }
    pMark->pFather = pNode->pFather;
    pNode->pFather = pMark;
}

  • 整体代码：

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

typedef struct Node{
    int nValue;
    struct Node *pLeft;
    struct Node *pRight;
    struct Node *pFather;	//右旋时需要用到父子关系，所以创建树时注意需要该信息
}BinaryTree;

BinaryTree *pTree = NULL;

BinaryTree* CreateBinaryTree(){
    //根
    BinaryTree* Root = NULL;
    Root = (BinaryTree*)malloc(sizeof(BinaryTree));
    Root->nValue = 1;
    Root->pFather = NULL;
    //根的左
    Root->pLeft = (BinaryTree*)malloc(sizeof(BinaryTree));
    Root->pLeft->nValue = 2;
    Root->pLeft->pFather = Root;
    //根的右
    Root->pRight = (BinaryTree*)malloc(sizeof(BinaryTree));
    Root->pRight->nValue = 3;
    Root->pRight->pFather = Root;
    //根的左的左
    Root->pLeft->pLeft = (BinaryTree*)malloc(sizeof(BinaryTree));
    Root->pLeft->pLeft->nValue = 4;
    Root->pLeft->pLeft->pLeft = NULL;
    Root->pLeft->pLeft->pRight = NULL;
    Root->pLeft->pLeft->pFather = Root->pLeft;
    //根的左的右
    Root->pLeft->pRight = (BinaryTree*)malloc(sizeof(BinaryTree));
    Root->pLeft->pRight->nValue = 5;
    Root->pLeft->pRight->pLeft = NULL;
    Root->pLeft->pRight->pRight = NULL;
    Root->pLeft->pRight->pFather = Root->pLeft;

    return Root;
}

void RightRotate(BinaryTree *pNode){
    if (pNode == NULL || pNode->pLeft == NULL) return;
    BinaryTree *pMark = pNode->pLeft;
    //三个孩子的关系
    pNode->pLeft = pMark->pRight;
    pMark->pRight = pNode;
    if (pNode->pFather == NULL) {
        pTree = pMark;
    }else{
        if (pNode == pNode->pFather->pLeft) {
            pNode->pFather->pLeft = pMark;
        }
        else{
            pNode->pFather->pRight = pMark;
        }
    }
    //三个父亲的关系
    if (pNode->pLeft != NULL) {
        pNode->pLeft->pFather = pNode;
    }
    pMark->pFather = pNode->pFather;
    pNode->pFather = pMark;
}

void PreorderTraversal(BinaryTree *pTree){
    if (pTree == NULL)  return;
    //打印
    printf("%d  ",pTree->nValue);
    //左子树
    PreorderTraversal(pTree->pLeft);
    //右子树
    PreorderTraversal(pTree->pRight);
}//前序遍历

int main()
{
    pTree = CreateBinaryTree();
    PreorderTraversal(pTree);
    printf("\n");
    RightRotate(pTree);
    PreorderTraversal(pTree);
    printf("\n");

    return 0;
}
左旋（右的右引起的不平衡时进行）
image-20220505161212312
父子关系：

  • C的左孩子 = A ；C的右孩子 = E ； X的孩子 = C

  • A的父亲 = C；E的父亲 = C；C的父亲 = X

//左旋代码
void LeftRotate(BinaryTree *pNode){
    if (pNode == NULL || pNode->pRight == NULL) return;
    BinaryTree *pMark = pNode->pRight;
    //三个孩子的关系
    pNode->pRight = pMark->pLeft;
    pMark->pLeft = pNode;
    if (pNode->pFather == NULL) {
        pTree = pMark;
    }else{
        if (pNode == pNode->pFather->pLeft) {
            pNode->pFather->pLeft = pMark;
        }
        else{
            pNode->pFather->pRight = pMark;
        }
    }
    //三个父亲的关系
    if (pNode->pRight != NULL) {
        pNode->pRight->pFather = pNode;
    }
    pMark->pFather = pNode->pFather;
    pNode->pFather = pMark;
}
//其实和右旋代码一样，把left和right互相替换掉就可以了
左右旋VS右左旋

  • 左的右引起的不平衡 -> 左右旋

    • 举例一下~

      image-20220505163305522

  • 右的左引起的不平衡 -> 右左旋

  • 直接调用右旋和左旋的函数即可，无需重写左右旋 or 右左旋的函数。

97Marcus
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
算法与数据结构学习笔记-最优二叉搜索树(optimal binary search tree)的动态规划实现详解
mschessy的博客
01-30 3638
一串字符中可能进行多次查找，每个字符被查找到的频率都不同，如何根据字符被查找到的频率，建立一个二叉搜索树，使得花费时间最少呢？ 题目：给定一列按升序排列的键值K=[k1,k2,...,kn]K=[k_1,k_2,...,k_n]K=[k1​,k2​,...,kn​]和它们被搜索到的频率P=[p1,p2,...,pn]P=[p_1,p_2,...,p_n]P=[p1​,p2​,...,pn​]，建立...
《数据结构与算法之美》的学习笔记和python代码实现.zip
01-01
二叉搜索树（BST）保证左子树所有节点小于父节点，右子树所有节点大于父节点，适合查找操作。平衡树如AVL树和红黑树通过保持高度平衡来确保高效操作。 7. 图： 图由顶点和边构成，用于表示对象之间的关系。图可以是...
算法学习笔记——数据结构：二叉搜索树BST
Insomnia_X的博客
04-03 287
二叉搜索树BST 二叉搜索树BST，即BinarySearchTree，其特性是： 对于任意节点，如果其值为val，则左子树所有节点值小于等于val，且右子树所有节点值大于等于val 注意利用此特性，避免多余的访问 def traverseBST(node: TreeNode, target: int): """BST遍历框架""" if node is None: return if node.val == target:
【数据结构与算法学习笔记-BST二叉查找树】
floating_heart的博客
04-07 970
本文为学习笔记，感兴趣的读者可在MOOC中搜索《数据结构与算法Python版》或阅读《数据结构（C语言版）》（严蔚敏）。 本文包括二叉查找树的介绍、结构定义和增删改查等方法的实现，涉及一些Python内置方法的构建，最终有简单的复杂度分析过程。
数据结构与算法学习笔记：二叉搜索树(下)
baidu_41388533的博客
07-18 250
写在前面：记录学习《恋上数据结构与算法》的过程。 课程链接地址：https://ke.qq.com/course/385223 目录 二叉树的遍历（适用于所有二叉树） 前序遍历 中序遍历 后序遍历 层序遍历 设计遍历接口 增强遍历接口 树状打印二叉树 遍历的应用 计算二叉树的高度 完全二叉树的判断 翻转二叉树 根据遍历结果重构二叉树 前驱节点（Predecessor） 后继节点（successor） 删除节点 - 叶子节点 删除节点 - 度为1的节点 删除节点 - 度为
数据结构与算法学习笔记：二叉搜索树(上)
baidu_41388533的博客
07-17 281
写在前面：记录学习《恋上数据结构与算法》的过程。 课程链接地址：https://ke.qq.com/course/385223 目录 二叉搜索树的引入 二叉搜索树(Binary Search Tree) BST 接口设计 节点 判断不能为空 根节点 添加根节点 添加节点 找到父节点 创建新节点，添加 定义比较接口，元素必须实现接口 改善比较方式，创建比较器 兼容以上两种比较方法 或者使用匿名类 打印BST 推荐几个网站 值相等处理（覆盖原节点） 二叉搜索树的引入
0020算法笔记——【动态规划】最优二叉搜索树问题 - liufeng_king的专栏 - 博客频道 - CSDN1
08-03
【最优二叉搜索树问题】是一种在数据结构和算法领域中的经典问题，主要涉及动态规划的概念。该问题的目标是设计一棵二叉搜索树（BST），使得在给定的元素集合和存取概率分布下，搜索元素时的平均比较次数达到最小。 ...
MIT算法导论公开课之课程笔记 9.二叉搜索树.rar
07-06
二叉搜索树（Binary Search Tree，BST）是数据结构领域中的一个重要概念，它是一种特殊的二叉树，每个节点都包含一个键（key）、一个关联的值、一个指向左子节点的引用以及一个指向右子节点的引用。在这个“MIT算法...
c++命令模式
qq_71286244的博客
08-30 4219
c++命令模式详细介绍
c语言赋值截断
hutaotaotao的博客
09-02 463
c语言赋值过程与截断行为
【C++】智能指针——auto_ptr，unique_ptr，shared_ptr
2301_79796701的博客
09-01 1199
1.智能指针对象中引用计数是多个智能指针对象共享的，两个线程中智能指针的引用计数同时 ++或--，这个操作不是原子的，引用计数原来是1，++了两次，可能还是2.这样引用计数就错 乱了。旧的智能指针的会转移给新的智能指针，而旧的智能指针的会被置空。解决方案：在引用计数的场景下，把节点中的_prev和_next改成weak_ptr就可以了，weak_ptr不会增加引用计数，代码示意。该问题是有类似于链表节点的结构引起的，当外部的智能指针都释放了，就拿不内部的智能指针，那么节点就不会释放。使用方法参考官方文档。
C++友类匿名对象，运算符重载
最新发布
m0_75109289的博客
09-02 117
【代码】C++友类匿名对象，运算符重载。
适用于 Visual Studio 的 C++ 万能头
Xi Xu 的博客
08-25 3774
修改版本是根据 GNU General Public License v3.0 or later 分发的。原始文件是根据 GNU General Public License v3.0 or later 分发的。用于在 Visual Studio 上预编译的 C++ 包含。文件的修改版本，与 Visual Studio 兼容。此文件是 GCC 13.1.0 中。此文件的配置方法可在互联网上搜索。修改由本文作者完成。
C++的内存模型
qhu1600417010的博客
08-28 1168
C++ 的内存模型包含了程序运行时如何分配、访问、管理内存的规则，涵盖了多线程环境下的数据一致性、内存对齐、以及虚拟内存管理等内容。掌握这些概念对于编写高效、安全的 C++ 程序至关重要。
怎么解决 hash 碰撞，用 C++ 实现 hashMap？
zhanghaiou07657的博客
08-29 2618
如果要自己实现一个简单的哈希映射，可以定义一个结构体来表示哈希表中的节点，包含键值对和指向下一个节点的指针（如果采用链地址法）。在插入操作时，计算键的哈希值，若该位置已被占用且键不相同，则根据选择的解决碰撞的方法（如链地址法）将新元素插入到链表中。在查找操作时，同样计算键的哈希值，然后遍历对应的链表（如果是链地址法）来查找目标键值对。“哈希碰撞是在哈希函数计算过程中可能出现的不同输入产生相同哈希值的情况。链地址法是将哈希值相同的元素存储在一个链表中，当进行查找等操作时，遍历对应的链表来找到目标元素。
C++ | Leetcode C++题解之第390题消除游戏
Ddddddd_158的博客
09-02 123
C++ | Leetcode C++题解之第390题消除游戏
Ascend C算子开发（入门）—— 算子开发初体验
Byyyi耀的博客
08-29 2573
Ascend C算子开发（入门）—— 算子开发初体验
C++战列舰小游戏Lv. 1.2版本(半成品)
YYDS314的博客
08-31 1840
C++代码
JS算法与数据结构：二叉查找树（BST）深度解析
这种结构使得二叉查找树在搜索、插入和删除操作上有很好的性能。在理想情况下，即当树完全平衡时，这些操作的时间复杂度为O(log n)，其中n是树中节点的数量。然而，如果树严重倾斜，性能可能会退化到O(n)。 二叉...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

97Marcus

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

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

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

打赏作者

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

抵扣说明：

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

余额充值