数据结构-----二叉搜索树（C++）

最新推荐文章于 2024-10-01 18:51:18 发布
最新推荐文章于 2024-10-01 18:51:18 发布
阅读量753 收藏 15
点赞数 24
文章标签： java 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dh15834384655/article/details/141035025
版权

一.概念介绍

二叉搜索树，它如果不为空树，则它满足条件：1.左子树不为空，则左子树上的所有节点值小于根节点的值 2.右子树不为空，则右子树上所有节点值大于根节点的值 3.它的左右子树也分别为二叉搜索树。

如同就是一个标准的二叉搜索树：

二.对二叉搜索树代码的实现

  1. key 搜索树模型 ：对节点的创建

模板 K ：表示的是所储存的值为K类型。

template<class K>
struct BSTreeNode
{
    BSTreeNode<K>* _left;
    BSTreeNode<K>* _right;
    K _key;
    
    // 对节点的创建
BSTreeNode(const K& key)
    :_left(nullptr)
    , _right(nullptr)
    , _key(key)
{}
​
};

对该模型其他功能的实现：

template<class K>
class BSTree
{
    //对 命名 的简化
    typedef BSTreeNode<K>  Node;
public:
    // 创建新的节点，插入新的节点
    bool Insert(K& e)
    {
        if (_root == nullptr)
        {
            _root = new Node(e);
            return true;
        }
​
        Node* cur = _root;
        while (cur)
        {
            if (cur->_key > e)
            {
                if (cur->_left)
                    cur = cur->_left;
                else
                    cur->_left = new Node(e), cur = nullptr;
            }
            else if (cur->_key < e)
            {
                if (cur->_right)
                    cur = cur->_right;
                else
                    cur->_right = new Node(e), cur = nullptr;
            }
            else
            {
                return false;
            }
        }
​
        return true;
    }
    // 删除key == e 的相关节点   细致讲解请看下面难点解析
    bool Erase(const K& e)
    {
        Node* parent = nullptr;
        Node* cur = _root;
​
        while (cur)
        {
            if (cur->_key < e)
            {
                parent = cur;
                cur = cur->_right;
            }
            else if (cur->_key > e)
            {
                parent = cur;
                cur = cur->_left;
            }
            else
            {
                //删除
                if (cur->_left == nullptr)
                {
                    if (cur == _root)
                    {
                        _root = cur->_right;
                    }
                    else
                    {
                        if (cur == parent->_left)
                        {
                            parent->_left = cur->_right;
                        }
                        else
                        {
                            parent->_right = cur->_right;
                        }
                    }
​
                    delete cur;
                }
                else if (cur->_right == nullptr)
                {
                    if (cur == _root)
                    {
                        _root = cur->_left;
                    }
                    else
                    {
                        if (cur == parent->_left)
                        {
                            parent->_left = cur->_left;
                        }
                        else
                        {
                            parent->_right = cur->_left;
                        }
                    }
​
                    delete cur;
                }
                else
                {
                    Node* rightMinParent = cur;
                    Node* rightMin = cur->_right;
                    while (rightMin->_left)
                    {
                        rightMinParent = rightMin;
                        rightMin = rightMin->_left;
                    }
​
                    swap(cur->_key, rightMin->_key);
​
                    if (rightMinParent->_left == rightMin)
                        rightMinParent->_left = rightMin->_right;
                    else
                        rightMinParent->_right = rightMin->_right;
​
                    delete rightMin;
                }
​
                return true;
            }
​
        }
​
        return false;
    }
    //找到相关的值的节点
    bool Find(const K& e)
    {
        Node* cur = _root;
        while (cur)
        {
            if (cur->_key < e)
            {
                cur = cur->_right;
            }
            else if (cur->_key > e)
            {
                cur = cur->_left;
            }
            else
            {
                return true;
            }
        }
​
        return false;
    }
    //中序遍历
    void InOrder()
    {
        _InOrder(_root);
    }
private:
    void _InOrder(Node* root)
    {
        if (root == nullptr)
        {
            return;
        }
​
        _InOrder(root->_left);
        cout << root->_key << " ";
        _InOrder(root->_right);
    }
private:
    Node* _root = nullptr;
};
// 附带的一组测试样例
void TestBSTree1()
{
    int a[] = { 8, 3, 1, 10, 6, 4, 7, 14, 13 };
    BSTree<int> t1;
    for (auto e : a)
    {
        t1.Insert(e);
    }
​
    t1.InOrder();
​
    t1.Erase(3);
    cout << endl;
    t1.Erase(8);
​
    t1.InOrder();
​
    for (auto e : a)
    {
        cout << endl;
        t1.Erase(e);
        t1.InOrder();
​
    }
}

三.二叉搜素树难点删除解析

四. key_value 的版本

与 key 的二叉搜素树基本类似，这里不做详细的说明：

仅仅不同的是有两个模板参数，K 与 V两个模板参数类型。

    namespace key_value
{
    //key 与 value 版本的
    template<class K, class V>
    struct BSTreeNode
    {
        BSTreeNode<K, V>* _left;
        BSTreeNode<K, V>* _right;
        K _key;
        V _value;
​
        BSTreeNode(const K& key,const V& value)
            :_left(nullptr)
            ,_right(nullptr)
            ,_key(key)
            ,_value(value)
        {}
    };
    
    template<class K,class V>
    class BSTree
    {
        typedef BSTreeNode<K, V> Node;
    public:
        bool Insert(const K& key, const V& value)
        {
            if (_root == nullptr)
            {
                _root = new Node(key,value);
                return true;
            }
    
            Node* cur = _root;
            while (cur)
            {
                if (cur->_key > key)
                {
                    if (cur->_left)
                        cur = cur->_left;
                    else
                        cur->_left = new Node(key,value), cur = nullptr;
                }
                else if (cur->_key < key)
                {
                    if (cur->_right)
                        cur = cur->_right;
                    else
                        cur->_right = new Node(key,value), cur = nullptr;
                }
                else
                {
                    return false;
                }
            }
    
            return true;
        }
​
​
        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 cur;
        }
    
        bool Erase(const K& key)
        {
            Node* cur = _root;
            Node* parent = nullptr;
    
            while (cur)
            {
                if (cur->_key > key)
                {
                    parent = cur;
                    cur = cur->_left;
                }
                else if(cur->_key <key)
                {
                    parent = cur;
                    cur = cur->_right;
                }
                else
                {
                    if (cur->_left == nullptr)
                    {
                        if (_root == cur)
                        {
                            _root = _root->_right;
                        }
                        else
                        {
                            if (cur == parent->_left)
                            {
                                parent->_left = cur->_right;
                            }
                            else
                            {
                                parent->_right = cur->_right;
                            }
                        }
    
                        delete cur;
                    }
                    else if (cur->_right == nullptr)
                    {
                        if (_root == cur)
                        {
                            _root = _root->_left;
                        }
                        else
                        {
                            if (cur == parent->_left)
                            {
                                parent->_left = cur->_left;
                            }
                            else
                            {
                                parent->_right = cur->_left;
                            }
                        }
    
                        delete cur;
                    }
                    else
                    {
                        Node* leftMax = cur->_left;
                        Node* leftMaxP = cur;
                        while (leftMax ->_right!= nullptr)
                        {
                            leftMaxP = leftMax;
                            leftMax = leftMax->_right;
                        }
    
                        swap(cur->_key, leftMax->_key);
                        swap(cur->_value, leftMax->_value);
​
​
•               
​
                        if (leftMaxP->_right == leftMax)
                        {
                            leftMaxP->_right = leftMax->_left;
                        }
                        else
                        {
                            leftMaxP->_left = leftMax->_left;
                        }
    
                        delete leftMax;
                    }
    
                    return true;
                }
            }
    
            return false;
            
        }
    
        void InOrder()
        {
            _InOrder(_root);
            cout << endl;
        }
    private:
            void _InOrder(Node* root)
            {
                if (root == nullptr)
                {
                    return;
                }
    
                _InOrder(root->_left);
                cout << root->_key << ":" << root->_value << endl;
                _InOrder(root->_right);
            }
    private:
        Node* _root = nullptr;
    };
    
    void TestBSTree2()
    {
        BSTree<string, string> dict;
        dict.Insert("string", "字符串");
        dict.Insert("left", "左边");
        dict.Insert("insert", "插入");
    
        string str;
        while (cin >> str)
        {
            BSTreeNode<string, string>* ret = dict.Find(str);
            if (ret)
            {
                cout << ret->_value << endl;
            }
            else
            {
                cout << "无此单词，请重新输入" << endl;
            }
        }
    }
    
    void TestBSTree3()
    {
        // 统计次数
        string arr[] = { "苹果", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜",
​
"苹果", "香蕉", "苹果", "香蕉","苹果","草莓", "苹果","草莓" };
        BSTree<string, int> countTree;
        for (const auto& str : arr)
        {
            auto ret = countTree.Find(str);
            if (ret == nullptr)
            {
                countTree.Insert(str, 1);
            }
            else
            {
                ret->_value++;
            }
        }
    countTree.InOrder();
}
​
void TestBSTree4()
{
    BSTree<string, string> dict;
    dict.Insert("string", "字符串");
    dict.Insert("left", "左边");
    dict.Insert("insert", "插入");
    dict.Insert("hello", "你好");
    dict.Insert("love", "爱你");
    dict.Insert("rain", "雨");
    dict.Insert("banana", "香蕉");
    dict.Insert("ant", "蚂蚁");
    dict.Insert("zabro", "斑马");
    dict.Insert("yoyo", "悠悠球");
​
    dict.InOrder();
    dict.Erase("left");
    dict.Erase("love");
    dict.InOrder();
}
​
}

五. 总结

        二叉搜素树非常重要对于C++的学习来说，之后设计到的容器set 和 map 所依赖的基础都是 二叉搜索树，二叉搜素树的删除是相对难的重点，插入的时候是有去重操作的，对于插入重复的值是不能够成功插入的。希望大家能好好吸收这一章所讲述的内容，仔细研究代码，自己画图进行理解。

dh大羊123456
关注
C++---二叉搜索树
qq_47406941的博客
05-19 652
一、二叉搜索树的概念 二叉搜索树又称二叉排序树，它是一颗空树或者是具有以下性质的树： 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 它的左右子树也分别为二叉搜索树 二、二叉搜索树的操作 1、查找 基本思路： 根节点为空，返回false 根节点不为空，比较根节点和要找的值是否相等，相等返回true。 根节点和要找的值不想等时，判断跟节点和要找的值的关系。 如果根节点小于要找到的值，则在右子树找 如果根节点大于要
二叉树-基于C++实现的二叉搜索树.zip
04-26
总之，二叉搜索树是一种重要的数据结构，它在C++中的实现涉及到节点结构的设计和插入、查找、删除等操作的实现。理解并掌握二叉搜索树的原理和操作是提升算法能力的关键，而自平衡二叉搜索树则进一步提高了在大规模...
C++ 数据结构--二叉搜索树的实现
凡事都是靠练习
08-19 1095
数据结构中二叉搜索树的实现
数据结构题目-二叉排序树
weixin_61133168的博客
12-06 1548
题目描述给定一个序列，使用该序列生成二叉排序树（也叫二叉搜索树，BST），然后以本题规定方法输出该二叉排序树。 例： 给定一个序列：43 25 29 67 17 88 54 47 35 62 以第一个数字（43）为根节点，然后将后面的数字依输入次序逐个添加至该树中，得到一个二叉排序树，如下图所示。 然后先序遍历上面这个树，并按行输出数字。 其中每个子节点的输出前，需要相较于其父节点前多四个普通空格。 当某个节点为叶子节点（即无子节点），则该节点的左右叶子节点均不用输出。 而当某个节点仅有左叶子节点或右叶子节
数据结构 - C/C++ - 树
0xCC说逆向
07-03 945
删除节点同时存在左子树以及右子树 - 删除节点左子树内容挂在删除节点右子树中的左子节点，删除节点的右子节点替换被删除节点。操作 - 失衡节点的左子节点作为新的根节点，将失衡节点作为新的根节点的右子节点。叶子节点是指没有任何子节点的节点。假如删除节点存在一个子节点，子节点替换被删除节点位置，并对应指向。根节点的左子树不为空，则左子树上的所有节点的值均小于它根节点的值。根节点的右子树不为空，则右子树上的所有节点的值均大于它根节点的值。节点是树结构的最顶端节点，它没有父节点，并且是二叉树结构的起点。
数据结构-二叉搜索树、AVL树
qq_46895011的博客
11-30 1057
K key;// 关键码E data;// 数据域// 左子女和右子女BSTNode() : left(NULL), right(NULL) {} // 构造函数BSTNode(K x, E d) : key(x), data(d), left(NULL), right(NULL) {} // 构造函数~BSTNode() {} // 析构函数public:BST() : root(NULL) {} // 构造函数~BST() {} // 析构函数// 搜索x// 赋值// 创建。
数据结构--二叉搜索树的实现
qq_63440853的博客
12-29 1024
介绍了二叉搜索树的概念以及插入，删除，遍历和其应用的场景，与key/value的应用与代码
C++--二叉搜索树
m0_74085682的博客
08-19 651
问题：如果退化成单支树，二叉搜索树的性能就失去了。个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二。a、从根开始比较，查找，比根大则往右边走查找，比根小则往左边走查找。在二叉搜索树中检索该单词是否存在，存在则拼写正确，不存在则拼写错误。插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的性能。b、最多查找高度次，走到到空，还没找到，这个值不存在。叉搜索树的深度的函数，即结点越深，则比较次数越多。，统计成功后，给定单词就可快速找到其出现的次数，
【C++ STL】-- 二叉搜索树
weixin_64609308的博客
11-25 2503
详细配图讲解：搜索二叉树的构建与函数接口实现
数据结构-二叉排序树（C++代码实现）
随风而行的博客
12-23 3345
数据结构中二叉排序树的C++代码实现 有关参考博客：https://blog.csdn.net/kang___xi/article/details/80392565 Code : /* 二叉排序树（二叉搜索树）：树上所有结点的左子树的值均小于该节点的值，右子树的值均大于该节点的值 https://blog.csdn.net/kang___xi/article/details/80392565 */ #include<iostream> #include<queue> using n
C++数据结构-二叉查找树和平衡二叉树
01-03
实现了二叉查找树的查找、插入...实现了平衡二叉树（AVL树）的查找、插入、删除和迭代遍历的完整功能，插入时的各种旋转操作按照经典数据结构教材实现，并有详细的注释和说明。删除操作和相关旋转方法有单独描述文档。
数据结构课程设计C++B-tree
06-19
同时，你可能还需要分析B树与其他数据结构（如二叉搜索树、红黑树）的优劣，以及在特定场景下为何选择B树。 总结来说，这个数据结构课程设计项目是一个很好的机会，让你深入理解和实践C++编程，掌握高级数据结构B树...
数据结构实验报告-查找-B-树基本操作的实现10分-实验内容与要求.docx
03-11
数据结构实验报告主要关注B-树的基本操作，这是一种平衡的多路查找树，适用于大量数据的存储和检索。实验的目的是让学生掌握B-树插入、删除和查找算法，加深对数据结构的理解。 B-树的核心特性包括： 1. 每个节点...
JavaScript ArrayBuffer的读写与类型转换
最新发布
白瑕 的博客
10-01 420
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
spring-boot 整合 mybatis
m0_72168501的博客
09-29 529
spring boot 整合 mybatis
Java内存布局
阿呆的专栏
10-01 793
64位 JVM 不启用指针压缩时：Object Header 大小是16字节。64位 JVM 启用指针压缩时（默认）：Object Header 大小是12字节。32位 JVM：Object Header 大小是8字节。JVM在默认情况下启用指针压缩，但如果堆内存超过32GB，就会禁用指针压缩。32GB是压缩指针的最大寻址范围。超过32GB的堆内存中，压缩指针带来的性能提升并不显著，而且需要解压指针反而可能增加开销。
【开源免费】基于SpringBoot+Vue.JS校园资料分享平台（JAVA毕业设计）
customer08的博客
09-30 1240
校园资料分享平台是一个B/S模式系统，采用Spring Boot框架作为开发技术，MYSQL数据库设计开发，充分保证系统的稳定性。系统具有界面清晰、操作简单，功能齐全的特点，使得校园资料分享平台管理工作系统化、规范化。
C#基础：掌握控制流语句，构建灵活的程序逻辑
学习和分享
09-28 325
在C#中，控制流语句是用来控制程序执行流程的重要部分。它们允许你根据条件执行不同的代码块，或者重复执行某些代码块直到满足特定条件。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值