平衡二叉树理解

《平衡二叉树理解》
 
分类:
算法
转载:
http://www.cppblog.com/cxiaojia/archive/2012/08/20/187776.html
平衡二叉树(Balanced Binary Tree)是二叉查找树的一个进化体,也是第一个引入平衡概念的二叉树。1962年,G.M. Adelson-Velsky 和 E.M. Landis发明了这棵树,所以它又叫AVL树。平衡二叉树要求对于每一个节点来说,它的左右子树的高度之差不能超过1,如果插入或者删除一个节点使得高度之差大于1,就要进行节点之间的旋转,将二叉树重新维持在一个平衡状态。这个方案很好的解决了二叉查找树退化成链表的问题,把插入,查找,删除的时间复杂度最好情况和最坏情况都维持在O(logN)。但是频繁旋转会使插入和删除牺牲掉O(logN)左右的时间,不过相对二叉查找树来说,时间上稳定了很多

《平衡二叉树理解》

平衡二叉树实现的大部分过程和二叉查找树是一样的(学平衡二叉树之前一定要会二叉查找树),区别就在于插入和删除之后要写一个旋转算法去维持平衡,维持平衡需要借助一个节点高度的属性。我参考了机械工业出版社的《数据结构与算法分析-C语言描述》写了一个C++版的代码。这本书的AVLTree讲的很好,不过没有很完整的去描述。我会一步一步的讲解如何写平衡二叉树,重点是平衡二叉树的核心部分,也就是旋转算法。

第一步:节点信息

  相对于二叉查找树的节点来说,我们需要用一个属性二叉树的高度,目的是维护插入和删除过程中的旋转算法。

代码如下:

[html] 
view plain
 copy

  1. //AVL树节点信息  
  2. template<class T>  
  3. class TreeNode  
  4. {  
  5.     public:  
  6.         TreeNode():lson(NULL),rson(NULL),freq(1),hgt(0){}  
  7.         T data;//值  
  8.         int hgt;//以此节点为根的树的高度  
  9.         unsigned int freq;//频率  
  10.         TreeNode* lson;//指向左儿子的地址  
  11.         TreeNode* rson;//指向右儿子的地址  
  12. };  

第二步:平衡二叉树类的声明

  声明中的旋转函数将在后边的步骤中详解。

代码如下:

[html] 
view plain
 copy

  1. //AVL树类的属性和方法声明  
  2. template<class T>  
  3. class AVLTree  
  4. {  
  5.     private:  
  6.         TreeNode<T>* root;//根节点  
  7.         void insertpri(TreeNode<T>* &node,T x);//插入  
  8.         TreeNode<T>* findpri(TreeNode<T>* node,T x);//查找  
  9.         void insubtree(TreeNode<T>* node);//中序遍历  
  10.         void Deletepri(TreeNode<T>* &node,T x);//删除  
  11.         int height(TreeNode<T>* node);//求树的高度  
  12.         void SingRotateLeft(TreeNode<T>* &k2);//左左情况下的旋转  
  13.         void SingRotateRight(TreeNode<T>* &k2);//右右情况下的旋转  
  14.         void DoubleRotateLR(TreeNode<T>* &k3);//左右情况下的旋转  
  15.         void DoubleRotateRL(TreeNode<T>* &k3);//右左情况下的旋转  
  16.         int Max(int cmpa,int cmpb);//求最大值  
  17.   
  18.     public:  
  19.         AVLTree():root(NULL){}  
  20.         void insert(T x);//插入接口  
  21.         TreeNode<T>* find(T x);//查找接口  
  22.         void Delete(T x);//删除接口  
  23.         void traversal();//遍历接口  
  24.   
  25. };  

第三步:两个辅助方法

  旋转算法需要借助于两个功能的辅助,一个是求树的高度,一个是求两个高度的最大值。这里规定,一棵空树的高度为-1,只有一个根节点的树的高度为0,以后每多一层高度加1。为了解决指针NULL这种情况,写了一个求高度的函数,这个函数还是很有必要的。

代码如下:

[html] 
view plain
 copy

  1. //计算以节点为根的树的高度  
  2. template<class T>  
  3. int AVLTree<T>::height(TreeNode<T>* node)  
  4. {  
  5.     if(node!=NULL)  
  6.         return node->hgt;  
  7.     return -1;  
  8. }  
  9. //求最大值  
  10. template<class T>  
  11. int AVLTree<T>::Max(int cmpa,int cmpb)  
  12. {  
  13.     return cmpa>cmpb?cmpa:cmpb;  
  14. }  

第四步:旋转

  对于一个平衡的节点,由于任意节点最多有两个儿子,因此高度不平衡时,此节点的两颗子树的高度差2.容易看出,这种不平衡出现在下面四种情况:

《平衡二叉树理解》

     1、6节点的左子树3节点高度比右子树7节点大2,左子树3节点的左子树1节点高度大于右子树4节点,这种情况成为
左左

  2、6节点的左子树2节点高度比右子树7节点大2,左子树2节点的左子树1节点高度小于右子树4节点,这种情况成为左右

  3、2节点的左子树1节点高度比右子树5节点小2,右子树5节点的左子树3节点高度大于右子树6节点,这种情况成为右左

  4、2节点的左子树1节点高度比右子树4节点小2,右子树4节点的左子树3节点高度小于右子树6节点,这种情况成为右右

  从图2中可以可以看出,1和4两种情况是对称的,这两种情况的旋转算法是一致的,只需要经过一次旋转就可以达到目标,我们称之为单旋转。2和3两种情况也是对称的,这两种情况的旋转算法也是一致的,需要进行两次旋转,我们称之为双旋转。

第五步:单旋转

  单旋转是针对于左左和右右这两种情况的解决方案,这两种情况是对称的,只要解决了左左这种情况,右右就很好办了。图3是左左情况的解决方案,节点k2不满足平衡特性,因为它的左子树k1比右子树Z深2层,而且k1子树中,更深的一层的是k1的左子树X子树,所以属于左左情况。

《平衡二叉树理解》

为使树恢复平衡,我们把k2变成这棵树的根节点,因为k2大于k1,把k2置于k1的右子树上,而原本在k1右子树的Y大于k1,小于k2,就把Y置于k2的左子树上,这样既满足了二叉查找树的性质,又满足了平衡二叉树的性质。

  这样的操作只需要一部分指针改变,结果我们得到另外一颗二叉查找树,它是一棵AVL树,因为X向上一移动了一层,Y还停留在原来的层面上,Z向下移动了一层。整棵树的新高度和之前没有在左子树上插入的高度相同,插入操作使得X高度长高了。因此,由于这颗子树高度没有变化,所以通往根节点的路径就不需要继续旋转了。

代码如下:

[html] 
view plain
 copy

  1. //左左情况下的旋转  
  2. template<class T>  
  3. void AVLTree<T>::SingRotateLeft(TreeNode<T>* &k2)  
  4. {  
  5.     TreeNode<T>* k1;  
  6.     k1=k2>lson;  
  7.     k2->lson=k1>rson;  
  8.     k1->rson=k2;  
  9.   
  10.     k2->hgt=Max(height(k2->lson),height(k2->rson))+1;  
  11.     k1->hgt=Max(height(k1->lson),k2->hgt)+1;  
  12. }  
  13. //右右情况下的旋转  
  14. template<class T>  
  15. void AVLTree<T>::SingRotateRight(TreeNode<T>* &k2)  
  16. {  
  17.     TreeNode<T>* k1;  
  18.     k1=k2>rson;  
  19.     k2->rson=k1>lson;  
  20.     k1->lson=k2;  
  21.   
  22.     k2->hgt=Max(height(k2->lson),height(k2->rson))+1;  
  23.     k1->hgt=Max(height(k1->rson),k2->hgt)+1;  
  24. }  

第六步:双旋转

对于左右和右左这两种情况,单旋转不能使它达到一个平衡状态,要经过两次旋转。双旋转是针对于这两种情况的解决方案,同样的,这样两种情况也是对称的,只要解决了左右这种情况,右左就很好办了。图4是左右情况的解决方案,节点k3不满足平衡特性,因为它的左子树k1比右子树Z深2层,而且k1子树中,更深的一层的是k1的右子树k2子树,所以属于左右情况。

《平衡二叉树理解》

为使树恢复平衡,我们需要进行两步,第一步,把k1作为根,进行一次右右旋转,旋转之后就变成了左左情况,所以第二步再进行一次左左旋转,最后得到了一棵以k2为根的平衡二叉树树。

代码如下:

[html] 
view plain
 copy

  1. //左右情况的旋转  
  2. template<class T>  
  3. void AVLTree<T>::DoubleRotateLR(TreeNode<T>* &k3)  
  4. {  
  5.     SingRotateRight(k3->lson);  
  6.     SingRotateLeft(k3);  
  7. }  
  8. //右左情况的旋转  
  9. template<class T>  
  10. void AVLTree<T>::DoubleRotateRL(TreeNode<T>* &k3)  
  11. {  
  12.     SingRotateLeft(k3->rson);  
  13.     SingRotateRight(k3);  
  14. }  

 第七步:插入

  插入的方法和二叉查找树基本一样,区别是,插入完成后需要从插入的节点开始维护一个到根节点的路径,每经过一个节点都要维持树的平衡。维持树的平衡要根据高度差的特点选择不同的旋转算法。

代码如下:

[html] 
view plain
 copy

  1. /插入  
  2. template<class T>  
  3. void AVLTree<T>::insertpri(TreeNode<T>* &node,T x)  
  4. {  
  5.     if(node==NULL)//如果节点为空,就在此节点处加入x信息  
  6.     {  
  7.         node=new TreeNode<T>();  
  8.         node->data=x;  
  9.         return;  
  10.     }  
  11.     if(node->data>x)//如果x小于节点的值,就继续在节点的左子树中插入x  
  12.     {  
  13.         insertpri(node->lson,x);  
  14.         if(2==height(node->lson)-height(node->rson))  
  15.             if(x<node->lson->data)  
  16.                 SingRotateLeft(node);  
  17.             else  
  18.                 DoubleRotateLR(node);  
  19.     }  
  20.     else if(node->data<x)//如果x大于节点的值,就继续在节点的右子树中插入x  
  21.     {  
  22.         insertpri(node->rson,x);  
  23.         if(2==height(node->rson)-height(node->lson))//如果高度之差为2的话就失去了平衡,需要旋转  
  24.             if(x>node->rson->data)  
  25.                 SingRotateRight(node);  
  26.             else  
  27.                 DoubleRotateRL(node);  
  28.     }  
  29.     else ++(node->freq);//如果相等,就把频率加1  
  30.     node->hgt=Max(height(node->lson),height(node->rson));  
  31. }  
  32. //插入接口  
  33. template<class T>  
  34. void AVLTree<T>::insert(T x)  
  35. {  
  36.     insertpri(root,x);  
  37. }  

第八步:查找

和二叉查找树相比,查找方法没有变法,不过根据存储的特性,AVL树能维持在一个O(logN)的稳定的时间,而二叉查找树则相当不稳定。

代码如下:

[html] 
view plain
 copy

  1. //查找  
  2. template<class T>  
  3. TreeNode<T>* AVLTree<T>::findpri(TreeNode<T>* node,T x)  
  4. {  
  5.     if(node==NULL)//如果节点为空说明没找到,返回NULL  
  6.     {  
  7.         return NULL;  
  8.     }  
  9.     if(node->data>x)//如果x小于节点的值,就继续在节点的左子树中查找x  
  10.     {  
  11.         return findpri(node->lson,x);  
  12.     }  
  13.     else if(node->data<x)//如果x大于节点的值,就继续在节点的左子树中查找x  
  14.     {  
  15.         return findpri(node->rson,x);  
  16.     }  
  17.     else return node;//如果相等,就找到了此节点  
  18. }  
  19. //查找接口  
  20. template<class T>  
  21. TreeNode<T>* AVLTree<T>::find(T x)  
  22. {  
  23.     return findpri(root,x);  
  24. }  

第九步:删除

  删除的方法也和二叉查找树的一致,区别是,删除完成后,需要从删除节点的父亲开始向上维护树的平衡一直到根节点。

代码如下:

[html] 
view plain
 copy

  1. //删除  
  2. template<class T>  
  3. void AVLTree<T>::Deletepri(TreeNode<T>* &node,T x)  
  4. {  
  5.     if(node==NULL) return ;//没有找到值是x的节点  
  6.     if(x < node->data)  
  7.     {  
  8.          Deletepri(node->lson,x);//如果x小于节点的值,就继续在节点的左子树中删除x  
  9.          if(2==height(node->rson)-height(node->lson))  
  10.             if(node->rson->lson!=NULL&&(height(node->rson->lson)>height(node->rson->rson)) )  
  11.                 DoubleRotateRL(node);  
  12.             else  
  13.                 SingRotateRight(node);  
  14.     }  
  15.   
  16.     else if(x > node->data)  
  17.     {  
  18.          Deletepri(node->rson,x);//如果x大于节点的值,就继续在节点的右子树中删除x  
  19.          if(2==height(node->lson)-height(node->rson))  
  20.             if(node->lson->rson!=NULL&& (height(node->lson->rson)>height(node->lson->lson) ))  
  21.                 DoubleRotateLR(node);  
  22.             else  
  23.                 SingRotateLeft(node);  
  24.     }  
  25.   
  26.     else//如果相等,此节点就是要删除的节点  
  27.     {  
  28.         if(node->lson&&node->rson)//此节点有两个儿子  
  29.         {  
  30.             TreeNode<T>temp=node>rson;//temp指向节点的右儿子  
  31.             while(temp->lson!=NULL) temp=temp>lson;//找到右子树中值最小的节点  
  32.             //把右子树中最小节点的值赋值给本节点  
  33.             node->data=temp>data;  
  34.             node->freq=temp>freq;  
  35.             Deletepri(node->rson,temp->data);//删除右子树中最小值的节点  
  36.             if(2==height(node->lson)-height(node->rson))  
  37.             {  
  38.                 if(node->lson->rson!=NULL&& (height(node->lson->rson)>height(node->lson->lson) ))  
  39.                     DoubleRotateLR(node);  
  40.                 else  
  41.                     SingRotateLeft(node);  
  42.             }  
  43.         }  
  44.         else//此节点有1个或0个儿子  
  45.         {  
  46.             TreeNode<T>temp=node;  
  47.             if(node->lson==NULL)//有右儿子或者没有儿子  
  48.             node=node>rson;  
  49.             else if(node->rson==NULL)//有左儿子  
  50.             node=node>lson;  
  51.             delete(temp);  
  52.             temp=NULL;  
  53.         }  
  54.     }  
  55.     if(node==NULL) return;  
  56.     node->hgt=Max(height(node->lson),height(node->rson))+1;  
  57.     return;  
  58. }  
  59. //删除接口  
  60. template<class T>  
  61. void AVLTree<T>::Delete(T x)  
  62. {  
  63.     Deletepri(root,x);  
  64. }  

第十步:中序遍历

代码如下:

[html] 
view plain
 copy

  1. //中序遍历函数  
  2. template<class T>  
  3. void AVLTree<T>::insubtree(TreeNode<T>* node)  
  4. {  
  5.     if(node==NULL) return;  
  6.     insubtree(node->lson);//先遍历左子树  
  7.     cout<<node->data<<” “;//输出根节点  
  8.     insubtree(node->rson);//再遍历右子树  
  9. }  
  10. //中序遍历接口  
  11. template<class T>  
  12. void AVLTree<T>::traversal()  
  13. {  
  14.     insubtree(root);  
  15. }  


第十一步:关于效率

  此数据结构插入、查找和删除的时间复杂度均为O(logN),但是插入和删除需要额外的旋转算法需要的时间,有时旋转过多也会影响效率。

  关于递归和非递归。我用的是递归的方法进行插入,查找和删除,而非递归的方法一般来说要比递归的方法快很多,但是我感觉非递归的方法写出来会比较困难,所以我还是选择了递归的方法。

  还有一种效率的问题是关于高度信息的存储,由于我们需要的仅仅是高度的差,不需要知道这棵树的高度,所以只需要使用两个二进制位就可以表示这个差。这样可以避免平衡因子的重复计算,可以稍微的加快一些速度,不过代码也丧失了相对简明性和清晰度。如果采用递归写法的话,这种微加速就更显得微乎其微了。

 

    原文作者:平衡二叉树
    原文地址: https://blog.csdn.net/shicuicui1234/article/details/78523307
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞