C++进阶 二叉搜索树的讲解

最新推荐文章于 2024-09-16 15:03:26 发布
最新推荐文章于 2024-09-16 15:03:26 发布
阅读量1k 收藏 40
点赞数 54
分类专栏： C++进阶 文章标签： c++ 数据结构 二叉树 二叉搜索树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80122797/article/details/142285036
版权

在这里插入图片描述

二叉搜索树的概念

二叉搜索树又称为二叉排序树。

  • 二叉搜索树的性质
    • 若它的左子树不为空，则左子树上所有结点的值都小于等于根结点的值
    • 若它的右子树不为空，则右子树上所有结点的值都大于等于根结点的值
    • 它的左右子树也分别为二叉搜索树
    • 二叉搜索树中可以支持插入相等的值，也可以不支持插入相等的值。

二叉搜索树的插入

    1. 树为空，则直接新增结点，赋值给 root 指针
    1. 树不空，按二叉搜索树性质，插入值比当前结点大往右走，插入值比当前结点小往左走，找到空位置，插入新结点。
    1. 如果支持插入相等的值，插入值跟当前结点相等的值可以往右走，也可以往左走，找到空位置，插入新结点。（要注意的是要保持逻辑一致性，插入相等的值不要一会往右走，一会往左走）

例子:

int a[] = {8, 3, 1, 10, 1 6, 4, 7, 14, 13};

请添加图片描述

代码:

bool Insert(const K &key, const V &value)
{
    if (_root == nullptr)
    {
        _root = new Node(key, value);
        return true;
    }

    Node *parent = nullptr;
    Node *cur = _root;

    while (cur)
    {
        if (cur->_key < key)
        {
            parent = cur;
            cur = cur->_right;
        }
        else if (cur->_key > key)
        {
            parent = cur;
            cur = cur->_left;
        }
        else
        {
            return false;
        }
    }

    cur = new Node(key, value);
    if (parent->_key < key)
    {
        parent->_right = cur;
    }
    else
    {
        parent->_left = cur;
    }

    return true;
}

二叉搜索树的查找

    1. 从根开始比较，查找 x，x 比根的值大则往右边走查找，x 比根值小则往左边走查找。
    1. 最多查找高度次，走到到空，还没找到，这个值不存在。
    1. 如果不支持插入相等的值，找到 x 即可返回。
    1. 如果支持插入相等的值，意味着有多个 x 存在，一般要求查找中序的第一个 x。

代码:

Node *Find(const K &key)
{
    Node *cur = _root;
    while (cur)
    {
        if (cur->_key < key)
        {
            cur = cur->_right;
        }
        else if (cur->_key > key)
        {
            cur = cur->_left;
        }
        else
        {
            return cur;
        }
    }

    return nullptr;
}

二叉搜索树的删除

首先查找元素是否在二叉搜索树中，如果不存在，则返回 false。
如果查找元素存在则分以下四种情况分别处理：（假设要删除的结点为 N）

  1. 要删除结点 N 左右孩子均为空
    • 解决方法：把 N 结点的父亲对应孩子指针指向空，直接删除 N 结点
  2. 要删除的结点 N 左孩子位空，右孩子结点不为空
    • 解决方法：把 N 结点的父亲对应孩子指针指向 N 的右孩子，直接删除 N 结点
  3. 要删除的结点 N 右孩子位空，左孩子结点不为空
    • 解决方法：把 N 结点的父亲对应孩子指针指向 N 的左孩子，直接删除 N 结点
  4. 要删除的结点 N 左右孩子结点均不为空
    • 解决方法：无法直接删除 N 结点，因为 N 的两个孩子无处安放，只能用替换法删除。**找 N 左子树的值最大结点 R(最右结点)**或者 N 右子树的值最小结点 R(最左结点)替代 N，因为这两个结点中任意一个，放到 N 的位置，都满足二叉搜索树的规则。替代 N 的意思就是 N 和 R 的两个结点的值交换，转而变成删除 R 结点，R 结点符合情况 2 或情况 3，可以直接删除。

代码:

bool Erase(const K &key)
{
    Node *parent = nullptr;
    Node *cur = _root;

    while (cur)//循环搜索目标节点
    {
        if (cur->_key < key)//当前节点的值小于目标值就向右子树
        {
            parent = cur;
            cur = cur->_right;
        }
        else if (cur->_key > key)//当前节点的值大于目标值就向左子树
        {
            parent = cur;
            cur = cur->_left;
        }
        else
        {
            //找到了目标节点,进行删除操作
            if (cur->_left == nullptr)//左节点为空
            {
                if (cur == _root)//如果是根节点，就将根节点的右子节点设置为根节点
                {
                    _root = cur->_right;
                }
                else
                {
                    if (parent->_left == cur)//如果父节点的左节点是当前节点
                    {
                        parent->_left = cur->_right;//将父节点的左节点连接至当前节点的右子节点。
                    }
                    else//如果父节点的右节点是当前节点
                    {
                        parent->_right = cur->_right;//将父节点的右节点连接至当前节点的右子节点。
                    }
                }
                delete cur;//删除当前节点
            }
            else if (cur->_right == nullptr)//右节点为空
            {
                if (cur == _root)//如果是根节点，就将根节点的左子节点设置为根节点
                {
                    _root = cur->_left;
                }
                else
                {
                    if (parent->_left == cur)//如果父节点的左节点是当前节点
                    {
                        parent->_left = cur->_left;//将父节点的左节点连接至当前节点的左子节点。
                    }
                    else//如果父节点的右节点是当前节点
                    {
                        parent->_right = cur->_left;//将父节点的右节点连接至当前节点的左子节点。
                    }
                }

                delete cur;//删除当前节点
            }
            else
            {
                // 左右节点都不为空
                // 这里默认替换右子树最左节点c
                Node *replaceParent = cur;
                Node *replace = cur->_right;//进入根节点的右子树
                while (replace->_left)//迭代左节点，找到右子树的最左节点
                {
                    replaceParent = replace;//记录父节点
                    replace = replace->_left;//迭代左节点
                }
                //此时替换节点（replace）的左节点一定为空
                cur->_key = replace->_key;//交换值

                if (replaceParent->_left == replace)//如果替换节点是左节点
                    replaceParent->_left = replace->_right;//将父节点的左赋值为替换节点的右，因为替换节点的左节点一定是空的，因为是按照根节点的右子树的最左节点查找的。
                else//如果替换节点是右节点
                    replaceParent->_right = replace->_right;//将父节点的右赋值为替换节点的右，因为替换节点的左节点一定是空的，因为是按照根节点的右子树的最左节点查找的。

                delete replace;//删除替换节点
            }

            return true;
        }
    }

    return false;
}

二叉搜索树的析构

  • 递归析构
public:
~BSTree()
{
    Destroy(_root);
    _root = nullptr;
}

private:
void Destroy(Node *root)
{
    if (root == nullptr)
        return;

    Destroy(root->_left);
    Destroy(root->_right);
    delete root;
}

二叉搜索树的深拷贝

BSTree(const BSTree &t)
{
    _root = Copy(t._root);
}

Node *Copy(Node *root)
{
    if (root == nullptr)
        return nullptr;

    Node *newRoot = new Node(root->_key, root->_value);
    newRoot->_left = Copy(root->_left);
    newRoot->_right = Copy(root->_right);
    return newRoot;
}

二叉搜索树的=重载

BSTree &operator=(BSTree tmp)
{
    swap(_root, tmp._root);//tmp为拷贝，可以直接交换，不影响tmp
    return *this;
}

完整代码

#pragma once
#include <iostream>
using namespace std;

template <class K>
struct BSTNode
{
    K _key;
    BSTNode<K> *_left;
    BSTNode<K> *_right;

    BSTNode(const K &key)
        : _key(key), _left(nullptr), _right(nullptr)
    {
    }
};

namespace key
{

    template <class K>
    class BSTree
    {
        typedef BSTNode<K> Node;

    public:
        bool Insert(const K &key) // 二叉树的插入
        {
            if (_root == nullptr)
            {
                _root = new Node(key);
                return true;
            }

            Node *parent = nullptr;
            Node *cur = _root;
            while (cur)
            {
                if (cur->_key < key)
                {
                    parent = cur;
                    cur = cur->_right;
                }
                else if (cur->_key > key)
                {
                    parent = cur;
                    cur = cur->_left;
                }
                else
                {
                    return false;
                }
            }

            cur = new Node(key);
            if (parent->_key < key)
            {
                parent->_right = cur;
            }
            else
            {
                parent->_left = cur;
            }

            return true;
        }

        void Inorder() // 中序遍历
        {
            _Inorder(_root);
        }

        bool find(const K &key) // 查找
        {
            Node *cur = _root;
            while (cur)
            {
                if (cur->_key < key)
                {
                    cur = cur->_right;
                }
                else if (cur->_key > key)
                {
                    cur = cur->_left;
                }
                else
                {
                    return true;
                }
            }
            return false;
        }

        bool Erase(const K &key)
        {
            Node *parent = nullptr;
            Node *cur = _root;
            while (cur)
            {
                // 先搜索节点
                if (cur->_key < key)
                {
                    parent = cur;
                    cur = cur->_right;
                }
                else if (cur->_key > key)
                {
                    parent = cur;
                    cur = cur->_left;
                }
                else
                {
                    // 找到了要删除的节点
                    // 删除
                    // 左为空
                    if (cur->_left == nullptr)
                    {
                        if (cur == _root)
                        {
                            _root = cur->_right;
                        }
                        else
                        {
                            if (parent->_left == cur)
                            {
                                parent->_left = cur->_right;
                            }
                            else
                            {
                                parent->_right = cur->_right;
                            }
                        }
                        delete cur;
                    }
                    else if (cur->_right == nullptr) // 右为空
                    {
                        if (cur == _root)
                        {
                            _root = cur->_left;
                        }
                        else
                        {
                            if (parent->_left == cur)
                            {
                                parent->_left = cur->_left;
                            }
                            else
                            {
                                parent->_right = cur->_left;
                            }
                        }

                        delete cur;
                    }
                    else
                    {
                        // 左右都不为空
                        // 右子树最左节点
                        Node *replaceParent = cur;
                        Node *replace = cur->_right;
                        while (replace->_left)
                        {
                            replaceParent = replace;
                            replace = replace->_left;
                        }

                        cur->_key = replace->_key;

                        if (replaceParent->_left == replace)
                            replaceParent->_left = replace->_right;
                        else
                            replaceParent->_right = replace->_right;

                        delete replace;
                    }

                    return true;
                }
            }

            return false;
        }

    private:
        void _Inorder(Node *root)
        {
            if (root == nullptr)
            {
                return;
            }
            _Inorder(root->_left);
            cout << root->_key << ' ';
            _Inorder(root->_right);
        }

    private:
        Node *_root = nullptr;
    };

}

在这里插入图片描述

Mike!
关注
专栏目录
C++进阶——二叉搜索树BST
weixin_43635473的博客
04-21 748
C++进阶——二叉搜索树BST
【C++】二叉搜索树
fight_p的博客
11-22 1341
这是一篇万子以上的博客，本文更准确的说可以算上二叉树的进阶，详细讲解的二叉搜索树的插入，删除，查找，以及递归查找，递归删除，递归查找和构造，析构，拷贝构造，以及赋值重载，详细讲解什么是K模型，什么是KV模型，以及二叉搜索树应用场景，以及二叉搜索树性能分析
c++进阶_二叉搜索树
2401_83052144的博客
08-19 729
嗨喽大家好，时隔许久阿鑫又给大家带来了新的博客，c++进阶——二叉搜索树，下面让我们开始今天的学习吧！ c++进阶_二叉搜索树 内容安排说明 二叉搜索树实现 二叉树搜索树应用分析 二叉树进阶面试题 1. 内容安排说明 二叉树最重要的一点就是将每一个节点看成一个子树的根，对于理解会方便很多 map和set特性需要先铺垫二叉搜索树，而二叉搜索树也是一种树形结构 二叉搜索树的特性了解，有助于更好的理解map和set的特性 二叉树中部分面试题稍微有点难度，在前面讲解大家不容易接受，且时间长容易忘 有些O
【C++进阶：二叉树进阶】二叉搜索树的操作和key模型、key/value模型的实现 | 二叉搜索树的应用 | 二叉搜索树的性能分析
wh128341的博客
08-27 1536
从这里开始 C++ 的语法就告一段落了。二叉树在前面的数据结构和算法初阶中就讲过，本文取名为二叉树进阶是因为：我们之前说过，普通二叉树单纯的存储数据价值不大，因为仅仅是单纯的存储数据，你不如去使用顺序表和链表这样友善的多。它一定要套一种应用场景，二叉树的其中一个重要的应用场景就是我们本文中要学习的二叉搜索树。二叉搜索树又称搜索二叉树或二叉排序树 (如果你对下图的二叉搜索树中序遍历，你会发现它是有序并且升序的)，我们当前学习的搜索二叉树一般是不允许修改的，不过下面我们会学习搜索二叉树的 key_value 模
[C++进阶]二叉搜索树的应用
2301_80017277的博客
08-16 395
前面我们讲过key模型和Key-Value模型就是常见的两种的模型。
【C++】二叉树进阶（二叉搜索树）
是阿建吖！
05-26 1811
这篇文章详细介绍了二叉搜索树（BST）的基本概念、操作、代码实现以及应用。首先，介绍了BST的定义和核心操作，包括查找、插入和删除，并提供了非递归和递归两种实现方式。随后，通过具体的代码示例，展示了BST的节点设置、类框架构建以及查找、插入、中序遍历和删除函数的完整实现。此外，还探讨了BST在实际问题中的应用和性能分析。进阶部分则包含了一系列与二叉树相关的OJ题目，涵盖了从根据遍历序列构造二叉树，到层序遍历、公共祖先查找、BST与双向链表转换等多种场景，希望能够帮助读者深入理解二叉树的结构和应用。
【二叉搜索树】二叉搜索树的用法以及实现
m0_68617301的博客
04-28 1158
二叉搜索树的用法以及实现
C++ 二叉搜索树
cat_fish_rain的博客
07-01 150
二叉树在前面C数据结构阶段已经讲过，本节取名二叉树进阶是因为：1.先铺垫二叉搜索树，而二叉搜索树也是一种树形结构2.3.，在前面讲解，且时间长容易忘4.因此本节借二叉树搜索树，对二叉树部分进行收尾总结。
【C++进阶】二叉搜索树（来自二叉树的复仇）
2301_79551553的博客
04-01 1112
今天我们学习了二叉树里的扛把子——二叉搜索树，细致地模拟了他的接口的实现（递归与迭代），接着讲解了他的应用——K模型和KV模型，最后把KV写了一遍。
JAVA编程语言和数据结构第十一版 进阶版 编程答案
05-01
6. **树**：分层数据结构，如二叉树、二叉搜索树和红黑树等，用于搜索、排序和组织数据。 7. **图**：由节点和边组成，用于表示复杂的关系网络，如路网、社交网络等。 **进阶Java编程** - **并发编程**：Java提供了...
数据结构算法与应用-C++语言描述目录-综合文档
05-20
6. **查找算法**：包括顺序查找、二分查找、哈希查找以及二叉搜索树的查找方法。 7. **动态规划**：讲解动态规划的基本思想和模板，通过实例分析如背包问题、最长公共子序列、最短路径等经典问题。 8. **贪心算法*...
【进阶数据结构】二叉搜索树&经典习题讲解
East-sunrise的博客
03-20 997
二叉搜索树 —— 轻易找到你想要的
【二叉搜索树进阶】：平衡增长的优雅实现技巧
二叉搜索树（BST）是一种特殊的二叉树，它不仅能够存储数据，还能高效地执行数据的插入、查找和删除操作。其核心是每个节点都遵循这样的规则：对于任意节点N，其左子树上的所有节点的值都小于等于N的值，而其右子树...
【C++进阶之路】第三篇：二叉搜索树 & kv模型
Captain_ldx的博客
10-26 310
二叉搜索树概念、操作、实现；二叉搜索树的应用-kv模型；二叉搜索树的性能分析；
C++ STL中sort函数
weixin_43349440的博客
09-15 167
刷题中经常遇到，用于各种元素排序，可以自定义排序方式，vector、deque适用。详细讲解：https://zhuanlan.zhihu.com/p/36274119。，为避免QuickSort快排的递归调用带来过大的额外负荷，就改用。一旦分段后的数据量小于某个门槛。STL的sort算法，
CF C. Nikita and LCM
qq_74190237的博客
09-13 264
思维题.首先先对数组排序,考虑一种特殊情况,那就是如果数组最大值不能被其他数整除,这代表什么?代表其他数里面有某个质因子,最大值里面没有或者数量不管,所有最小公倍数都会大于最大值.那么其他情况的话,就可以确定所有的数都是最大数的因子,那么形成的最小公倍数也一定是最大数的因子,那么就可以枚举一下最大数的因子,就可以了.给长度为n的数组,求出最长的特殊子数组,如果子数组的最小公倍数不在原数组中,那么就是特殊的.
C++与QML的数据交互
qq_50679120的博客
09-11 520
这里没什么好说的，在C++中组合好json后，通过信号发送到qml中，qml中是可以解析json的。通过Q_PROPERTY属性，可以轻松地在QML中读取和修改数据，并将其更新到C++中，先创建一个类。在QML接收，直接通过data.can_id这样的形式去访问结构体中的元素。这两个也没什么好说的，在C++中直接发送信号就好了，在C++中声明并注册一个结构体。然后发送信号到QML中。
【C++】【网络】【Linux系统编程】单例模式，加锁封装TCP/IP协议套接字
最新发布
2301_79796701的博客
09-16 863
给系统，表明这个套接字所期望的、还未处理的（即还在等待被接受的连接）连接请求的最大队列长度。换句话说，它告诉系统内核为这个套接字分配多大的空间来存储尚未处理的连接请求。有关套接字编程的细节和更多的系统调用课参考《UNIX环境高级编程》一书，可以在如下网站搜索电子版，该书在第16章详细的介绍了各种接口。我们可以根据自己的需求，用面向对象的思想封装出接口简洁的类。在类似添加一个该类类型的指针，该指针是静态的并且是私有成员。结构体填充，为了使不同的地址格式能和套接字绑定，需要把对应的结构体强转成通用地址结构。
评论 36
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Mike!

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

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

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

打赏作者

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

抵扣说明：

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

余额充值