AVLTree实现

于 2024-07-22 23:01:55 发布
阅读量758 收藏 17
点赞数 15
文章标签： 算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiyun_king/article/details/140621679
版权

AVLTree

  • AVLTree是一种特殊的搜索二叉树（左子树的值小于root，右子树的值大于root），AVLTree解决了普通的搜索二叉树可能退化为单支树导致的搜索元素效率低下的问题

AVLTree: 他的左右子树都是AVLTree，左右子树的高度差（平衡因子）的绝对值不超过1（1、0、-1）在本博客中以右子树的高度减左子树的高度作为平衡因子

AVLTree实现

  • AVLTree通过使用平衡因子的方法来实现左右高度差不超过1，如果插入新节点之后AVLTree的左右高度差超过了1，就要对这个AVLTree进行旋转处理
AVLTree节点的定义
template<typename K, typename V>
struct AVLNode{
    AVLNode(pair<K, V> kv = {K(), V()})
    :_kv(kv),
    _bt(0), _left(nullptr),
    _right(nullptr),_parent(nullptr)
    {}

   pair<K, V> _kv;
   int _bt; //balance factor
   AVLNode<K, V>* _left; 
   AVLNode<K, V>* _right; 
   AVLNode<K, V>* _parent; 
};
AVLTree的插入

​ AVLTree就是在普通的二叉搜索树中加入平衡因子，所以AVLTree也可以看作是一个二叉搜索树，所以AVLTree的插入可以分为两步

  1. 通过二叉搜索树的性质找到要插入的位置

  2. 根据平衡因子的改变对树进行调整

    注：由于我们定义的平衡因子是右子树的高度减左子树的高度，所以如果插入的新的节点在parent的右边的化parent->bt++ 否则 parent->bt–

  • 完整代码
template<typename K, typename V>
    bool AVLTree<K, V>::insert(const pair<K, V>& kv){
/
/*找到要插入的位置并将节点插入*/
        if(_root == nullptr){
            _root = new Node(kv);
        }
        //find position to insert
        Node *cur = _root, *parent = _root;
        while(cur){
            parent = cur;
            if(kv.first > cur->_kv.first){
                cur = cur->_right;
            }else if(kv.first < cur->_kv.first){
                cur = cur->_left;
            }else{
                return false;
            }
        }

        //link
        Node* node = new Node(kv);
        if(kv.first > parent->_kv.first){
            parent->_right = node;
        }else{
            parent->_left = node;
        }
        node->_parent = parent;
/
/*调整平衡因子并根据平衡因子进行旋转操作*/
        while(parent){
            //renewal balance factor
            if(node == parent->_left) parent->_bt--;
            else parent->_bt++;
            if(parent->_bt == 0) break;
///*旋转操作*/
            if(parent->_bt == 2 || parent->_bt == -2){
                if(parent->_bt == 2 && node->_bt == 1){
                    RotateL(parent);
                }else if(parent->_bt == -2 && node->_bt == -1){
                    RotateR(parent);
                }else if(parent->_bt == 2 && node->_bt == -1){
                    Node* SubR = parent->_right; 
                    Node* SubRL = SubR->_left;
                    int bt = SubRL->_bt;
                    RotateRL(parent);
                    //renewal balance factor
                    if(bt == 0){
                        SubR->_bt = parent->_bt = 0;
                    }else if(bt == 1){
                        parent->_bt = -1;
                        SubR->_bt = SubRL->_bt = 0;
                    }else if(bt == -1){
                        SubRL->_bt = parent->_bt = 0;
                        SubR->_bt = 1;
                    }

                }else if(parent->_bt == -2 && node->_bt == 1){
                    Node* SubL = parent->_left;
                    Node* SubLR = SubL->_right;
                    int bt = SubLR->_bt;
                    RotateLR(parent);
                    //renewal balance factor
                    if(bt == 0){
                        SubL->_bt = parent->_bt = 0;
                    }else if(bt == 1){
                        SubL->_bt = -1;
                        SubLR->_bt = parent->_bt = 0;
                    }else if(bt == -1){
                        SubL->_bt = SubLR->_bt = 0;
                        parent->_bt = 1;
                    }
                }
                break;
            }
            node = parent;
            parent = parent->_parent;
        }
    }
AVLTree平衡因子的更新

当我们插入节点时并不是每次都要进行旋转的，要看我们插入的位置以及对于整个树高度的影响

  1. 如果插入之后parent-bt == 0证明这个子树高度不变，直接可以退出
  2. 如果插入之后parent->bt == 2/-2那么就要根据情况来进行合适的旋转
  3. 否则就要继续向上更新，将node = parent; parent = node->_parent
AVLTree的旋转

​ 如果在一个原本是平衡的AVL树中插入一个新节点，可能造成不平衡，此时必须要调整树的结构，使之平衡化。根据节点插入位置的不同，AVL的旋转有四种

    1. 新插入的节点在较高左子树的左侧 – 左左： 右单旋

      在这里插入图片描述

      这种情况是较为简单的，我们可以设置30为SubL， 60为parent， 30的右节点为SubLR，只要将SubL->right = parent, parent->right = SubLR, 同时更新他们的父节点就可以了（这里要注意保存parent的父节点，并判断是否为nullptr如果是nullptr，那就要让SubL变成root）

      • 代码
      template<typename K, typename V>
    void AVLTree<K, V>::RotateR(Node* parent){
        Node* SubL = parent->_left;
        Node* SubLR = SubL->_right;
        Node* Parent_parent = parent->_parent;

        //link
        SubL->_right = parent;
        parent->_parent = SubL;
        parent->_left = SubLR;
        if(SubLR) SubLR->_parent = parent;
        if(Parent_parent == nullptr){
            _root = SubL;
        }else{
            if(Parent_parent->_left == parent){
                Parent_parent->_left = SubL;
            }else{
                Parent_parent->_right = SubL;
            }
        }
        SubL->_parent = Parent_parent;

        //renewal balance factor
        parent->_bt = SubL->_bt = 0;
    }

    1. 新插入的节点在较高右子树的右侧 – 右右：左单选

      在这里插入图片描述

      具体内容与左左单旋一致，直接上代码

         template<typename K, typename V>
   void AVLTree<K, V>::RotateL(Node* parent){
       Node* SubR = parent->_right;
       Node* SubRL = SubR->_left;
       Node* Parent_parent = parent->_parent;

       //link
       SubR->_left = parent;
       parent->_parent = SubR;
       parent->_right = SubRL;
       if(SubRL) SubRL->_parent = parent; 
       if(Parent_parent == nullptr){
           _root = SubR;
       }else{
           if(parent == Parent_parent->_left){
               Parent_parent->_left = SubR;
           }else{
               Parent_parent->_right = SubR;
           }
       }
       SubR->_parent = Parent_parent;

       //renewal balance factor
       parent->_bt = SubR->_bt = 0;
   }

    1. 新节点插入较高右子树的左侧—右左：先右单旋再左单旋

      在这里插入图片描述

      由于这种情况较为复杂，书面并不能很好的表达清楚，所以仅仅把图和代码贴给大家，大家可以自己根据左旋和右旋的概念自己画一遍，并根据代码写一遍可以更好的理解就是先对90进行右单旋，再对30进行左单旋，这个的难点不是代码，而是对平衡因子的掌控，因为插入在b中还是在c中对30和90的平衡因子会造成影响，所以请大家结合这个图自行画图思考

      //旋转代码
template<typename K, typename V>
    void AVLTree<K, V>::RotateRL(Node* parent){
        Node* SubR = parent->_right;
        Node* SubRL = SubR->_left;
        
        RotateR(SubR);
        RotateL(parent);
    }

      			//平衡因子更新代码
			else if(parent->_bt == 2 && node->_bt == -1){
                    Node* SubR = parent->_right; 
                    Node* SubRL = SubR->_left;
                    int bt = SubRL->_bt;
                    RotateRL(parent);
                    //renewal balance factor
                    if(bt == 0){
                        SubR->_bt = parent->_bt = 0;
                    }else if(bt == 1){
                        parent->_bt = -1;
                        SubR->_bt = SubRL->_bt = 0;
                    }else if(bt == -1){
                        SubRL->_bt = parent->_bt = 0;
                        SubR->_bt = 1;
                    }

    1. 新节点插入较高左子树的右侧—左右：先左单旋再右单旋

      在这里插入图片描述

      • 代码
      			//更新平衡因子
			else if(parent->_bt == -2 && node->_bt == 1){
                    Node* SubL = parent->_left;
                    Node* SubLR = SubL->_right;
                    int bt = SubLR->_bt;
                    RotateLR(parent);
                    //renewal balance factor
                    if(bt == 0){
                        SubL->_bt = parent->_bt = 0;
                    }else if(bt == 1){
                        SubL->_bt = -1;
                        SubLR->_bt = parent->_bt = 0;
                    }else if(bt == -1){
                        SubL->_bt = SubLR->_bt = 0;
                        parent->_bt = 1;
                    }

          //旋转
    template<typename K, typename V>
    void AVLTree<K, V>::RotateLR(Node* parent){
        Node* SubL = parent->_left;
        Node* SubLR = SubL->_right;
        
        RotateL(SubL);
        RotateR(parent);
    }

平衡二叉树的验证

  1. 验证其为二叉树 (中序得到一个有序序列)
  2. 验证其为平衡树 (左右子树高度差不超过1)
  • 代码
    template<typename K, typename V>
    int AVLTree<K, V>::_Height(Node* root){
        if(root == nullptr) return 0;

        int left_height = _Height(root->_left);
        int right_height = _Height(root->_right);

        return left_height > right_height ? left_height+1 : right_height+1;
    }

    template<typename K, typename V>
    bool AVLTree<K, V>::_IsBalance(Node* root){
        if(root == nullptr) return true;

        int left_height = _Height(root->_left);
        int right_height = _Height(root->_right); 

        //这里是判断错误的情况，如果正确，还要递归判断其左右子树
        if(abs(left_height - right_height) >= 2 || abs(root->_bt) >= 2)
            return false;

        bool left_is_balance = _IsBalance(root->_left);
        bool right_is_balance = _IsBalance(root->_right);

        return left_is_balance && right_is_balance;
    }

总结

总结： 假如以pParent为根的子树不平衡，即pParent的平衡因子为2或者-2，分以下情况考虑

  1. pParent的平衡因子为2，说明pParent的右子树高，设pParent的右子树的根为pSubR

当pSubR的平衡因子为1时，执行左单旋 当pSubR的平衡因子为-1时，执行右左双旋

  1. pParent的平衡因子为-2，说明pParent的左子树高，设pParent的左子树的根为pSubL

当pSubL的平衡因子为-1是，执行右单旋 当pSubL的平衡因子为1时，执行左右双旋 旋转完成后，原pParent为根的子树个高度降低，已经平衡，不需要再向上更新。

spigcoder
关注
  • 15
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
【数据结构】AVLTree实现详解
EWIAW_ilove的博客
06-08 1109
在二叉搜索树的博客中，我们提到了，当插入的数据有序或者接近有序的时候，二叉搜索树会退化成单支树，导致其效率变低，所以为了解决这种情况，于是我们提出了AVLTree，即二叉平衡搜索树。如下图就是一棵二叉搜索树退化成的单支树。那么AVLTree又是如何实现使二叉树搜索树不会退化成单支树的呢，它又是如何保证效率的呢？因为AVLTree严格的要求左右子树的高度差不能大于1，且每一棵子树也一样。如下图所示。
程序员修炼手册--AVLTree实现--附源代码
c-and-c++ It*s my life
06-04 302
AVLtree三叉链实现
数据结构之Java实现AVL Tree
zhangjun62的博客
09-28 1720
AVL Tree是最早的自平衡二分搜索树结构。平衡二叉树对于任意结点左子树与右子树高度差不超过1，平衡二叉树高度与结点数量为O(log n)关系。每一个结点需要记录每一个结点的高度，计算平衡因子，平衡因子等于左子树高度减去右子树高度。对于一个二分搜索树，当添加元素时会破坏平衡，这时需要维护，删除元素时也会造成平衡破坏，需要维护平衡。主要有四种情况，分别如下 1.LL，平衡因子大于1，左子树平衡因...
AVLTree的实现C++
C++
02-22 260
普通的binary Search Tree的大量插入删除操作会造成树的不平衡，使得查找等操作效率不再为O(logn)。 AVLTree能够保证插入，删除，查找等操作在O(logn)内完成。 组成AVLTree的最少节点数与斐波那契数列的关系。 AVLTree的插入操作完成插入后需要更新节点的高度信息，并重新平衡此树， 找到发现问题的节点（imbalance factor == 2），并平衡以...
avltree实现
10-16
平衡二叉树实现 平衡二叉树的实质就是保持树“尽量胖，尽量矮
AVL tree实现源码
06-25
AVL tree的源码实现。该AVL tree为模板容器，可以在其中放入任何东西。被放入的对象需要实现拷贝构造函数与赋值构造函数。该程序能够在linux下面顺利通过编译。平时随意开发，如有不足之处，还请见谅！！！
AVltree_avltree_
09-30
3. `avltree_test.c`：这是一个测试文件，用于验证`avltree.c`中的AVL树实现是否正确。通常，它会包含一些测试用例，通过插入、删除和查找操作来检查AVL树的正确性和性能。 4. `avltree_test`：这个可能是编译后的...
AVLTree实现的源代码
04-12
在给定的代码中，主要展示了AVL树的插入操作的实现。 首先，我们看到`avlInsert`函数用于在AVL树中插入一个新节点。这个函数首先检查树是否为空，如果为空，则直接创建一个新节点作为树的根节点。接着，通过循环...
avltree算法.rar_avl_avl tree
09-21
在"www.pudn.com.txt"和"AVLTree"这两个文件中，可能包含了关于AVL树的更多详细信息，如实现代码、示例或进一步的解释。学习AVL树不仅能够理解其基本概念和操作，还能深入理解数据结构的设计和优化，这对于理解和...
【18】输出字符菱形
2301_78786609的博客
07-19 372
用‘*’构造一个对角线长n个字符，倾斜放置的菱形。
Leetcode—207. 课程表【中等】
Atticus的博客
07-19 309
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
插入和选择排序
c23856的博客
07-20 443
我们来计算一下它的时间复杂度：我们知道时间复杂度是计算最坏的情况，在这里的最坏情况为逆序，因为逆序的时候每次插入都需要执行前面数的数量，那么我们假设其有N个数，那么总执行量就为：1+2+3...+N-1 即为(N^2)/2。时间复杂度：O(N*logN),我们设该树高为h，那么树的所有节点为N=2^h-1个，我们的时间复杂度要换成与数量有关的式子，所以时间复杂度为O(N*logN).希尔排序是在插入排序的基础上，效率更高的排序，其实就是在插入排序的基础上加上了与预排序的操作。
2024.7.19 刷题总结
TheJustice_的博客
07-19 232
543.二叉树的直径，这道题是一道考察递归的题目，按照树的一般算法，维护一个最大直径答案值，定义一个递归函数，开头是递归返回条件，即当前节点为空节点就返回0，否则分别往左和往右递归，维护每个节点的最大深度为左右最大深度中的最大值再加一，答案用左右节点的最大深度的和再加一来维护.124.二叉树中的最大路径和，这是一道考察递归的题目，从根节点出发，类似于dfs，分别递归寻找左右节点的路径和，直到叶子节点再返回，从叶子节点往上更新以每个节点为根节点的最大路径，直到返回根节点，用一个变量来维护答案.
算法刷题笔记 排列数字（C++实现）
hanmo22357的博客
07-17 305
一道简单的深度优先搜索（DFS）模板题，给出了DFS问题的一般思路以及C++代码实现
python实现图像缩放算法
最新发布
qq_42568323的博客
07-20 322
它通过选择离目标像素最近的原始像素的颜色值来确定目标像素的颜色值。它通过考虑目标像素周围16个像素的颜色值，使用双三次插值公式计算出目标像素的颜色值。相较于双线性插值，双三次插值能生成更平滑、更细腻的图像效果。它通过考虑目标像素周围四个像素的颜色值，使用双线性插值公式计算出目标像素的颜色值。尽管最近邻插值在某些应用场景中足够使用，但在需要更高质量图像的场景中，通常会选择更加复杂的插值方法，如双线性插值或双三次插值。双三次插值是图像缩放中高质量的方法之一，适合需要高质量图像处理的应用场景。
(算法)区间调度问题
2202_75519246的博客
07-17 245
此外,参与工作的时间段不能重复(即使是开始的瞬间和结束的瞬间的重叠也是不允许的). 你的目标是参与尽王多的工作,那么最多能参与多少项工作呢?有n项工作,每项工作分别在s时间开始,在t时间结束. 对于每项工作,你都可以选择参与与否,如果选择了参与,那么自始至终都必须全程参与.
傻瓜图解 -- 算法刷题之路之链表初探（八 ）旋转链表
aoyuanyuan0921的博客
07-19 179
今天来学习的算法题是leecode61旋转链表，是一道简单的入门题，话不多说！原子本来写了一大推书面解释！我直接上图，如果有疑问的话私信我交流一下！
【刷题汇总 -- 压缩字符串(一)、chika和蜜柑、 01背包】
m0_69455439的博客
07-19 1130
今日刷题汇总day018 -- 压缩字符串(一)、chika和蜜柑、 01背包
用python实现avl
05-24
AVL 树是一种自平衡二叉搜索树，它可以在 O(log n) 时间内完成查找、插入和删除操作。以下是 Python 实现 AVL 树的示例代码： ```python # AVL 树节点类 class AVLNode: def __init__(self, key): self.key = key self.left = None self.right = None self.height = 1 # AVL 树类 class AVLTree: def __init__(self): self.root = None # 获取节点高度 def get_height(self, node): if node is None: return 0 return node.height # 获取节点的平衡因子 def get_balance_factor(self, node): if node is None: return 0 return self.get_height(node.left) - self.get_height(node.right) # 右旋转 def rotate_right(self, node): left_child = node.left left_right_child = left_child.right left_child.right = node node.left = left_right_child node.height = 1 + max(self.get_height(node.left), self.get_height(node.right)) left_child.height = 1 + max(self.get_height(left_child.left), self.get_height(left_child.right)) return left_child # 左旋转 def rotate_left(self, node): right_child = node.right right_left_child = right_child.left right_child.left = node node.right = right_left_child node.height = 1 + max(self.get_height(node.left), self.get_height(node.right)) right_child.height = 1 + max(self.get_height(right_child.left), self.get_height(right_child.right)) return right_child # 插入节点 def insert(self, key): def insert_node(node, key): if node is None: return AVLNode(key) elif key < node.key: node.left = insert_node(node.left, key) else: node.right = insert_node(node.right, key) node.height = 1 + max(self.get_height(node.left), self.get_height(node.right)) balance_factor = self.get_balance_factor(node) # 左旋转 if balance_factor > 1 and key < node.left.key: return self.rotate_right(node) # 右旋转 if balance_factor < -1 and key > node.right.key: return self.rotate_left(node) # 左右旋转 if balance_factor > 1 and key > node.left.key: node.left = self.rotate_left(node.left) return self.rotate_right(node) # 右左旋转 if balance_factor < -1 and key < node.right.key: node.right = self.rotate_right(node.right) return self.rotate_left(node) return node self.root = insert_node(self.root, key) # 删除节点 def delete(self, key): def delete_node(node, key): if node is None: return node elif key < node.key: node.left = delete_node(node.left, key) elif key > node.key: node.right = delete_node(node.right, key) else: # 节点只有一个子节点或没有子节点 if node.left is None: temp = node.right node = None return temp elif node.right is None: temp = node.left node = None return temp # 节点有两个子节点 temp = self.get_min_node(node.right) node.key = temp.key node.right = delete_node(node.right, temp.key) if node is None: return node node.height = 1 + max(self.get_height(node.left), self.get_height(node.right)) balance_factor = self.get_balance_factor(node) # 左旋转 if balance_factor > 1 and self.get_balance_factor(node.left) >= 0: return self.rotate_right(node) # 右旋转 if balance_factor < -1 and self.get_balance_factor(node.right) <= 0: return self.rotate_left(node) # 左右旋转 if balance_factor > 1 and self.get_balance_factor(node.left) < 0: node.left = self.rotate_left(node.left) return self.rotate_right(node) # 右左旋转 if balance_factor < -1 and self.get_balance_factor(node.right) > 0: node.right = self.rotate_right(node.right) return self.rotate_left(node) return node self.root = delete_node(self.root, key) # 获取最小节点 def get_min_node(self, node): if node is None or node.left is None: return node return self.get_min_node(node.left) # 中序遍历 def inorder_traversal(self): def inorder(node): if node is not None: inorder(node.left) print(node.key, end=" ") inorder(node.right) inorder(self.root) ``` 示例用法： ```python avl_tree = AVLTree() avl_tree.insert(10) avl_tree.insert(20) avl_tree.insert(30) avl_tree.insert(40) avl_tree.insert(50) avl_tree.insert(25) avl_tree.inorder_traversal() avl_tree.delete(30) avl_tree.inorder_traversal() ``` 输出结果： ``` 10 20 25 30 40 50 10 20 25 40 50 ```
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值