二叉搜索树

最新推荐文章于 2024-06-02 10:28:16 发布
最新推荐文章于 2024-06-02 10:28:16 发布
阅读量129 收藏 3
点赞数 5
分类专栏： 数据结构 c++ 文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61567378/article/details/126539528
版权

文章目录

二叉搜索树

概念

左子树的值小于根，右子树的值大于根
根的值大于左子树，小于右子树
在这里插入图片描述
二叉搜索树就是用来查找的

假如我们要查找7：7比3大，到3的右子树=5，7比5大，到5的右子树7，查找到了

二叉搜索树的中序遍历，可以实现从小到大排序的遍历

时间复杂度

最坏情况1：查找：高度次
最坏情况2：O（N）:
如下图:这个效率就特别差，和单链表没有区别
在这里插入图片描述
后续用AVL树，RB树

应用

搜索树的应用

  1. 搜索，key搜索模型，key/value模型
  2. 排序+去重

key模型
可以用来判断值在不在，效率很搞O(logN)
应用场景

  1. 搜索树存储小区业主的车牌号，扫描，存在就通过，不存在就不让过
  2. 搜索树存储同学的学号
  3. 给一个英文作文，检查里面的单词拼写是否正确（我们把单词都存放进去，进行搜索存在与否）

key/value模型
通过一个值查找另外一个值
应用场景

  1. 高铁站刷身份证进站，用身份证查早是否右买票

实现

key模型

树的节点

template <class K>

    struct BSTNode
    {
        K _val;//节点的值
        BSTNode<K> *_left;//左子树
        BSTNode<K> *_right;//右子树
        BSTNode(const K &val)//构造函数
            : _val(val), _right(nullptr), _left(nullptr)
        {
        }
    };

BStree的类

template <class K>
    struct BSTree
    {
        typedef BSTNode<K> Node;//把每个节点进行重命名

    private:
        Node *_root;//节点

    public:
        BSTree()
            : _root(nullptr)
        {
        }
};
Insert

在这里插入图片描述

非递归版本

  1. 插入一个值，从根往下面走，要插入的值比它大，走右边，比它小走左边，如果这个值已近存在了，就不要插入
  2. 直到走到空，就是我们要插入的地方
  3. 我们需要把这个节点链接上去，所以我们需要空节点对应的父节点，父节点连接上新添加的节点
  4. 如果根节点就是空，直接插入在根节点即可
    例如：我们插入一个10

10>8,先走右边，到9，10>9走右边，走到了空，把它插入到这个地方

        bool Insert(const K &key) //非线性叫做insert
        {
            //插入重复的值，就返回失败
            if (_root == nullptr)//一个节点都没有
            {
                _root = new Node(key);
                return true;
            }
            else
            {
                Node *cur = _root;//cur用来走到要插入的位置
                Node *prev;//prev用来记录插入位置的父节点
                while (cur)
                {
                    if (cur->_val > key)//比要插入的值大，往左走
                    {
                        prev = cur;
                        cur = cur->_left;
                    }
                    else if (cur->_val < key)//比要插入的值小，往右走
                    {
                        prev = cur;
                        cur = cur->_right;
                    }
                    else//相等就别走了
                    {
                        return false;
                    }
                }
                //走到这里cur就是空
                cur = new Node(key);
                if (prev->_val < key)//父节点小于插入节点
                {
                    prev->_right = cur;//连接到父节点的右边
                }
                else
                {
                    prev->_left = cur;
                }
                return true;
            }
        }

递归版本

我们使用引用就不需要用父节点来连接
例如:我们链接上的节点为10，走到9的右，root即是空，也是9右指针的别名

        bool _InsertR(Node *&root, const K &key) //这里要多一个引用,指针的引用，进行修改才使用引用
        {
            if (root == nullptr) //走到空就插入,引用，root是上面的root->right别名
            {
                root = new Node(key); //直接链接上了 ，都是前面的别名，都连接起来了
                return true;
            }
            if (root->_val > key)
            {
                return _InsertR(root->_left, key);
            }
            else if (root->_val < key)  
            {
                return _InsertR(root->_right, key);
            }
            else
            {
                return false;
            }
        }

        bool InsertR(const K &key) //有序的方式就会变成单边树，栈爆了
        {
            //递归有根，都要套一个子函数
            return _InsertR(_root, key);
        }
Find

非递归版本

从根节
点往下走，比它大，走右边，比它小走左边，相等就找到了，走到空就说明没找到

        bool Find(const K &key) //查找
        {
            Node *cur = _root;
            while (cur)
            {
                if (cur->_val > key)
                {
                    cur = cur->_left;
                }
                else if (cur->_val < key)
                {
                    cur = cur->_right;
                }
                else
                {
                    return true;//在这中间，就说明找到了
                }
            }
            return false;//走到空就没找到
        }

递归版本

        Node *FindR(const K &key)
        {
            return _Find(_root, key);
        }
        Node *_FindR(Node *root, const K &key)
        {
            if (root == nullptr)
            {
                return nullptr;
            }
            if (root->_val == key)
            {
                return root;
            }
            else if (root->_val > key)
            {
                return _FindR(root->_left, key);
            }
            else
            {
                return _FindR(root->_right, key);
            }
        }
Erase

在这里插入图片描述

非递归版本

  1. 先找到要查找到要删除的节点
  2. 如果要删除的节点左子树为空，如果它是它父亲的左节点，它的父亲节点的左节点连接上删除节点的右指针

例如删除3，左为空，3是1的右节点，把1的右节点，连接到3的右节点

  1. 如果要删除的节点右子树为空，它为父节点的右节点，把它父节点的右节点连接到删除节点的左节点

例如删除10，右为空，10 是9的右节点，把10的左节点，连接到9的右节点上

  1. 如果要删除的节点左右子树都为空，要使用替换法删除，可以把要删除的节点的右子树的最左边或者要删除节点的左子树的最右边，把它和要删除节点进行替换，在把那个替换的节点删除

例如删除5，左右节点都不为空，把5右节点的最左边和5进行替换，

        bool Erase(const K &key)
        {
            //先查找,删除之后要保持搜索二叉树的状态
            //有两个儿子，用左子树的最右节点，或者右子树的最左节点来进行替换删除
            //先找到要删除的值，还要找到它的父亲
            Node *cur = _root;
            Node *parent = nullptr;
            while (cur)
            {
                if (cur->_val < key)
                {
                    parent = cur;
                    cur = cur->_right;
                }
                else if (cur->_val > key)
                {
                    parent = cur;
                    cur = cur->_left;
                }
                else
                {
                    //这里面就找到了
                    //如果删除的是根节点，左为空，或右为空，没有父亲，我们还要单独处理

                    if (cur->_left == nullptr) //左为空
                    {
                        if (parent == nullptr)//删除的是根节点
                        {
                            _root = _root->_right;
                        }
                        else
                        {
                            if (parent->_left == cur)
                            {
                                //我是父亲的左
                                //父亲的左，指向我的右
                                parent->_left = cur->_right;
                            }
                            else if (parent->_right == cur)
                            {
                                parent->_right = cur->_right;
                            }
                        }
                        delete cur;
                        cur = nullptr;
                    }
                    else if (cur->_right == nullptr) //右为空
                    {
                        if (parent == nullptr)
                        {
                            _root = _root->_left;
                        }
                        else
                        {
                            if (parent->_left == cur)
                            {
                                //我是父亲的左
                                //父亲的左，指向我的右
                                parent->_left = cur->_left;
                            }
                            else if (parent->_right == cur)
                            {
                                parent->_right = cur->_left;
                            }
                        }
                        delete cur;
                        cur = nullptr;
                    }
                    else
                    {
                        //都不为空
                        //我们用右子树的最左节点,替换法删除
                        Node *node = cur->_right;
                        Node *parent = cur;
                        if (node->_left != nullptr)//右子树右左节点
                        {

                            while (node->_left)
                            {
                                parent = node;
                                node = node->_left;
                            }
                            swap(cur->_val, node->_val);
                            parent->_left = node->_right;
                            delete node;
                            node = nullptr;
                        }
                        else//右子树没有左节点，直接把父和它的右节点连接起来即可
                        {
                            swap(cur->_val, node->_val);
                            parent->_right = node->_right;
                            delete node;
                            node = nullptr;
                        }
                    }

                    return true;
                }
            }
            return false;
        }

递归版本

        Node *EraseR(const K &key)
        {
            _EraseR(key, _root);
        }
        bool _EraseR(const K &key, Node *&root)
        {
            if (root == nullptr)
                return false;
            if (root->_val > key)
            {
                return _EraseR(key, root->_left);
            }
            else if (root->_val < key)
            {
                return _EraseR(key, root->_right);
            }
            else
            {
                Node *del = root;
                if (root->_left == nullptr)
                {

                    root = root->_right;
                }

                else if (root->_right == nullptr)
                {
                    root = root->_left;
                }
                else
                {
                    //左右都不为空
                    //找到右子树的最左边，找替代节点

                    Node *min = root->_right;
                    while (min->_left)
                    {
                        min = min->_left;
                    }
                    swap(min->_val, root->_val); //把替代节点替换上去，后面只需要再递归的去删除交换的节点就可以了
                    //递归到右子树的最左节点去删除
                    return _EraseR(key, root->_right);
                }
                delete del;
                return true;
            }
        }
InOrder

中序遍历，左根右
在类里面递归遍历，我们可以使用子函数，这样外部就不需要用类里面的私有成员变量

        void InOrder()
        {
            //套一个子函数就可以了
            _InOrder(_root);
        }

        void _InOrder(Node *root) //在外面或得不到根
        {
            if (root == nullptr)
                return;
            _InOrder(root->_left);
            cout << root->_val << " ";
            _InOrder(root->_right);
        }

KV模型

    template <class K,class V>

    struct BSTNode
    {
        K _key;
        V _val;
        BSTNode<K,V> *_left;
        BSTNode<K,V> *_right;
        BSTNode(const K &key,const V& val)
            : _val(val), _right(nullptr), _left(nullptr),_key(key)
        {
        }
    };

    //比如：key是身份证，value就是票的信息，vector<info> _vinfo
    template <class K,class V>
    struct BSTree
    {
        typedef BSTNode<K,V> Node;

    private:
        Node *_root;

    public:
        BSTree()
            : _root(nullptr)
        {
        }

        bool Insert(const K &key,const V& val) //非线性叫做insert
        {
            //插入重复的值，就返回失败
            if (_root == nullptr)
            {
                _root = new Node(key,val);
                return true;
            }
            else
            {
                Node *cur = _root;
                Node *prev;
                while (cur)
                {
                    if (cur->_key > key)
                    {
                        prev = cur;
                        cur = cur->_left;
                    }
                    else if (cur->_key < key)
                    {
                        prev = cur;
                        cur = cur->_right;
                    }
                    else
                    {
                        return false;
                    }
                }
                cur = new Node(key,val);
                if (prev->_key < key)
                {
                    prev->_right = cur;
                }
                else
                {
                    prev->_left = cur;
                }
                return true;
            }
        }

        

        Node* Find(const K &key) //查找,返回对应的节点
        {
            Node *cur = _root;
            while (cur)
            {
                if (cur->_key > key)
                {
                    cur = cur->_left;
                }
                else if (cur->_key < key)
                {
                    cur = cur->_right;
                }
                else
                {
                    return cur;//找到就返回对应的节点
                }
            }
            return nullptr;//没有找到就返回空
        }
        void InOrder()
        {
            //套一个子函数就可以了
            _InOrder(_root);
        }

        void _InOrder(Node *root) //在外面或得不到根
        {
            if (root == nullptr)
                return;
            _InOrder(root->_left);
            cout << root->_key << " ";
            _InOrder(root->_right);
        }

        bool Erase(const K &key)
        {
            //先查找,删除之后要保持搜索二叉树的状态
            //有两个儿子，用左子树的最右节点，或者右子树的最左节点来进行替换删除
            //先找到要删除的值，还要找到它的父亲
            Node *cur = _root;
            Node *parent = nullptr;
            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 (parent == nullptr)
                        {
                            _root = _root->_right;
                        }
                        else
                        {
                            if (parent->_left == cur)
                            {
                                //我是父亲的左
                                //父亲的左，指向我的右
                                parent->_left = cur->_right;
                            }
                            else if (parent->_right == cur)
                            {
                                parent->_right = cur->_right;
                            }
                        }
                        delete cur;
                        cur = nullptr;
                    }
                    else if (cur->_right == nullptr) //右为空
                    {
                        if (parent == nullptr)
                        {
                            _root = _root->_left;
                        }
                        else
                        {
                            if (parent->_left == cur)
                            {
                                //我是父亲的左
                                //父亲的左，指向我的右
                                parent->_left = cur->_left;
                            }
                            else if (parent->_right == cur)
                            {
                                parent->_right = cur->_left;
                            }
                        }
                        delete cur;
                        cur = nullptr;
                    }
                    else
                    {
                        //都不为空
                        //我们用右子树的最左节点,替换法删除
                        Node *node = cur->_right;
                        Node *parent = cur;
                        if (node->_left != nullptr)
                        {

                            while (node->_left)
                            {
                                parent = node;
                                node = node->_left;
                            }
                            swap(cur->_val, node->_val);
                            swap(cur->_key, node->_key);
                            parent->_left = node->_right;
                            delete node;
                            node = nullptr;
                        }
                        else
                        {
                            swap(cur->_val, node->_val);
                            swap(cur->_key, node->_key);
                            parent->_right = node->_right;
                            delete node;
                            node = nullptr;
                        }
                    }

                    return true;
                }
            }
            return false;
        }

        
    };
Zevin~
关注
  • 5
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 7
    评论
专栏目录
C#二叉搜索树插入算法实例分析
01-21
本文实例讲述了C#二叉搜索树插入算法。分享给大家供大家参考。具体实现方法如下： public class BinaryTreeNode { public BinaryTreeNode Left { get; set; } public BinaryTreeNode Right { get; set; } public...
二叉排序树（二叉查找树、二叉搜索树）（图解+完整代码）
热门推荐
weixin_54186646的博客
04-25 7万+
图解二叉排序树（二叉查找树、二叉搜索树）的插入操作、查找操作、删除操作以及完整的代码实现
【Java 数据结构】实现一个二叉搜索树
程序猿教你打篮球的博客
01-09 6855
本期主要讲解： 1、认识二叉搜索树 2、实现一个二叉搜索树 2.1 成员变量 2.2 insert 方法 2.3 search 方法 2.4 remove 方法(重点) 3、二叉搜索树总结
二叉搜索树详解
拂晓123的博客
06-17 5685
写在前面        本文主要分为三个部分。        第一部分介绍了二叉搜索树的基本性质。        第二部分全面详细地讲述了二叉搜索树的各种基本操作...
二叉搜索树(二叉排序树)
爱敲代码的三毛的博客
09-09 4万+
一.概念 二叉搜索树又称二叉排序树，具有以下性质： 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 它的左右子树也分别为二叉搜索树 注意：二叉搜索树中序遍历的结果是有序的 二、基本操作 1.查找元素 思路：二叉搜索树的左子树永远是比根节点小的，而它的右子树则都是比根节点大的值。当前节点比要找的大就往左走，当前元素比要找的小就往右走 public Node search(int key) { if(root ==
java二叉搜索树详解
m0_57180439的博客
02-21 2048
文章目录一、概念二、相关操作1.查找2.插入2.删除实现 提示：以下是本篇文章正文内容，下面案例可供参考 一、概念 二叉搜索树又称二叉排序树 它或者是一棵空树，或者是具有以下性质的二叉树: 1.若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 2.若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 3.它的左右子树也分别为二叉搜索树 （图片来自比特就业课） 二、相关操作 1.查找 （图片来自比特就业课） 代码如下（示例）： 2.插入 代码如下（示例）： 2.删除 实现 ....
判断二叉树是否为二叉搜索树
明朗晨光的专栏
07-01 5672
利用二叉树递归套路判断是否为二叉搜索树
二叉搜索树（BinarySearchTree）
潜心钻研技术
03-05 1382
二叉搜索树（BinarySearchTree） 文章目录二叉搜索树（BinarySearchTree）二叉搜索树的概念如何定义 二叉搜索树的节点 && 二叉搜索树查找插入删除二叉搜索树的缺点二叉搜索树的应用 二叉搜索树的概念 搜索二叉树满足一下条件： 是一棵二叉树 这可树上的任意一个节点满足：若他的右子树不为空，则右子树上的所有节点的值大于该节点的值 这可树上的任意一个节点满足：若他的左子树不为空，则左子树上的所有节点的值小于该节点的值 它的的左子树和右子树也是二叉搜索树 例如下图就是一
Java二叉搜索树
m0_64318128的博客
11-05 1316
二叉搜索树的概念、性质，二叉搜索树的实现
构建二叉搜索树
一个努力练习代码的小菜鸟的博客
04-12 1012
二叉搜索树 (BST) 递归定义为具有以下属性的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值 若它的右子树不空，则右子树上所有结点的值均大于或等于它的根结点的值 它的左、右子树也分别为二叉搜索树 给定二叉树的具体结构以及一系列不同的整数，只有一种方法可以将这些数填充到树中，以使结果树满足 BST 的定义。 请你输出结果树的层序遍历。 示例如图 1 和图 2 所示。 输入格式 第一行包含一个正整数 N，表示树的结点个数。 所有结点的编号为 0∼N−1，并且编号为
Java创建二叉搜索树,实现搜索,插入,删除的操作实例
08-28
下面小编就为大家分享一篇Java创建二叉搜索树,实现搜索,插入,删除的操作实例，具有很好的参考价值，希望对大家有所帮助
二叉搜索树实例练习
09-05
一棵二叉查找树是按二叉树结构来组织的。这样的树可以用链表结构表示，其中每一个结点都是一个对象
C-数据结构-树状存储基本概念
aqiangdeba的博客
05-27 752
’’树状存储基本概念深度（层数）度（子树个数）叶子孩子兄弟堂兄弟二叉树：满二叉树：完全二叉树：存储：顺序，链式树的遍历：按层遍历，先序，中序，后序‘’’树是计算机科学中的一种重要数据结构。以下是关于树的基本概念和类型的详细介绍。
树--搜索二叉树
Beau Wang
05-29 799
线索二叉树充分利用了指针空间，同时又便于寻找结点的前驱结点和后继结点。线索二叉树适用于经常需要遍历寻找结点前驱或者后继结点的二叉树。
数据结构复习指导之交换排序（冒泡排序，快速排序）
最新发布
心碎烤肠的博客
06-02 1191
所谓交换，是指根据序列中两个元素关键字的比较结果来对换这两个记录在序列中的位置。 基于交换的排序算法很多，本书主要介绍冒泡排序和快速排序， 其中冒泡排序算法比较简单，一般很少直接考查，通常会重点考查快速排序算法的相关内容。
【数据结构：排序算法】堆排序（图文详解）
djdjiejsn的博客
05-29 1736
堆排序，详细理解
数据库服务器的三种数据结构
HuJunFeng123456的博客
05-30 147
例如：每条记录固定20KB，如果读取第二条记录，就能直接跳跃到位置 (起始索引 + 20 * 1024 * 1)来读取。数据库设计时一般每部分固定字节数，查询时就能根据主键和索引，快速的跳跃读取指针，定位到目标位置读取。一般按照固定的格式来组织数据，例如数据表的每个字段占用固定的字节，对应的是某个结构体属性。如果是更新，还需要把内存数据写入磁盘，覆盖旧的数据，或者追加数据到磁盘文件的末尾。以逻辑抽象结构来组织数据，方便数据的查询，新增，修改和删除。3、调用对应的方法，读取磁盘文件的部分数据进入内存。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Zevin~

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

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

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

打赏作者

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

抵扣说明：

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

余额充值