⼆叉搜索树的实现

原创于 2025-09-13 14:10:46 发布 · 523 阅读

6 ·

CC 4.0 BY-SA版权

文章标签：

#开发语言 #c++

从0开始学习c++ 专栏收录该内容

19 篇文章

订阅专栏

1. ⼆叉搜索树的概念

⼆叉搜索树⼜称⼆叉排序树，它或者是⼀棵空树，或者是具有以下性质的⼆叉树:
• 若它的左⼦树不为空，则左⼦树上所有结点的值都⼩于等于根结点的值
• 若它的右⼦树不为空，则右⼦树上所有结点的值都⼤于等于根结点的值
• 它的左右⼦树也分别为⼆叉搜索树
• ⼆叉搜索树中可以⽀持插⼊相等的值，也可以不⽀持插⼊相等的值，具体看使⽤场景定义，map/set/multimap/multiset系列容器底层就是⼆叉搜索树，其中map/set不⽀持插⼊相等值，multimap/multiset⽀持插⼊相等值
在这里插入图片描述

2. ⼆叉搜索树的性能分析

最优情况下，⼆叉搜索树为完全⼆叉树(或者接近完全⼆叉树)，其⾼度为：log2N
最差情况下，⼆叉搜索树退化为单⽀树(或者类似单⽀)，其⾼度为：N
所以综合⽽⾔⼆叉搜索树增删查改时间复杂度为：O(N)
那么这样的效率显然是⽆法满⾜我们需求的，我们后续课程需要继续讲解⼆叉搜索树的变形，平衡⼆叉搜索树AVL树和红⿊树，才能适⽤于我们在内存中存储和搜索数据。
另外需要说明的是，⼆分查找也可以实现O(log2 N) 级别的查找效率，但是⼆分查找有两⼤缺陷：

需要存储在⽀持下标随机访问的结构中，并且有序。
插⼊和删除数据效率很低，因为存储在下标随机访问的结构中，插⼊和删除数据⼀般需要挪动数据。这⾥也就体现出了平衡⼆叉搜索树的价值。
极端情况

3. ⼆叉搜索树的插⼊

插⼊的具体过程如下：

树为空，则直接新增结点，赋值给root指针
树不空，按⼆叉搜索树性质，插⼊值⽐当前结点⼤往右⾛，插⼊值⽐当前结点⼩往左⾛，找到空位置，插⼊新结点。
如果⽀持插⼊相等的值，插⼊值跟当前结点相等的值可以往右⾛，也可以往左⾛，找到空位置，插⼊新结点。（要注意的是要保持逻辑⼀致性，插⼊相等的值不要⼀会往右⾛，⼀会往左⾛）

4. ⼆叉搜索树的查找

从根开始⽐较，查找x，x⽐根的值⼤则往右边⾛查找，x⽐根值⼩则往左边⾛查找。
最多查找⾼度次，⾛到到空，还没找到，这个值不存在。
如果不⽀持插⼊相等的值，找到x即可返回
如果⽀持插⼊相等的值，意味着有多个x存在，⼀般要求查找中序的第⼀个x。如下图，查找3，要找到1的右孩⼦的那个3返回

在这里插入图片描述

5. ⼆叉搜索树的删除

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

要删除结点N左右孩⼦均为空
要删除的结点N左孩⼦位空，右孩⼦结点不为空
要删除的结点N右孩⼦位空，左孩⼦结点不为空
要删除的结点N左右孩⼦结点均不为空
对应以上四种情况的解决⽅案：
把N结点的⽗亲对应孩⼦指针指向空，直接删除N结点（情况1可以当成2或者3处理，效果是⼀样的）
把N结点的⽗亲对应孩⼦指针指向N的右孩⼦，直接删除N结点
把N结点的⽗亲对应孩⼦指针指向N的左孩⼦，直接删除N结点
⽆法直接删除N结点，因为N的两个孩⼦⽆处安放，只能⽤替换法删除。找N左⼦树的值最⼤结点R(最右结点)或者N右⼦树的值最⼩结点R(最左结点)替代N，因为这两个结点中任意⼀个，放到N的位置，都满⾜⼆叉搜索树的规则。替代N的意思就是N和R的两个结点的值交换，转⽽变成删除R结点，R结点符合情况2或情况3，可以直接删除。

6. ⼆叉搜索树的实现代码

//1.二叉搜索树中结点的结构
template<class K>
struct BSTNode
{
    K _key;
    BSTNode<K>* _left;
    BSTNode<K>* _right;

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

template<class K>
class BSTree
{
    typedef BSTNode<K> Node;
public:
    //1.插入
    bool Insert(const K& key)
    {
        //根节点为空时
        if (_root == nullptr)
        {
            _root = new Node(key);
            return true;
        }

        Node* cur = _root;
        Node* parent = nullptr;
        while (cur)
        {
            if (key < cur->_key)
            {
                parent = cur;
                cur = cur->_left;
            }
            else if (key > cur->_key)
            {
                parent = cur;
                cur = cur->_right;
            }
            else
            {
                return false;
            }
        }
        //找到插入的地方
        cur = new Node(key);
        if (parent->_key < key)
        {
            parent->_right = cur;
        }
        else
        {
            parent->_left = cur;
        }

        return true;
    }

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

    //3.删除
    bool Erase(const K& key)
    {
        Node* cur = _root;
        Node* parent = nullptr;
        while (cur)
        {
            if (key > cur->_key)
            {
                parent = cur;
                cur = cur->_right;
            }
            else if (key < cur->_key)
            {
                parent = cur;
                cur = cur->_left;
            }
            else
            {
                //1.cur左节点为空
                if (cur->_left == nullptr)
                {
                    //判断是否为根节点
                    if (cur != _root)
                    {
                        if (parent->_left == cur)
                        {
                            parent->_left = cur->_right;
                        }
                        else
                        {
                            parent->_right = cur->_right;
                        }
                    }
                    else
                    {
                        _root = cur->_right;
                    }
                    delete cur;
                }
                //2.cur的右节点为空
                else if (cur->_right == nullptr)
                {
                    //判断是否为根节点
                    if (cur != _root)
                    {
                        if (parent->_left == cur)
                        {
                            parent->_left = cur->_left;
                        }
                        else
                        {
                            parent->_right = cur->_left;
                        }
                    }
                    else
                    {
                        _root = cur->_left;
                    }
                    delete cur;
                }
                //3.左右节点都不为空
                else
                {
                    Node* minrightparent = cur;
                    Node* minright = cur->_right;
                    //寻找最小的
                    while (minright->_left)
                    {
                        minrightparent = minright;
                        minright = minright->_left;
                    }
                    swap(cur->_key, minright->_key);
                    if (minright == minrightparent->_left)
                    {
                        minrightparent->_left = minright->_right;
                    }
                    else
                    {
                        minrightparent->_right = minright->_right;
                    }
                    delete minright;
                }
                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 << " ";
        _InOrder(root->_right);
    }

private:
    Node* _root = nullptr;
};