搜索树BinarySearchTree

最新推荐文章于 2025-05-08 23:56:28 发布
最新推荐文章于 2025-05-08 23:56:28 发布
阅读量189 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构 搜索树 BinarySearchTree
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/aisheng_huo/article/details/72810401
版权

搜索树

定义

二叉搜索树（Binary Search Tree）， 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉排序树。

组成

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

    BSNode<K>(const K& key)
        :_left(NULL)
        ,_right(NULL)
        ,_key(key)
    {}
};

左右孩子_left,_right,用来比较大小的key值

主要实现操作

插入

当前节点为空，则直接给_root根节点插入。 
比根节点大，插入到根节点的右树上。 
比根节点小，插入到根节点的左树上。

插入代码

bool Insert(const K& key)
    {
        if (NULL == _root)
        {
            _root = new Node(key);
            return true;
        }

        Node* parent = NULL;
        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;
            }
        }

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

删除

递归版

比当前节点大，到当前节点的右树上查找并删除； 
比当前节点大，到当前节点的右树上查找并删除； 
当前节点就是需要删除的节点 
1.找到当前节点右子树的最左节点，与要被删除节点交换，从当前节点的父节点继续递归删除。

bool _RemoveR(Node*& cur, const K& key)
    {
        if (NULL == cur){
            return false;
        }

        if (cur->_key < key){
            return _RemoveR(cur->_right, key);
        }
        else if (cur->_key > key){
            return _RemoveR(cur->_left, key);
        }
        else{
            //找到为key的节点cur
            Node* del = cur;
            if (NULL == cur->_left){
                cur = cur->_right;
            }
            else if (NULL == cur->_right){
                cur = cur->_left;
            }
            else
            {
                Node* tmp = cur;
                Node* parent = cur->_right;
                cur = cur->_left;
                while (cur)
                {
                    parent = cur;
                    cur = cur->_left;
                }
                //parent现在是以被删除节点为根，右子树的最左节点
                swap(parent->_key, tmp->_key);

                return _RemoveR(parent, key);
            }
            delete del;
            return true;
        }
        return false;
    }
非递归版

找到需要删除的节点，进行如下判断 
1.del（需要删除的节点）的左孩子为空时,判断del是否为根节点，不是根节点，再判断是parent的左孩子还是右孩子,判断好后进行删除 
2.del的右孩子为空时与左类似 
3.del的左右孩子都不为空，使用替换法

    bool Rmove(const K& key)
    {
        if (NULL == _root){return true;}

        Node* cur = _root;
        Node* parent = NULL;
        Node* del = NULL;
        while (cur)
        {
            if (cur->_key < key)
            {
                parent = cur;
                cur = cur->_right;
            }

            else if (cur->_key > key)
            {
                parent = cur;
                cur = cur->_left;
            }

            else
            {
                if (NULL == cur->_left) //删除节点的左孩子为空
                {
                    if (NULL == parent) //当前节点为根节点
                    {
                        _root = cur->_right;
                    }
                    else
                    {
                        if (cur == parent->_left)
                        {
                            parent->_left = cur->_right;    //让父节点的左孩子指向当前节点的右孩子                      
                        }

                        else if (cur == parent->_right)
                        {
                            parent->_right = cur->_right;   //让父节点的右孩子指向当前节点的右孩子
                        }
                    }
                    del = cur;
                }


                else if (NULL == cur->_right)    //删除节点的右孩子为空
                {
                    if (NULL == parent) //当前节点为根节点
                    {
                        _root = cur->_left;
                    }
                    else
                    {
                        if (cur == parent->_left)   //parent的左孩子是cur且cur的右孩子为空
                        {
                            parent->_left = cur->_left;
                        }

                        if (cur == parent->_right)
                        {
                            parent->_right = cur->_left;//parent的右孩子是cur且cur的右孩子为空
                        }
                    }
                    delete cur; 
                }

                else    //删除节点的左右孩子都不为空
                {
                    //利用替换法，将当前节点视为根节点，找当前节点右子树最左节点，与要删除的节点做替换
                    Node* tmp = cur;
                    Node* subNode = cur->_right;//右子树肯定不为空
                    while (subNode->_left)
                    {
                        tmp = subNode;
                        subNode = subNode->_left;
                    }
                    //找到右子树的最左节点tmp;
                    swap(cur->_key, subNode->_key);//交换数据

                    //分两种情况
                    if (tmp->_left == subNode)  //tmp的左为替换节点  
                    {
                        tmp->_left = subNode->_right;
                    }

                    else if(tmp->_right == subNode)                         
                    {
                        tmp->_right = subNode->_right;
                    }
                    del = subNode;
                }
                delete del;
                return true;
            }
        }
        return false;
    }

完整实现

BSTree.h

#ifndef __BSTREE_H__
#define __BSTREE_H__

#include <iostream>

using namespace std;

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

    BSNode<K>(const K& key)
        :_left(NULL)
        ,_right(NULL)
        ,_key(key)
    {}
};

template <class K>
class BSTree
{
    typedef BSNode<K> Node;
public:
    BSTree()
        :_root(NULL)
    {}
    /*BSTree(const)
    {}*/
    bool Insert(const K& key)
    {
        if (NULL == _root)
        {
            _root = new Node(key);
            return true;
        }

        Node* parent = NULL;
        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;
            }
        }

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

    bool Rmove(const K& key)
    {
        if (NULL == _root){return true;}

        Node* cur = _root;
        Node* parent = NULL;
        Node* del = NULL;
        while (cur)
        {
            if (cur->_key < key)
            {
                parent = cur;
                cur = cur->_right;
            }

            else if (cur->_key > key)
            {
                parent = cur;
                cur = cur->_left;
            }

            else
            {
                if (NULL == cur->_left) //删除节点的左孩子为空
                {
                    if (NULL == parent) //当前节点为根节点
                    {
                        _root = cur->_right;
                    }
                    else
                    {
                        if (cur == parent->_left)
                        {
                            parent->_left = cur->_right;    //让父节点的左孩子指向当前节点的右孩子                      
                        }

                        else if (cur == parent->_right)
                        {
                            parent->_right = cur->_right;   //让父节点的右孩子指向当前节点的右孩子
                        }
                    }
                    del = cur;
                }


                else if (NULL == cur->_right)    //删除节点的右孩子为空
                {
                    if (NULL == parent) //当前节点为根节点
                    {
                        _root = cur->_left;
                    }
                    else
                    {
                        if (cur == parent->_left)   //parent的左孩子是cur且cur的右孩子为空
                        {
                            parent->_left = cur->_left;
                        }

                        if (cur == parent->_right)
                        {
                            parent->_right = cur->_left;//parent的右孩子是cur且cur的右孩子为空
                        }
                    }
                    delete cur; 
                }

                else    //删除节点的左右孩子都不为空
                {
                    //利用替换法，将当前节点视为根节点，找当前节点右子树最左节点，与要删除的节点做替换
                    Node* tmp = cur;
                    Node* subNode = cur->_right;//右子树肯定不为空
                    while (subNode->_left)
                    {
                        tmp = subNode;
                        subNode = subNode->_left;
                    }
                    //找到右子树的最左节点tmp;
                    swap(cur->_key, subNode->_key);//交换数据

                    //分两种情况
                    if (tmp->_left == subNode)  //tmp的左为替换节点  
                    {
                        tmp->_left = subNode->_right;
                    }

                    else if(tmp->_right == subNode)                         
                    {
                        tmp->_right = subNode->_right;
                    }
                    del = subNode;
                }
                delete del;
                return true;
            }
        }
        return false;
    }

    void InOder()
    {
        _InOder(_root);
        cout<<endl;
    }

    bool RmoveR(const K& key)
    {
        return _RemoveR(_root, key);
    }
    bool InsertR(const K& key)
    {
        return _InsertR(_root, key);
    }
    bool Find(const K& key)
    {
        if (_root == NULL)
            return false;

        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 FindR(const K& key)
    {
        return _FindR(_root, key);
    }
    ~BSTree()
    {
        _Destory(_root);
    }
protected:
    bool _RemoveR(Node*& cur, const K& key)
    {
        if (NULL == cur){
            return false;
        }

        if (cur->_key < key){
            return _RemoveR(cur->_right, key);
        }
        else if (cur->_key > key){
            return _RemoveR(cur->_left, key);
        }
        else{
            //找到为key的节点cur
            Node* del = cur;
            if (NULL == cur->_left){
                cur = cur->_right;
            }
            else if (NULL == cur->_right){
                cur = cur->_left;
            }
            else
            {
                Node* tmp = cur;
                Node* parent = cur->_right;
                cur = cur->_left;
                while (cur)
                {
                    parent = cur;
                    cur = cur->_left;
                }
                //parent现在是以被删除节点为根，右子树的最左节点
                swap(parent->_key, tmp->_key);

                return _RemoveR(parent, key);
            }
            delete del;
            return true;
        }
        return false;
    }
    bool _InsertR(Node*& root, const K& key)
    {
        if (NULL == root)
        {
            root = new Node(key);
            return true;
        }
        if (root->_key < key)
        {
            return _InsertR(root->_right, key);
        }
        else if (root->_key > key)
        {
            return _InsertR(root->_left, key);
        }
        else
            return false;
    }
    bool _FindR(Node* root,const K& key)
    {
        if (NULL == root){return false;}

        if (root->_key < key){
            return _FindR(root->_right, key);
        }
        else if (root->_key > key){
            return _FindR(root->_left, key);
        }
        else {
            return true;
        }

        return false;
    }
    void _Destory(Node* root)
    {
        if (NULL == root){return;}

        _Destory(root->_left);
        _Destory(root->_right);

        delete root;
    }

    void _InOder(Node* root)
    {
        if (NULL == root){return;}

        _InOder(root->_left);
        cout<<root->_key<<" ";
        _InOder(root->_right);
    }
protected:
    Node* _root;
};
#endif //__BSTREE_H__
二叉搜索树 BinarySearchTree
阿振的博客
01-26 294
参考算法导论第三版第十二章： 二叉搜索树。实现代码：百度网盘， 提取密码：duri。  对二叉树进行这样的限制条件：对任意结点x，其左子树中所有关键字均小于x.key，其右子树中所有关键字均大于（等于）x.key。这样的二叉树被称为二叉搜索树。如下图：  可以看出，相同的关键字集合，能够构建出不同结构的二叉搜索树，而任意结构都满足二叉搜索树的性质。由于二叉搜索树关键字组织特性，树的
【数据结构】二叉搜索树binarySearchTree
acm_pn的博客
08-07 867
二叉搜索树的优点很明显，就是在查找元素时的速度能够达到，可以说查找效率非常之高了。但其也存在着缺点，就是在构成单支树是效率会递减至O(n)，也就是说它的查找效率是不稳定的。为了弥补这一缺陷，努力让树的层数尽可能少，分布尽可能均衡是提升二叉树效率的关键，也就有了后来的AVL树和红黑树，不过他们的基础都是二叉搜索树，所以一定要先好好理解二叉搜索树的原理。
C++二叉搜索树BinarySearchTree
学习C++的小陈同学
11-03 194
本章介绍了搜索二叉树的特性，并且用C++模拟实现，详细分析了代码思路
C++ 二叉搜索树BinarySearchTree
冰果滴的博客
07-30 1168
二叉搜索树是为学习map和set做的铺垫，了解了二叉搜索树的特性，有助于更好的理解map和set。
BST 二叉搜索树 BinarySearchTree 思路分析与实现 C++
weixin_41363278的博客
09-12 130
合集 - STL/高阶数据结构 (20)1.BST 二叉搜索树 BinarySearchTree 思路分析与实现 C++08-202.手搓平衡搜索树-AVL树 平衡修正 图文详解 (万字长文)08-233.详细分析平衡树-红黑树的平衡修正 图文详解 (万字长文)08-264.STL 改造红黑树 模拟封装set和map08-315.STL map、set、multi_map、multi_set 基...
C++实现二叉搜索树BinarySearchTree
weixin_42936764的博客
07-30 305
C++实现int类型元素的二叉搜索树。
二叉搜索树BinarySearchTree
shen_11的博客
04-24 186
简简单单一个二叉搜索树！（别信）
数据结构之二分搜索树BinarySearchTree
qq_41367934的博客
07-30 212
数据结构之二分搜索树 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录数据结构之二分搜索树前言一、节点、属性的设置二、二分搜索树的添加二、遍历三、删除总结 前言 什么是二分搜索树？ 二分搜索树是一种特殊的二叉树，当一个二叉树满足所有左儿子的值小于自己，所有右儿子的值大于自己，这样一个树就被称为二分搜索树。 注意！！ 二分搜索树的节点一定要具备可比性！！ 一、节点、属性的设置 节点的定义，首先有值，还有左右孩子 private class Node{ pri
JavaSE——搜索树BinarySearchTree&&实现电话薄
weixin_44919969的博客
10-09 231
1.搜索树 二叉搜索树又称二叉排序树，它或者是一棵空树**，或者是具有以下性质的二叉树: 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 它的左右子树也分别为二叉搜索树 搜索树主要实现三个操作 查询 插入 删除 1.查询（根据二叉树的性质来进行） key值与根结点进行比较，等于则返回该节点 ...
BinarySearchTree:Java中二叉搜索树的实现
06-11
二叉搜索树（Binary Search Tree，简称BST）是一...在提供的压缩包"BinarySearchTree-master"中，可能包含了更多关于二叉搜索树的实现，包括不同操作的优化和测试用例，你可以进一步研究以获取更深入的理解和实践经验。
BinarySearchTree:二叉搜索树算法演示
07-01
接下来，我们可以创建一个`BinarySearchTree`类来实现二叉搜索树的主要操作： ```java public class BinarySearchTree { private Node root; public BinarySearchTree() { this.root = null; } // 插入操作 ...
BinarySearchTree:基于节点的二叉搜索树
06-10
在这个名为"BinarySearchTree:基于节点的二叉搜索树"的主题中，我们将深入探讨这种数据结构的关键特性、操作以及在Java中实现的细节。 二叉搜索树的主要特征是其排序性质：对于任意节点，其左子树中的所有节点的键...
二叉搜索树的插入删除_二叉搜索树_python_
09-29
在实际使用中，你可以创建一个`BinarySearchTree`实例，然后通过调用`insert`和`delete`方法来操作二叉搜索树。例如： ```python bst = BinarySearchTree() bst.insert(5) bst.insert(3) bst.insert(7) bst.insert...
【数据结构】——链表OJ(下)
2302_81083101的博客
05-08 6091
前面我们已经刷了几道单链表的题目，下面我们继续看几道题目。
数据结构--二叉树
m0_74445123的博客
05-07 777
现实中我们通常把堆(一种二叉树)使用顺序结构的数组来存储，需要注意的是这里的堆和操作系统虚拟进程地址空间中的堆是两回事，一个是数据结构，一个是操作系统中管理内存的一块区域分段。而现实中使用中只有堆才会使用数组来存储，关于堆，前面有一篇文章有分享，二叉树顺序存储在物理上是一个数组，在逻辑上是一颗二叉树。对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。四、二叉树的存储结构。
算法与数据结构 - 常用图算法总结
最新发布
w8www的博客
05-08 880
在图论中，图算法非常重要，广泛应用于计算机科学、网络分析、社交网络、地理信息系统等领域。
数据结构 - 10（ B- 树 && B+ 树 && B* 树 4000 字详解 ）
weixin_73232539的博客
05-08 1238
数据结构第十篇，B- 树 && B+ 树 && B* 树 4000 字详解
day23-集合（泛型&Set&数据结构）
2301_80368429的博客
05-08 1081
泛型的介绍 泛型是JDK5中引入的特性，它提供了编译时类型安全检测机制泛型的好处把运行时期的问题提前到了编译期间避免了强制类型转换泛型的定义格式<类型>: 指定一种类型的格式.尖括号里面可以任意书写,一般只写一个字母.例如:<类型1,类型2…>: 指定多种类型的格式,多种类型之间用逗号隔开.例如: <E,T> <K,V>不可以存储重复元素没有索引,不能使用普通for循环遍历不可以存储重复元素没有索引可以将元素按照规则进行排序。
数据结构和算法
Xingshi89的专栏
05-08 422
--1. 使用PL/SQL连接到数据库 SELECT T.session_id FROM DBA_DDL_LOCKS T WHERE T.owner = '？' AND T.name = 'ADM_IMP_BRANCHRELATIONS'; --2. select pro.spid from v$session ses,v$process pro wher
二叉搜索树详解及C++实现
这个模板类`BinarySearchTree`代表二叉搜索树本身。它包含一个私有成员`m_root`，表示树的根节点。类提供了各种成员函数来操作二叉搜索树： - 构造函数：默认构造函数、拷贝构造函数。 - 析构函数：负责释放树...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值