有关AVL树的平衡化旋转和插入

最新推荐文章于 2023-02-05 22:22:34 发布
最新推荐文章于 2023-02-05 22:22:34 发布
阅读量390 收藏 1
点赞数
分类专栏： 数据结构 文章标签： AVLTree
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/apt1203JN/article/details/79508768
版权

一、AVL树的概念
1、定义：一棵高度平衡的二叉搜索树，就是AVL树。
2、性质：
(1) 它的左右子树均为AVL树
(2) 左子树和右子树的高度之差（简称平衡因子）的绝对值不超过1（-1、0、1）
3、平衡因子的计算方法：左右子树的高度差

二、AVL树的平衡化旋转
1、左单旋：插入的节点位于较高右子树的右侧（右右）
*******当插入节点f之后，a节点的平衡因子的绝对值为2，此时的树已不满足AVL树的性质，需要通过左单旋去调节平衡因子已达到树的平衡。（将c节点往上提，a节点往下放）
这里写图片描述
这里写图片描述
代码如下：

void RotateL(pNode pParent)
    {
        //先找双亲的右子树,右子树的左子树
        pNode pSubR = pParent->_pRight;
        pNode pSubRL = pSubR->_pLeft;

        //先处理pSubRL
        pParent->_pRight = pSubRL;

        if(pSubRL)
            pSubRL->_pParent = pParent;

        pSubR->_pLeft = pParent;
        pNode ppParent = pSubR->_pParent;
        pParent->_pParent = pSubR;

        if(pParent == _pRoot)
        {
            pSubR->_pLeft = pParent;
            pSubR->_pParent = NULL;
        }

        //判断pParent为左子树还是右子树
        else if(ppParent->_pLeft == pParent)
        {
            ppParent->_pLeft = pSubR;
        }

        else
        {
            ppParent->_pRight = pSubR;
        }
        pSubR->_pParent = ppParent;

        //更新平衡因子
        pParent->_bf = pSubR->_bf = 0;
    }

2、右单旋：插入的节点位于较高左子树的左侧（左左）
****当插入节点f之后，a节点的平衡因子的绝对值为2，此时的树已不满足AVL树的性质，需要通过右单旋去调节平衡因子已达到树的平衡。（将b节点往上提，a节点往下放）
这里写图片描述
这里写图片描述

void RotateR(pNode pParent)
    {
        //先找双亲的左子树，以及左子树的右子树
        pNode pSubL = pParent->_pLeft;
        pNode pSubLR = pSubL->_pRight;

        //先处理pSubLR
        pParent->_pLeft = pSubLR;

        if(pSubLR)
            pSubLR->_pParent = pParent;

        pSubL->_pRight = pParent;
        pNode ppParent = pSubL->_pParent;
        pParent->_pParent = pSubL;

        if(pParent == _pRoot)
        {
            pSubL->_pRight = pParent;
            pSubL->_pParent = NULL;
        }

        //判断pParent为左子树还是右子树
        else if(ppParent->_pLeft == pParent)
        {
1           ppParent->_pLeft = pSubL;
        }

        else
        {
            ppParent->_pRight = pSubL;
        }
        pSubL->_pParent = ppParent;

        //更新平衡因子
        pParent->_bf = pSubL->_bf = 0;
    }

3、左右双旋（先左单旋后右单旋）：插入的节点位于较高左子树的右侧
*******当插入节点f之后，a节点的平衡因子的绝对值为2，此时的树已不满足AVL树的性质，需要通过左右单旋去调节平衡因子已达到树的平衡。先以b节点为根节点左单旋调节a的左子树的平衡，再去整体右单旋调节整个子树
这里写图片描述

void RotateLR(pNode pParent)
    {
        pNode pSubL = pParent->_pLeft;
        pNode pSubLR = pSubL->_pRight;

        RotateL(pParent);
        RotateR(pParent->_pLeft);    

        //更新平衡因子
        int bf = pSubLR->_bf;
        if(bf == 1)
            pSubL->_bf = -1;
        else if(bf == -1)
            pSubL->_bf = 1;
    }

4、右左双旋（先右单旋后左单旋）：插入的节点位于较高右子树的左侧
**** 当插入节点f之后，a节点的平衡因子的绝对值为2，此时的树已不满足AVL树的性质，需要通过右左单旋去调节平衡因子已达到树的平衡。先以c节点为根节点右单旋调节a的右子树的平衡，再去整体左单旋调节整个子树

这里写图片描述

void RotateRL(pNode pParent)
    {
        pNode pSubR = pParent->_pRight;
        pNode pSubRL = pSubR->_pLeft;

        RotateR(pParent); 
        RotateL(pParent);    

        //更新平衡因子
        int bf = pSubRL->_bf;
        if(bf == 1)
            pSubR->_bf = -1;
        else if(bf == -1)
            pSubR->_bf = 1;
    }

三、AVL树的插入
算法如下：
1、若树为空，插入后即为根节点，插入后直接返回true
2、若树不为空，寻找要插入的位置（若在寻找过程中找到key，则插入失败返回false）
3、插入节点
4、调节平衡因子

注意：新节点的平衡因子为0，但其双亲pParent的平衡因子有三种情况：

  • （1）若pParent的平衡因子为0，即在pParent的较矮的子树上插入新节点，pParent此时是平衡的，但此时pParent到根节点路径上的各节点为根的子树的高度不变，即各个节点的平衡因子不变。不需要调节平衡因子
  • （2）若pParent的平衡因子的绝对值为1，则插入前的pParent的平衡因子为0，插入后以pParent为根的子树没有失去平衡，但该子树的高度发生增加，此时需要从pParent向根节点依次查看pParent的双亲的平衡因子
  • （3）步骤2更新平衡因子之后，若pParent的平衡因子的绝对值为2，新节点在较高的子树插入，需要做平衡化处理
  • （3.1）若pParent->_bt == 2，说明右子树高，设pParent的右子树为pSubR。当pSubR的平衡因子为1时，执行左单旋；当pSubR的平衡因子为-1时，执行右左双旋
  • （3.2）若pParent->_bt == -2，说明左子树高，设pParent的左子树为pSubL。当pSubL的平衡因子为-1时，执行右单旋；当pSubL的平衡因子为1时，执行左右双旋
  • 旋转后pParent为根的子树高度降低，无需继续向上查看

完整代码如下：

#include<math.h>
#include<iostream>
using namespace std;
template <class V, class K>
struct AVLTreeNode
{
      //给左右子树,  双亲结点
      AVLTreeNode<V,K>* _pLeft;
      AVLTreeNode<V,K>* _pRight;
      AVLTreeNode<V,K>* _pParent;
      K _key;        //关键码
      V _value;
      int _bf;      //平衡因子
      //构造函数
      AVLTreeNode(const K& key, const V& value)
            :_pLeft(NULL)
            ,_pRight(NULL)
            ,_pParent(NULL)
            ,_key(key)
            ,_value(value)
            ,_bf(0)
      {}
};
template <class V, class K>
class AVLTree
{
      typedef AVLTreeNode<V,K> Node;
      typedef Node* pNode;
public:
      //构造函数
      AVLTree()
            :_pRoot(NULL)
      {}
      //插入结点
      bool Insert(const K& key, const V& value)
      {
            //如果树为空，直接插入
            if(NULL == _pRoot)
            //创建新结点,让其等于搜索二叉树的根
            {
                  _pRoot = new Node(key, value);
                  return true;
            }

            else
            {
                  //树不为空，分情况
                  pNode pParent = NULL;
                  pNode pCur = _pRoot;
                  //插入结点
                  while(pCur)
                  {
                        if(key > pCur->_key)
                        {
                              pParent = pCur;
                              pCur = pCur->_pRight;
                        }
                        else if(key < pCur->_key)
                        {
                              pParent = pCur;
                              pCur = pCur->_pLeft;
                        }
                        else
                              return true;
                  }
                  pCur = new Node(key, value);
                  if(key > pParent->_key)
                  {
                        pParent->_pRight = pCur;
                        pCur->_pParent = pParent;
                  }
                  else
                  {
                        pParent->_pLeft = pCur;
                        pCur->_pParent = pParent;
                  }
                  //调节平衡因子
                  while(pParent)
                  {
                        if(pParent->_pLeft = pCur)
                        {
                              pParent->_bf--;
                        }
                        else
                        {
                              pParent->_bf++;
                        }
                        if(pParent->_bf == 0)
                              break;
                        else if(pParent->_bf == 1 || pParent->_bf == -1)
                        {
                              pCur = pParent;
                              pParent = pCur->_pParent;
                        }
                        else
                        {
                              if(pParent->_bf == 2)
                              {
                                    if(pCur->_bf == 1)
                                          RotateL(pParent);
                                    else   //-1
                                          RotateRL(pParent);
                              }
                              else
                              {
                                    if(pCur->_bf == -1)
                                          RotateR(pParent);
                                    else     //1
                                          RotateLR(pParent);
                              }
                        }
                        break;
                  }
            }
            return true;
      }
      void Inorder()
      {
            _Inorder(_pRoot);
            cout<<endl;
      }
      bool IsBalance()
      {
            return _IsBalance(pRoot);
      }
private:
      //左单旋---插入较高右子树的右侧
      void RotateL(pNode pParent)
      {
            //先找双亲的右子树,右子树的左子树
            pNode pSubR = pParent->_pRight;
            pNode pSubRL = pSubR->_pLeft;
            //先处理pSubRL
            pParent->_pRight = pSubRL;
            if(pSubRL)
                  pSubRL->_pParent = pParent;
            pSubR->_pLeft = pParent;
            pNode ppParent = pSubR->_pParent;
            pParent->_pParent = pSubR;
            if(pParent == _pRoot)
            {
                  pSubR->_pLeft = pParent;
                  pSubR->_pParent = NULL;
            }
            //判断pParent为左子树还是右子树
            else if(ppParent->_pLeft == pParent)
            {
                  ppParent->_pLeft = pSubR;
            }
            else
            {
                  ppParent->_pRight = pSubR;
            }
            pSubR->_pParent = ppParent;
            //更新平衡因子
            pParent->_bf = pSubR->_bf = 0;
      }
      //右单旋---插入较高左子树的左侧
      void RotateR(pNode pParent)
      {
            //先找双亲的左子树，以及左子树的右子树
            pNode pSubL = pParent->_pLeft;
            pNode pSubLR = pSubL->_pRight;
            //先处理pSubLR
            pParent->_pLeft = pSubLR;
            if(pSubLR)
                  pSubLR->_pParent = pParent;
            pSubL->_pRight = pParent;
            pNode ppParent = pSubL->_pParent;
            pParent->_pParent = pSubL;
            if(pParent == _pRoot)
            {
                  pSubL->_pRight = pParent;
                  pSubL->_pParent = NULL;
            }
            //判断pParent为左子树还是右子树
            else if(ppParent->_pLeft == pParent)
            {
                  ppParent->_pLeft = pSubL;
            }
            else
            {
                  ppParent->_pRight = pSubL;
            }
            pSubL->_pParent = ppParent;
            //更新平衡因子
            pParent->_bf = pSubL->_bf = 0;
      }
      //左右双旋---插入较高左子树的右侧(先左旋后右旋)
      void RotateLR(pNode pParent)
      {
            pNode pSubL = pParent->_pLeft;
            pNode pSubLR = pSubL->_pRight;
            RotateL(pParent);
            RotateR(pParent->_pLeft);   
            //更新平衡因子
            int bf = pSubLR->_bf;
            if(bf == 1)
                  pSubL->_bf = -1;
            else if(bf == -1)
                  pSubL->_bf = 1;
      }
      //右左双旋---插入较高右子树的左侧(先右旋后左旋)
      void RotateRL(pNode pParent)
      {
            pNode pSubR = pParent->_pRight;
            pNode pSubRL = pSubR->_pLeft;
            RotateR(pParent);
            RotateL(pParent);   
            //更新平衡因子
            int bf = pSubRL->_bf;
            if(bf == 1)
                  pSubR->_bf = -1;
            else if(bf == -1)
                  pSubR->_bf = 1;
      }
      void _Inorder(pNode pRoot)
      {
            if(NULL == pRoot)
                  return;
            _Inorder(pRoot->_pLeft);
            _Inorder(pRoot->_pRight);
      }
      bool _IsBalance(pNode pRoot)
      {
            //树为空
            if(NULL == pRoot)
                  return true;
            //树存在
            int leftHeight = _Height(pRoot->_pLeft);
            int rightHeight = _Height(pRoot->_pRight);

            if(abs(rightHeight - leftHeight) >= 2)
                  return false;
            return _IsBalance(pRoot->_pLeft)&&_IsBalance(pRoot->_pRight);
      }

      int _Height(pNode pRoot)
      {
            if(NULL == pRoot)
                  return 0;
            int leftHeight = _Height(pRoot->_pLeft);
            int rightHeight = _Height(pRoot->_pRight);
            return ((leftHeight>rightHeight?leftHeight:rightHeight)+1);
      }
protected:
      pNode _pRoot;
};
void AVLTreeTest()
{
      int array[] = {16, 3, 7, 11, 9, 26, 18, 14, 15};
      AVLTree<int, int> A;
      for(int i = 0; i<sizeof(array)/sizeof(array[0]); ++i)
      {
            A.Insert(array[i], i);
      }
      A.Inorder();
}
int main()
{
      void AVLTreeTest();
      return 0;
}

哈哈，有关AVL树的四种旋转的情况有多重，我只画了一部分，读者可以自行画出全部！！！

慵懒de疯子
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
1123. Is It a Complete AVL Tree(AVL树旋转、判断完全二叉树)
写代码的柯长的博客
03-08 607
Is It a Complete AVL Tree (30) An AVL tree is a self-balancing binary search tree. In an AVL tree, the heights of the two child subtrees of any node differ by at most one; if at any time they differ b
avl树的删除、插入、平衡化旋转算法实现
07-26
本程序实现了AVL树的基本操作，包括节点的插入、删除以及在插入或删除后进行的平衡旋转。 首先，插入操作是AVL树中的关键步骤。当一个新节点被插入到树中时，可能会破坏AVL树的平衡条件。如果插入后某个节点的平衡...
AVL树的平衡化旋转
单打乔的Log
05-23 316
左单旋：右单旋： 左右双旋： 右左双旋：
【数据结构】AVL树及平衡化旋转
Cheng_913的博客
01-26 1183
   二叉搜索树可以缩短查找的效率，但是如果数据有序或接近有序时二叉搜索树将退化为单支树，查找效率将会下降。因此，我们通过向二叉搜索树种插入结点后，保证左右子树的高度之差的绝对值不超过1来调节结点，降低树的高度。 一. AVL树概念：   一颗AVL树是一颗空树或者具有如下性质的二叉搜索树: 1.它的左右子树都是AVL树； 2.左子树和右子树高度之差（简称平衡因子）的绝对值不超过1； ...
【数据结构】AVL树的平衡化旋转及实现AVL树的插入操作
sofia_m的博客
04-05 987
1、AVL树 在计算机科学中，AVL树是最先发明的自平衡二叉查找树。在AVL树中任何节点的两个子树的高度最大差别为一，所以它也被称为高度平衡树。增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。AVL树得名于它的发明者 G.M. Adelson-Velsky 和 E.M. Landis，他们在 1962 年的论文 “An algorithm for the organization of ...
平衡二叉树（AVL树）
学习日常分享
02-17 1272
为什么引入“平衡二叉树” 二叉搜索树上实现查找的时间复杂度与从根节点到所查对象节点的路径成正比，最坏情况下等于树的高度。 在构造二叉搜索树时，如果输入对象的序列恰好是按其关键码大小有序，则结果将产生一棵单支树。 例如：输入序列为{11,39,46,38,75} 在这样的树上查找所需要的时间是O(n)（与节点个数成正比）。 平衡二叉树的定义 平衡树（Balanced Tree）：高度为O(logn)的树。 平衡二叉树（Balanced Binary Tree）：由阿德尔森一维尔斯和兰迪斯（Adelson-V
AVL平衡树及插入操作的C语言实现
06-21
AVL平衡树是一种自平衡的二叉搜索树（Binary Search Tree），由G. M. Adelson-Velsky和E. M. Landis于1962年提出，因此得名AVL树。在AVL树中，任何节点的两个子树的高度最大差别不超过1，这确保了树的平衡性，从而...
AVL树图形化界面操作-MFC
09-17
这种数据结构的主要特点是，任何节点的两个子树的高度差不超过1，这使得AVL树在插入和删除操作后能通过旋转保持平衡，从而保证了搜索、插入和删除操作的时间复杂度都是O(log n)。 MFC（Microsoft Foundation ...
AVLTree.zip_平衡树
09-14
AVL树的特点是任何节点的两个子树的高度最大差别不超过1，这使得AVL树在插入和删除操作后依然能保持良好的平衡状态，从而保证了O(log n)的时间复杂度。 平衡树的主要目标是解决普通BST在最坏情况下的性能问题，即当...
C语言数据结构之平衡二叉树（AVL树）实现方法示例
08-28
本文将详细介绍C语言数据结构之平衡二叉树（AVL树）实现方法，并结合实例形式分析了C语言平衡二叉树的相关定义与使用技巧。 知识点一：AVL树的定义 AVL树是一种自平衡的二叉查找树，每个结点的左子树和右子树的...
平衡二叉树AVL插入
aipiannian6725的博客
07-21 61
平衡二叉树(Balancedbinary tree)是由阿德尔森-维尔斯和兰迪斯(Adelson-Velskiiand Landis)于1962年首先提出的，所以又称为AVL树。 定义：平衡二叉树或为空树,或为如下性质的二叉排序树: （1）左右子树深度之差的绝对值不超过1; （2）左右子树仍然为平衡二叉树. 平衡二叉树可以避免排序二叉树深度上的极度恶化，使树的...
【数据结构】基础：AVL树（平衡二叉树）
最新发布
qq_66725576的博客
02-05 489
本文介绍二叉搜索树的改进AVL树（平衡二叉树），将对其概念与实现两部分展开。主要介绍其中的插入过程，其难点主要在于4个旋转过程。这个四个旋转过程，作者从几何特征，平衡因子特征出发，观察其变化情况与细节以及平衡因子的改变。最后进行性能分析的简要介绍。由于删除考察得比较少，因此本文并不对此进行介绍。
AVL树的旋转和插入
DragonBark的博客
01-16 359
包含了AVL树的单旋转和双旋转的算法，以及AVL树的递归插入和非递归插入算法。单旋转也叫“一”字形旋转，又可分为左-左型旋转和右-右型旋转；双旋转也叫“之”字形旋转，又可分为左-右型旋转和右-左型旋转。 #includeiostream> #includestack> using namespace std; class AVLNode{ public: int element;
图解平衡二叉树的四种旋转
hywo的博客
12-18 2294
这周写到平衡二叉树的题，在写旋转代码的时候写的有点晕，于是动笔画了个草图，总算是把四种旋转搞明白了。为了强化记忆，我用ppt做了四种旋转的图示，也希望看了这篇博客的各位能有所收获。四张图分别是LL旋转，RR旋转，LR旋转和RL旋转。（顺便吐槽一句，CSDN的markdown真难用，经常找不到光标，写的时候图片的的注解也没显示出来，不知道发出来会怎样） ...
AVL树平衡调整与应用解析
weixin_42357849的博客
06-25 613
一、 AVL树的概念。 二、AVL树的操作。 三、AVL树的模拟实现。 四、AVL树的应用及解析。
详细图解----AVL树的插入和旋转
昂的博客
04-22 454
文章目录AVL树的插入和旋转AVLTree是什么？AVLTree构造AVLTreeInsertAVL旋转左旋右旋双旋维护平衡因子 AVL树的插入和旋转 AVLTree是什么？ AVLTree叫平衡二叉搜索树，不同于普通的二叉搜索树，重点在于平衡， 它具有：他是一棵空树或该树非叶子节点的节点的左右子树的高度差的绝对值不超过1，所以会有个平衡因子进行维护，平衡因子的范围是(-1、0、1)。 这里有二叉搜索树的基础会明白的更好，没有了解的建议先去了解。 AVLTree 构造AVLTree public class
数据结构与算法（十三）平衡二叉树之AVL树
Chiclaim
06-19 1641
本文主要包括以下内容： 平衡二叉树的概念 AVL树 插入操作保持AVL树的平衡 删除操作保持AVL树的平衡 平衡二叉树的概念 为什么需要平衡二叉树？ 通过前面的 二分搜索树(Binary Search Tree)和 BinarySearchTree的时间复杂度分析 的介绍我们知道，二分搜索树的性能跟树的高度(h)有关系 ： h 为二分搜索树的高度，那么高度 h 和二分搜索树节...
AVL平衡树--(插入)
qq_43205670的博客
08-21 320
为什么要引入AVL平衡树二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当 于在顺序表中搜索元素，效率低下。 avl树的定义: 当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之 差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。 一棵AVL树或者是空树，或者是具有以下性质的二叉搜索树： (1)它的左右...
AVL—C语言实现四种平衡处理
Azad221103的博客
09-29 966
平衡二叉树（ALV） 平衡二叉树 (Balanced Binary Tree 或Height-Balanced Tree)又称AVL树。 它的左子树和右子树都是平衡二叉树，且左子树和右子树的深度之差的绝对值不超过1。AVL树是根据它的发明者G.M. Adelson-Velsky和E.M. Landis命名的。 平衡因子 BF（Balance Factor）：该节点的左子树的深度减去它的右子树的深度...
AVL树实现：插入、删除、查找与平衡操作
1. **插入**：当向AVL树中插入一个新节点时，可能破坏树的平衡。因此，插入操作后需要通过旋转来恢复平衡。插入可能引发单旋转（左旋或右旋）或双旋转（左右旋或右左旋）。插入操作通常包括以下步骤：找到插入位置、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值