数据结构——二叉搜索树

这篇具有很好参考价值的文章主要介绍了数据结构——二叉搜索树。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

数据结构——二叉搜索树,原创,数据结构,数据结构,c++

本章代码:二叉搜索树

🌲1.二叉搜索树概念

二叉搜索树又叫二叉排序树,它具有以下性质:

  • 若左子树不为空,则左子树上所有结点的值都小于根结点的值
  • 若右子树不为空,则右子树上所有结点的值都大于根结点的值
  • 它的左右子树也分别为二叉搜索树

数据结构——二叉搜索树,原创,数据结构,数据结构,c++

这个结构的时间复杂度为一般人会以为是O(logN),因为它每次都是往下一层,所以最多为二叉树的度,有n个结点的满二叉树的深度为log2(n+1)。但是实际上它的最坏情况可能是一颗斜树,这就等同于按顺序查找,时间复杂度为O(N)。所以我们按照最坏的情况来计算,二叉搜索的时间复杂度为O(N)

数据结构——二叉搜索树,原创,数据结构,数据结构,c++

🌳2. 二叉搜索树操作

🌿2.1 结构定义

template<class K>
struct BSTreeNode
{
	K _key;	//数据
	BSTreeNode<K>* _left;	//左孩子
	BSTreeNode<K>* _right;	//右孩子

	BSTreeNode(const K& key)	//初始化
		:_key(key)
		, _left(nullptr)
		, _right(nullptr)
	{}
};

template<class K>
class BSTree
{
    typedef BSTreeNode<K> Node;
public:
    BSTree()
        :_root(nullptr)
    {}
private:
    Node* _root;	//结点
    

🌿2.2 插入操作

插入流程较简单,即:

  • 若结点为空,则新增节点,将值赋给root
  • 若不为空,则按照左子树小于根结点,右子树大于根结点来进行插入新节点

数据结构——二叉搜索树,原创,数据结构,数据结构,c++

//非递归
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;
}
//递归
bool InsertR(const K& key)
{
    return _InsertR(_root, key);
}

private:
    bool _InsertR(Node*& root, const K& key)
    {
        if (root == nullptr)
        {
            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;
        }
    }

这里说明一下递归操作:

  1. 因为递归操作是需要传结点的,而我们的结点是私有的,外面访问不到,所以我们设一个子函数,来传结点

  2. 在非递归版本,我们需要记录父节点,因为我们要将树给连接上

    而递归版本,我们每次传的时候,都是root指向的左/节点

    数据结构——二叉搜索树,原创,数据结构,数据结构,c++

🌿2.3 查找操作

同样是按照二叉搜索树的性质来进行查找

数据结构——二叉搜索树,原创,数据结构,数据结构,c++

//非递归
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 FindR(const K& key)
{
    return _FindR(_root, key);
}
private:
    bool _FindR(Node* root, const K& key)
    {
        if (root == nullptr)
            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;
    }

🌿2.4 删除操作

删除操作是比较复杂的,这个节点找到之后进行删除,要保证这棵树还是一个二叉搜索树。

我们分为2种情况:

  1. 该节点只有左孩子/右孩子(无孩子),也就是至多一个孩子

    我们找到该节点之后,判断哪边空,然后再让父节点指向它的另一边,然后删掉这个节点即可

    数据结构——二叉搜索树,原创,数据结构,数据结构,c++

  2. 有2个孩子

    有2个孩子的话,直接删除的话,那这颗树的顺序就打乱了,根据它的性质,我们可以交换它的左子树里面的最大元素或者右子树里面的最小元素,这样就还能保证这棵树还是搜索树

数据结构——二叉搜索树,原创,数据结构,数据结构,c++

//非递归
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->_right == cur)
                    {
                        parent->_right = cur->_right;
                    }
                    else
                    {
                        parent->_left = cur->_right;
                    }
                }
            }
            else if (cur->_right == nullptr)	//右边为空
            {
                if (cur == _root)
                {
                    _root = cur->_left;
                }
                else
                {
                    if (parent->_right == cur)
                    {
                        parent->_right = cur->_left;
                    }
                    else
                    {
                        parent->_left = cur->_left;
                    }
                }
            }
            else  //左右都不为空
            {
                Node* ptmp = cur;
                //左子树最大元素为例
                Node* tmp = cur->_left;
                while (tmp->_right)
                {
                    ptmp = tmp;
                    tmp = tmp->_right;
                }
                //交换元素
                std::swap(cur->_key, tmp->_key);

                if (ptmp->_left == tmp)
                {
                    ptmp->_left = tmp->_left;
                }
                else
                {
                    ptmp->_right = tmp->_left;
                }
                cur = tmp;
            }
            delete cur;
            return true;
        }
    }
    return false;
}

//递归
bool EraseR(const K& key)
{
    return _EraseR(_root, key);
}
private:
    bool _EraseR(Node*& root, const K& key)
    {
        if (root == nullptr)
            return false;

        if (root->_key < key)
        {
            return _EraseR(root->_right, key);
        }
        else if (root->_key > key)
        {
            return _EraseR(root->_left, key);
        }
        else
        {
            Node* del = root;
            if (root->_left == nullptr)
            {
                root = root->_right;
            }
            else if (root->_right == nullptr)
            {
                root = root->_left;
            }
            else
            {
                Node* tmp = root->_left;
                while (tmp->_left)
                {
                    tmp = tmp->_right;
                }
                std::swap(tmp->_key, root->_key);
                return _EraseR(root->_left, key);
            }
            delete del;
            return true;
        }
    }

🌿2.5 遍历

这里采用的是中序遍历

void InOrder()
{
    _InOrder(_root);
    cout << endl;
}
private:
    void _InOrder(Node* root)
    {
        if (root == NULL)
            return;
        _InOrder(root->_left);
        cout << root->_key << " ";
        _InOrder(root->_right);
    }

🌴3. 二叉搜索树应用场景

🍀3.1 K模型

K模型即只有key作为数据元素,这可用于数据匹配,例如拼写检查。

我们上面实现的就是属于k模型

🍀3.2 KV模型

KV模型,每个key码都对应一个value值,我们生活中的字典、统计人员出入等,可采用这种模型

这里只做简单的逻辑演示,以下两种演示的代码都放在开头的代码仓库了,有兴趣可以查看

字典逻辑:

数据结构——二叉搜索树,原创,数据结构,数据结构,c++

次数统计:

数据结构——二叉搜索树,原创,数据结构,数据结构,c++


那本期的分享就到这里咯,我们下期在家,如果还有下期的话文章来源地址https://www.toymoban.com/news/detail-655162.html

到了这里,关于数据结构——二叉搜索树的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 高级数据结构——二叉搜索树

    目录 1. 二叉搜索树的概念 2. 二叉搜索树的实现 结点类 二叉搜索树的类 2.1 默认成员函数 2.1.1 构造函数 2.1.2 拷贝构造函数 2.1.3 赋值运算符重载函数 2.1.4 析构函数 2.2 中序遍历 2.3 insert插入函数 2.3.1 非递归实现 2.3.2 递归实现 2.4 erase删除函数 2.4.1 非递归实现 2.4.2 递归版本

    2024年02月10日
    浏览(41)
  • 高级数据结构 <二叉搜索树>

    本文已收录至《数据结构(C/C++语言)》专栏! 作者:ARMCSKGT 前面我们学习了二叉树,但仅仅只是简单的二叉树并没有很大的用处,而本节的二叉搜索树是对二叉树的升级,其查找效率相对于简单二叉树来说有一定提升,二叉搜索树是学习AVL树和红黑树的基础,所以我们必须先

    2024年02月04日
    浏览(45)
  • 算法与数据结构--二叉搜索树与自平衡二叉搜索树

    注:字典的 \\\"member运算\\\" 指的是检查字典中是否存在某个特定的键的操作,即查询操作。 如果我们使用数组来实现字典/map,虽然使用二分法查询也可以达到logn,但是的话插入和删除太慢了。使用链表实现的话虽然插入和删除是O(1),但是查询的话达到了O(n),也不可取。 因此人

    2024年02月04日
    浏览(38)
  • 数据结构篇八:二叉搜索树

      前面我们已经学习过了二叉树,二叉搜索树是在二叉树的基础上增添了一些规则,使其能完成快速查找的功能,同时它也帮助我们更好的理解后续将要学习的map和set。   二叉搜索树又称二叉排序树,它或者是一棵空树,或者是具有以下性质的二叉树: 若它的左子树不为

    2024年03月13日
    浏览(50)
  • 数据结构之二叉搜索树

    满足条件: 1.对于根节点:左子树中所有节点的值小于右子树中所有节点的值 2.任意节点的左右子树也是二叉搜索树,同样满足条件1 我们将二叉搜索树封装为一个类 BinarySearchTree ,并声明一个成员变量 root ,指向树的根节点 查找节点 给定目标值 target ,我们可以根据二叉搜索

    2024年01月20日
    浏览(37)
  • 【数据结构】二叉搜索树BSTree

    二叉搜索树又称二叉排序树,它或者是一棵空树,或者是具有以下性质的二叉树: 若它的左子树不为空,则左子树上所有节点的值都小于根节点的值 若它的右子树不为空,则右子树上所有节点的值都大于根节点的值 左根右 它的左右子树也分别为二叉搜索树 之所以又叫二叉排

    2024年02月03日
    浏览(44)
  • 数据结构:二叉搜索树(非递归实现)

    目录 1、二叉搜索树 2、二叉搜索树的相关操作。 1、查找 2、插入 3、删除 3、代码实现(非递归) 二叉搜索树(Binary Search Tree,简称BST)是一种特殊的二叉树,其中每个节点的值大于其左子树中所有节点的值,小于其右子树中所有节点的值。这种特性使得二叉搜索树具有快速

    2024年03月08日
    浏览(38)
  • 【数据结构】搜索二叉树(C++实现)

    ​ ​📝个人主页:@Sherry的成长之路 🏠学习社区:Sherry的成长之路(个人社区) 📖专栏链接:数据结构 🎯 长路漫漫浩浩,万事皆有期待 上一篇博客:【C++】C++模板进阶 —— 非类型模板参数、模板的特化以及模板的分离编译 二叉搜索树又称二叉排序树,它或者是一棵空

    2024年02月07日
    浏览(52)
  • 数据结构_进阶(1):搜索二叉树

    建议再看这节之前能对C++有一定了解 二叉树在前面C的数据结构阶段时有出过,现在我们对二叉树来学习一些更复杂的类型,也为之后C++学习的 map 和 set 做铺垫 1. map和set特性需要先铺垫二叉搜索树 ,而二叉搜索树也是一种树形结构 2. 二叉搜索树的特性了解,有助于更好的理

    2024年02月16日
    浏览(46)
  • 【数据结构】 二叉搜索树的实现

    二叉搜索树又称二叉排序树,它或者是一棵空树,或者是具有以下性质的二叉树 若它的左子树不为空,则左子树上所有节点的值都小于根节点的值 若它的右子树不为空,则右子树上所有节点的值都大于根节点的值 它的左右子树也分别为二叉搜索树 比如以下就为一个人二叉搜

    2024年02月09日
    浏览(38)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包