C++版【AVL树的模拟实现】

最新推荐文章于 2024-07-24 11:32:27 发布
最新推荐文章于 2024-07-24 11:32:27 发布
阅读量758 收藏 17
点赞数 29
分类专栏： C++学习 数据结构 文章标签： c++ java 开发语言 AVL树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_76941579/article/details/137554352
版权

前言

        在学习AVL树的底层之前，先回顾一下二叉搜索树，我们知道二叉搜索树在极端场景是会形成单支树的，如下图：

        在退化成单支树后，查找的效率就会降到O(n)，所以为了解决退化成单支树的情况，AVL树就诞生了，在学习AVL树的模拟实现之前，先要明白AVL是如何避免单支树的产生的。

一、AVL树解决单支树问题的原理

        在搜索某个节点时，本质上是要搜索这个节点的高度次，但当形成单支树或接近单支树，就会使时间复杂度提升至O(n)，所以为了提高搜索的效率，就要把高度降低。这也是AVL树解决单支树问题的关键！

原理：

        当向二叉搜索树中插入新结点后，必须保证每个结点的左右子树高度之差的绝对值不超过1，即可降低树的高度，从而减少平均搜索长度。

        所以根据原理，我们可以设计一个简单的AVL树，只需要在树的节点中增添一个成员变量来记录每个节点的左右子树的高度差，在插入节点时，来判断节点的左右子树高度差的绝对值是否超过1，再进行后续操作。

二、AVL树的模拟实现（源代码+解析）

        本次只实现中序遍历为升序，无重复值，且无删除操作的AVL树   (后续会完善功能)

1. 创造AVL树节点的类（AVLTreeNode）

        创造树节点的类时，需要考虑里面应该包含什么成员

成员变量：

指向左右子树的节点指针【 _left、 _right 】
指向父亲节点的指针（方便找父亲）【 _parent 】

记录每个节点左右子树高度差

平衡因子（balance factor）

【 _bf 】
该节点包含的数据【 _data 】

成员函数：

  • 构造函数
//我们在创造AVL树之前，先要把AVL树节点创造出来，要明确的是在AVLTreeNode类外
//我们还是需要使用到节点里面的内容，所以这里定义为struct类，默认权限为public
template <class T>   //模版，T可以为任何类型
struct AVLTreeNode
{
    AVLTreeNode(const T& data)
        : _left(nullptr)
        , _right(nullptr)
        , _parent(nullptr)
        , _bf(0)
        , _data(data)
    {}
    AVLTreeNode<T>* _left;
    AVLTreeNode<T>* _right;
    AVLTreeNode<T>* _parent;
    int _bf;    //用_bf来记录树节点的左右子树高度差，bf = high(right) - high(left)
    T _data;
};

2. 创造AVL树的类（AVLTree）

成员变量：

  • 根节点指针 AVLTreeNode* 

成员函数：

  • 插入操作（intsert）
  • 验证是否为AVL树
  • 其余函数请自行添加
//创造完AVLTreeNode后，可以开始创造AVLTree
//需要注意的是，我们在日常使用AVL树时，只需要使用其成员函数，并不需要用成员变量
//所以设定为class类，成员函数权限为public，成员函数权限为private
template <class T>
class AVLTree
{
public:
成员函数
    //插入
    bool insert(const T& data);
    //判断是否为AVL
    bool _IsBalance(Node* root, int& height);
private:
    typedef AVLTreeNode<T> Node;
    Node* _root = nullptr; //等价于在初始化列表初始化，在没插入之前，默认为空树
};

3. 成员函数：插入【insert】

        在插入时，其他步骤均与二叉搜索树一致，都是小的去左子树，大的去右子树，唯一多出来的步骤是：更新平衡因子

4. 更新平衡因子【重点】

因为我们AVL树的规定为 每个节点的左右子树高度差不能超过1

那bf 只能为 -1、0、1；

所以在插入之前，parent节点的平衡因子值只能为-1、0、1三种情况；

而在更新的过程中，因为bf = high(right) - high(left)

所以当在parent的左子树插入时，默认是增加左子树的高度，需要--bf；反之是增加右子树的高度，++bf；

在parent的平衡因子更新之后，bf结果只能为-2，-1，0，1，2这五种情况

我们后续就要根据这五种情况来判断，是否更新完成，更新完成直接退出，反之继续向上更新

（这里的更新是否完成是指：是否会影响上层节点的平衡因子bf的值，不影响就更新完成，影响就继续向上更新）

（1）更新后：parent->_bf == 0

        当更新完之后parent的平衡因子为0时，我们认为更新之前的parent平衡因子只有1或-1两种情况；

        我们通过抽象图可以看出，不会影响parent以上的节点的平衡因子

        所以在parent->_bf == 0时，平衡因子的更新结束！

结论：当parent->_bf == 0时，不会影响上层节点的bf，不需要继续更新，更新结束！

（2）更新后：parent->_bf == -1

        下图，我将更新之前，分为三种情况（有很多情况，不一列举）

        因为无论怎么插入节点，已有节点的平衡因子，也无非是-1，0，1；所以我将parent的父亲节点的平衡因子分为0，-1，1三种情况；

        以便探索在更新parent的平衡因子之后，是否还需要继续向上更新

        更新之后是否还满足AVL的规则（  | bf |   ≤  1  ）

        所以我们通过图中可以看出，无论是哪一种情况，当parent的bf == -1时，都会影响上层的节点的平衡因子，都要继续向上更新

结论：当parent->_bf == -1时，需要继续向上更新

（3）更新后：parent->_bf == 1

        我们发现，当更新后parent的平衡因子bf == 1时，也会影响上层的节点的平衡因子，所以仍需要继续向上更新

结论：当parent->_bf == 1时，需要继续向上更新！

通过（1）（2）可以得到当parent的平衡因子 bf == 正负1 时，都需要继续向上更新

（4）更新后：parent->_bf == 2 或 parent->_bf == -2

        当更新后的平衡因子超过1的时候，已经违反AVL树的规则，此时要进行旋转

        旋转的目的就是为了让高度降低，那如何来旋转请看下图：

通过图中可以看出在违背规则时，一共有4种不同的旋转方式可以解决

第一种：左旋转

旋转之后，不会影响上层节点的平衡因子，更新结束

第二种：右旋转

旋转之后，不会影响上层节点的平衡因子，更新结束

第三种：先左旋转，后右旋转

        这里需要进行两次旋转，因为最开始是右边高，要左旋，后来是左边高，再右旋

        但是在平衡因子的更新就需要分情况讨论了

        我们在cur的子树的左右侧分别插入，会导致最后的平衡因子为不同值，而最开始导致不同的原因是cright的bf的不同，所以在旋转结束后，更新平衡因子时以cright的bf不同值做分情况讨论

情况1，当h不存在，cright->_bf == 0

情况2，h存在，且在右侧插入，cright->_bf == 1

情况3，h存在且在左子树插入，cright->_bf == -1;

第四种：先右旋转，后左旋转

        这里与上面的采用统一思想

情况1：当h == 0时，插入的节点cleft->_bf == 0

情况2：在cur的左子树的左侧插入，cleft->_bf == -1

情况3：在cur的左子树的右侧插入，cleft->_bf == 1

【insert代码实现】

    bool insert(const T& data)
    {
        //这里插入规则与二叉搜索树一致
        //空树
        if(_root == nullptr)
        {
            _root = new Node(data);
            //创建失败
            if(_root == nullptr)
            {
                perror("new error");
                return false;
            }
            return true;
        }
        //不为空树
        else
        {
            Node* cur = _root;  //遍历找到插入的位置
            Node* parent = _root; //记录插入位置的父亲节点位置

            while(cur)
            {
                if(cur->_data > data)  //插入值小于节点值：去左子树插入
                {
                    parent = cur;
                    cur = cur->_left;
                }
                else if(cur->_data < data) //插入值大于节点值：去右子树插入
                {
                    parent = cur;
                    cur = cur->_right;
                }
                else //插入值等于节点值：插入失败
                {
                    perror("insert a same data");
                    return false;
                }
            }

            //找到插入位置了，创造新节点
            Node* newnode = new Node(data);

            if(parent->_data > data) //新节点的值比父亲的值小，插入父亲的左侧
            {
                parent->_left = newnode;
            }
            else                     //新节点的值比父亲的值大，插入父亲的右侧
            {
                parent->_right = newnode;
            }
            newnode->_parent = parent;

            //更新平衡因子bf
            UpdateBF(newnode, parent);
            return true;
        }
    }
//左旋转
    void RotationL(Node* parent, Node* cur)
    {
       Node* cleft = cur->_left;
       parent->_right = cleft;

       //cleft不为空，则需要链接其父亲，为空，则不用链接
       if(cleft)
           cleft->_parent = parent;

       cur->_left = parent;
       //
       Node* pparent = parent->_parent;
       parent->_parent = cur;

       if(parent == _root) //当parent就是根，旋转之后，cur就为根
       {
           _root = cur;
           cur->_parent = nullptr;
       }
       else //如果parent不是根，则需要判断parent在其父亲的左节点还是右节点
       {
           if(pparent->_left == parent)
           {
               pparent->_left = cur;
           }
           else
           {
               pparent->_right = cur;
           }
           cur->_parent = pparent;
       }

        //旋转之后，parent和cur的平衡因子都为0，不影响上层节点
        parent->_bf = 0;
        cur->_bf = 0;
    }

    //右旋转
    void RotationR(Node* parent, Node* cur)
    {
        Node* cright = cur->_right;
        parent->_left = cright;

        //cright存在，则链接其父亲到parent，不存在，不链接
        if(cright)
            cright->_parent = parent;

        cur->_right = parent;
        Node* pparent = parent->_parent;
        parent->_parent = cur;

        if(parent == _root) //当parent就是根，旋转之后，cur就为根
        {
            _root = cur;
            cur->_parent = nullptr;
        }
        else //如果parent不是根，则需要判断parent在其父亲的左节点还是右节点
        {
            if(pparent->_left == parent)
            {
                pparent->_left = cur;
            }
            else
            {
                pparent->_right = cur;
            }
            cur->_parent = pparent;
        }

        //旋转之后，parent和cur的平衡因子都为0，不影响上层节点
        parent->_bf = 0;
        cur->_bf = 0;
    }

    //左右旋转
    void RotationLR(Node* parent, Node* cur)
    {
        Node* cright = cur->_right;
        int bf = cright->_bf;

        RotationL(cur, cright);
        RotationR(parent, cright);

        if(bf == 1)
        {
            parent->_bf = 0;
            cright->_bf = 0;
            cur->_bf = -1;
        }
        else if(bf == -1)
        {
            parent->_bf = 1;
            cur->_bf = 0;
            cright->_bf = 0;
        }
        else
        {
            parent->_bf = 0;
            cur->_bf = 0;
            cright->_bf = 0;
        }
    }

    //右左旋转
    void RotationRL(Node* parent, Node* cur)
    {
        Node* cleft = cur->_left;
        int bf = cleft->_bf;

        RotationR(cur, cleft);
        RotationL(parent, cleft);

        if(bf == 1)
        {
            parent->_bf = -1;
            cleft->_bf = 0;
            cur->_bf = 0;
        }
        else if(bf == -1)
        {
            parent->_bf = 0;
            cur->_bf = 1;
            cleft->_bf = 0;
        }
        else
        {
            parent->_bf = 0;
            cur->_bf = 0;
            cleft->_bf = 0;
        }
    }

    //更新平衡因子
    void UpdateBF(Node*& cur, Node*& parent)
    {
        while(parent)
        {
            //我们在插入之前，parent的平衡因子可能为三种情况
            // 1、0、-1
            if(parent->_left == cur) //插入的节点在父亲的左边，bf--
            {
                --parent->_bf;
            }
            else //插入的节点在父亲的右边，bf++
            {
                ++parent->_bf;
            }

            //更新完平衡因子之后，parent的bf值可能为：2，1，0，-1，-2

            if(parent->_bf == 0)
            //说明parent在插入之前的bf为1或-1，以parent为根的左右子树高度差1
            //新增节点之后，也并不会影响整颗树的bf，只会让以parent为根的左右子树高度差更新为0
            {
                break;
            }
            else if(parent->_bf == -1 || parent->_bf == 1)
            //说明parent在插入之前的bf == 0，是AVL树，但是插入之后，会影响整体的高度
            //所以要依次向上更新
            {
                cur = parent;
                parent = cur->_parent;
            }
            else if(parent->_bf == 2 || parent->_bf == -2)
            //parent的平衡因子超过1，破坏了AVL树的规则，需要进行旋转
            //但是有4种旋转的情况
            {
                //情况1：左旋转
                if(parent->_bf == 2 && cur->_bf == 1)
                {
                    RotationL(parent, cur);
                }
                //情况2：右左旋转
                else if(parent->_bf == 2 && cur->_bf == -1)
                {
                    RotationRL(parent, cur);
                }
                //情况3：右旋转
                else if(parent->_bf == -2 && cur->_bf == -1)
                {
                    RotationR(parent, cur);
                }
                //情况4：左右旋转
                else if(parent->_bf == -2 && cur->_bf == 1)
                {
                    RotationLR(parent, cur);
                }
                else;

                //旋转结束、不需要更新
                break;
            }
            else
            {
                //平衡因子有问题
                assert(false);
            }

        }
    }

5. 判断是否为AVL树

        要想验证我们上面插入之后，是否为AVL树，可以写一个函数去判断一下，根据AVL树的性质：任意一个节点的左右子树的高度差的绝对值不超过1，所以我们可以根据这一性质来编写代码：

//判断是否为AVL树
    bool IsBalance()
    {
        int height = 0;
        return _IsBalance(_root, height);
    }

//判断是否是AVL树
    bool _IsBalance(Node* root, int& height)
    {
        if (root == nullptr)
        {
            height = 0;
            return true;
        }

        int leftHeight = 0, rightHeight = 0;
        if (!_IsBalance(root->_left, leftHeight)
            || !_IsBalance(root->_right, rightHeight))
        {
            return false;
        }

        if (abs(rightHeight - leftHeight) >= 2)
        {
            cout <<root->_data<<"不平衡" << endl;
            return false;
        }

        if (rightHeight - leftHeight != root->_bf)
        {
            cout << root->_data <<"平衡因子异常" << endl;
            return false;
        }

        height = leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;

        return true;
    }

这里建议可以把不想向外部展露的函数放在private里，避免对自身调用时的影响

三、代码汇总

#include <iostream>
#include <cassert>
using namespace std;
//
//我们在创造AVL树之前，先要把AVL树节点创造出来，要明确的是在AVLTreeNode类外
//我们还是需要使用到节点里面的内容，所以这里定义为struct类，默认权限为public
template <class T>
struct AVLTreeNode
{
    AVLTreeNode(const T& data)
        : _left(nullptr)
        , _right(nullptr)
        , _parent(nullptr)
        , _bf(0)
        , _data(data)
    {}
    AVLTreeNode<T>* _left;
    AVLTreeNode<T>* _right;
    AVLTreeNode<T>* _parent;
    int _bf;    //用_bf来记录树节点的左右子树高度差
    T _data;
};
///
//创造完AVLTreeNode后，可以开始创造AVLTree
//需要注意的是，我们在日常使用AVL树时，只需要使用其成员函数，并不需要用成员变量
//所以设定为class类，成员函数权限为public，成员函数权限为private
template <class T>
class AVLTree
{
public:
    //成员函数
    //插入函数
    bool insert(const T& data)
    {
        //这里插入规则与二叉搜索树一致
        //空树
        if(_root == nullptr)
        {
            _root = new Node(data);
            //创建失败
            if(_root == nullptr)
            {
                perror("new error");
                return false;
            }
            return true;
        }
        //不为空树
        else
        {
            Node* cur = _root;  //遍历找到插入的位置
            Node* parent = _root; //记录插入位置的父亲节点位置

            while(cur)
            {
                if(cur->_data > data)  //插入值小于节点值：去左子树插入
                {
                    parent = cur;
                    cur = cur->_left;
                }
                else if(cur->_data < data) //插入值大于节点值：去右子树插入
                {
                    parent = cur;
                    cur = cur->_right;
                }
                else //插入值等于节点值：插入失败
                {
                    perror("insert a same data");
                    return false;
                }
            }

            //找到插入位置了，创造新节点
            Node* newnode = new Node(data);

            if(parent->_data > data) //新节点的值比父亲的值小，插入父亲的左侧
            {
                parent->_left = newnode;
            }
            else                     //新节点的值比父亲的值大，插入父亲的右侧
            {
                parent->_right = newnode;
            }
            newnode->_parent = parent;

            //更新平衡因子bf
            UpdateBF(newnode, parent);
            return true;
        }
    }

    //遍历
    void InOrder()
    {
        _InOrder(_root);
    }

    //判断是否为AVL树
    bool IsBalance()
    {
        int height = 0;
        return _IsBalance(_root, height);
    }
private:
    typedef AVLTreeNode<T> Node;
    Node* _root = nullptr;

    //以下成员函数不希望被外部看到，所以设为private

    //判断是否是AVL树
    bool _IsBalance(Node* root, int& height)
    {
        if (root == nullptr)
        {
            height = 0;
            return true;
        }

        int leftHeight = 0, rightHeight = 0;
        if (!_IsBalance(root->_left, leftHeight)
            || !_IsBalance(root->_right, rightHeight))
        {
            return false;
        }

        if (abs(rightHeight - leftHeight) >= 2)
        {
            cout <<root->_data<<"不平衡" << endl;
            return false;
        }

        if (rightHeight - leftHeight != root->_bf)
        {
            cout << root->_data <<"平衡因子异常" << endl;
            return false;
        }

        height = leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;

        return true;
    }

    //遍历
    void _InOrder(Node* root)
    {
        if (root == nullptr)
            return;

        _InOrder(root->_left);
        cout << root->_data  << " ";
        _InOrder(root->_right);
    }

    //左旋转
    void RotationL(Node* parent, Node* cur)
    {
       Node* cleft = cur->_left;
       parent->_right = cleft;

       //cleft不为空，则需要链接其父亲，为空，则不用链接
       if(cleft)
           cleft->_parent = parent;

       cur->_left = parent;
       //
       Node* pparent = parent->_parent;
       parent->_parent = cur;

       if(parent == _root) //当parent就是根，旋转之后，cur就为根
       {
           _root = cur;
           cur->_parent = nullptr;
       }
       else //如果parent不是根，则需要判断parent在其父亲的左节点还是右节点
       {
           if(pparent->_left == parent)
           {
               pparent->_left = cur;
           }
           else
           {
               pparent->_right = cur;
           }
           cur->_parent = pparent;
       }

        //旋转之后，parent和cur的平衡因子都为0，不影响上层节点
        parent->_bf = 0;
        cur->_bf = 0;
    }

    //右旋转
    void RotationR(Node* parent, Node* cur)
    {
        Node* cright = cur->_right;
        parent->_left = cright;

        //cright存在，则链接其父亲到parent，不存在，不链接
        if(cright)
            cright->_parent = parent;

        cur->_right = parent;
        Node* pparent = parent->_parent;
        parent->_parent = cur;

        if(parent == _root) //当parent就是根，旋转之后，cur就为根
        {
            _root = cur;
            cur->_parent = nullptr;
        }
        else //如果parent不是根，则需要判断parent在其父亲的左节点还是右节点
        {
            if(pparent->_left == parent)
            {
                pparent->_left = cur;
            }
            else
            {
                pparent->_right = cur;
            }
            cur->_parent = pparent;
        }

        //旋转之后，parent和cur的平衡因子都为0，不影响上层节点
        parent->_bf = 0;
        cur->_bf = 0;
    }

    //左右旋转
    void RotationLR(Node* parent, Node* cur)
    {
        Node* cright = cur->_right;
        int bf = cright->_bf;

        RotationL(cur, cright);
        RotationR(parent, cright);

        if(bf == 1)
        {
            parent->_bf = 0;
            cright->_bf = 0;
            cur->_bf = -1;
        }
        else if(bf == -1)
        {
            parent->_bf = 1;
            cur->_bf = 0;
            cright->_bf = 0;
        }
        else
        {
            parent->_bf = 0;
            cur->_bf = 0;
            cright->_bf = 0;
        }
    }

    //右左旋转
    void RotationRL(Node* parent, Node* cur)
    {
        Node* cleft = cur->_left;
        int bf = cleft->_bf;

        RotationR(cur, cleft);
        RotationL(parent, cleft);

        if(bf == 1)
        {
            parent->_bf = -1;
            cleft->_bf = 0;
            cur->_bf = 0;
        }
        else if(bf == -1)
        {
            parent->_bf = 0;
            cur->_bf = 1;
            cleft->_bf = 0;
        }
        else
        {
            parent->_bf = 0;
            cur->_bf = 0;
            cleft->_bf = 0;
        }
    }

    //更新平衡因子
    void UpdateBF(Node*& cur, Node*& parent)
    {
        while(parent)
        {
            //我们在插入之前，parent的平衡因子可能为三种情况
            // 1、0、-1
            if(parent->_left == cur) //插入的节点在父亲的左边，bf--
            {
                --parent->_bf;
            }
            else //插入的节点在父亲的右边，bf++
            {
                ++parent->_bf;
            }

            //更新完平衡因子之后，parent的bf值可能为：2，1，0，-1，-2

            if(parent->_bf == 0)
            //说明parent在插入之前的bf为1或-1，以parent为根的左右子树高度差1
            //新增节点之后，也并不会影响整颗树的bf，只会让以parent为根的左右子树高度差更新为0
            {
                break;
            }
            else if(parent->_bf == -1 || parent->_bf == 1)
            //说明parent在插入之前的bf == 0，是AVL树，但是插入之后，会影响整体的高度
            //所以要依次向上更新
            {
                cur = parent;
                parent = cur->_parent;
            }
            else if(parent->_bf == 2 || parent->_bf == -2)
            //parent的平衡因子超过1，破坏了AVL树的规则，需要进行旋转
            //但是有4种旋转的情况
            {
                //情况1：左旋转
                if(parent->_bf == 2 && cur->_bf == 1)
                {
                    RotationL(parent, cur);
                }
                //情况2：右左旋转
                else if(parent->_bf == 2 && cur->_bf == -1)
                {
                    RotationRL(parent, cur);
                }
                //情况3：右旋转
                else if(parent->_bf == -2 && cur->_bf == -1)
                {
                    RotationR(parent, cur);
                }
                //情况4：左右旋转
                else if(parent->_bf == -2 && cur->_bf == 1)
                {
                    RotationLR(parent, cur);
                }
                else;

                //旋转结束、不需要更新
                break;
            }
            else
            {
                //平衡因子有问题
                assert(false);
            }

        }
    }
};

四、总结与完善

  1. 希望大家可以自行写出遍历操作、求树的高度、求树的节点个数等成员函数，需要注意的是，利用递归来完成的，都需要写个子函数，然后封装一下子函数.
  2. 大家感兴趣，可以自行查阅删除操作
  3. 后续会实现红黑树，红黑树那里会模拟实现一下map和set
终将向阳而生
关注
  • 29
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
平衡树的C++实现
11-04
首先，我们需要理解平衡树的基本类型，比如AVL树（Adelson-Velsky and Landis树）和红黑树（Red-Black Tree）。AVL树是最先被提出的一种自平衡二叉查找树，它的特点是严格保持平衡，即任何节点的两个子树的高度差不...
bvh：动态AABB树实现
02-22
这个过程可以通过平衡二叉树如AVL或红黑树来实现，确保树的平衡性，从而减少查询时间。 **3. 插入与删除操作** 在动态AABB树中，插入和删除物体时需要维护树的结构。插入操作涉及在现有树中找到合适的位置添加新...
C++模拟实现AVL树
小白的Coding之旅
01-06 202
AVL树的概念 一棵AVL树或者是空树，或者是具有以下性质的二叉搜索树： 它的左右子树都是AVL树 左右子树高度之差(简称平衡因子)的绝对值不超过1(-1/0/1) AVL树的旋转 如果在一棵原本是平衡的AVL树中插入一个新节点，可能造成不平衡，此时必须调整树的结构，使之平衡化。根据节点插入位置的不同，AVL树的旋转分为四种： 新节点插入较高左子树的左侧—左左：右单旋 新节点插入较高...
C++模拟实现二叉搜索树
小白的Coding之旅
12-16 228
BSTree.hpp #pragma once #include<iostream> #include<stack> using namespace std; template<class T> struct BSTreeNode { BSTreeNode(const T& data = T()) : _pLeft(nullptr) , _p...
【C++】AVL树模拟实现
m0_51064412的博客
02-22 495
文章目录一. 什么是AVL树？二. 为什么要有AVL树 一. 什么是AVL树？ 当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1，达到高度平衡，即可降低树的高度，从而减少平均搜索长度。如果一棵二叉搜索树是高度平衡的，它就是AVL树。 空树也算AVL树，AVL树一般具有一下性质： 节点的平衡因子 = 右子树高度 - 左子树高度。绝对值不大于1 它的左右子树都是AVL树 二. 为什么要有AVL树 ...
C++——AVL树及其模拟实现
fsbwb的博客
10-27 182
int _bf;
【C++】AVL树模拟实现插入功能
You don't have the guts to be what you wanna be.
08-10 321
AVL树插入功能模拟现实，四个旋转
C++实现AVL树
2303_79015671的博客
04-21 1084
AVL树的模拟实现啊
C++|AVL树(模拟实现，测试)
weixin_68201503的博客
05-20 797
节点中包括左指针，右指针，指向父节点的指针，平衡因子，要存储的数据值。//节点,_bf(0)T _bf;//平衡因子T _data;//要存储的值。
【C++、数据结构】AVL树 模拟实现
上上谦. 的博客
01-11 791
上一章节我们学习了二叉搜索树，并且模拟实现了二叉搜索树的实现。在学习完之后我们知道二叉搜索树查找的时间复杂度是〇（N），这里并不是〇（logN）具体的原因就是要搜索的二叉树并不是非常的平衡。并不是所有要查找的二叉树都是满二叉树或者是完全二叉树，有可能是单边树的情况，平均下来的时间复杂度就是〇（N）。前情回顾：二叉搜索树 👉传送门本章我们将学习AVL树，来解决上一章节二叉搜索树的查找时二叉树不平衡的问题，搬好小板凳准备开讲啦~~~ 🙋 🙋 🙋 🙋 🙋。
[数据结构 C++] AVL树的模拟实现
Ljy_cx_21_4_3的博客
01-03 2717
C++实现AVL树
算法与数据结构树的c++实现
07-02
树有多种类型，例如二叉树、二叉搜索树、完全二叉树、平衡二叉树（如AVL树和红黑树）、B树、B+树等。这些树各有其特性，适用于不同的场景。例如，二叉搜索树保证了左子树所有节点小于根节点，右子树所有节点大于根...
zupushu.rar_家族树 c_族谱_族谱c++_族谱c++二叉树_树族谱
09-19
为了提高查询效率，家族树的结构可以设计成平衡二叉树，如AVL树或红黑树，这样能保证搜索、插入和删除操作的时间复杂度为O(log n)。然而，对于较小规模的家族树，简单的二叉搜索树可能已经足够。 在实践中，家族树...
树结构示例C++程序
04-19
二叉树有几种基本类型，包括完全二叉树、满二叉树和平衡二叉树（如AVL树和红黑树）。 在C++中，实现二叉树通常涉及定义一个节点结构体或类，包含数据成员（存储节点值）和指针成员（指向左右子节点）。以下是一个...
c++AVL树的模拟实现
weixin_60358305的博客
05-11 1271
AVL与红黑树中存放的数据都是pair结构。//左孩子//右孩子//父亲int _bf;//平衡因子，健康的平衡因子绝对值不大于1:_bf(0),_kv(kv){}这里可以看到，AVL树的节点与平衡二叉树的节点区别在于AVL树节点有一个平衡因子的存在，也即1.1概念中所述。同时AVL树采用了三叉链结构，好处在于在对树进行操作时，不必额外存储节点的父亲。假如以pParent为根的子树不平衡，即pParent的平衡因子为2或者-2，分以下情况考虑。
C语言 之 理解指针（1）
fallzzzzz的博客
07-20 1311
就是先获取该数组的首元素的地址，从前面我们知道，指针的类型的作用是指针+1 所跳过的字节数，int为整形，大小为4个字节，所以p+1就跳过4个字节，p+2就跳过8个字节，计算机的CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后数据也会放回内存中，如果想对这些空间进行高效的管理，就可以。并且我们知道，数组的元素存放是随着下标增长，内存地址变大的。上面的代码创建了一个整型变量n，因为一个整形的大小是4个字节，所以内存中申请了4个字节，⽤于存放整数10，其中每个字节都有地址。
VS2019编译和使用gtest测试（C++）
最新发布
m0_65635427的博客
07-24 316
下载下来解压到文件夹，再在文件夹里面新建一个build文件夹，如下：再安装cmake，可以先检查一下是否安装了cmake，打开命令窗口，输入cmake -version：然后双击就对了，我这里已经安装好了，无法提供截图，注意一点就是在让选择是否建立系统环境变量（path）的时候，记得勾上第二个建立系统环境变量！下载好之后，记得检验一下是否安装成功，如果在普通用户下显示没有，建议用管理员身份打开命令窗口，再次尝试。之后命令窗口进入创建的build文件夹路径里面执行cmake ../
内网对抗-隧道技术篇&防火墙组策略&HTTP反向&SSH转发&出网穿透&CrossC2&解决方案
siu~
07-24 889
1、C2/C2上线-CrossC2插件-多系统平台支持 2、隧道技术篇-应用层-SSH协议-判断&封装&建立&穿透 3、隧道技术篇-应用层-HTTP协议-判断&封装&建立&穿透
树到二叉树的转换：理解转换规则
树的特性使其在很多算法和数据结构中扮演关键角色，如二叉搜索树、AVL树、红黑树等。在C++中，可以通过自定义结构体或类来表示树节点，包括节点的数据、指向子节点的指针等信息。同时，C++标准库中并没有内置的树...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

终将向阳而生

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

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

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

打赏作者

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

抵扣说明：

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

余额充值