AVL Tree 的实现

最新推荐文章于 2023-05-26 10:49:48 发布
最新推荐文章于 2023-05-26 10:49:48 发布
阅读量470 收藏
点赞数
分类专栏： 计算机基础 文章标签： AVL

http://blog.csdn.net/zk_sima/article/details/6268127


首先 AVL 树是平衡二叉搜索树，所以首先 必须满足搜索树，即l_child值<parent值<=r_child值。这个在前面已经实现了。插入和删除不停的递归就可以。

其次 AVL 树是平衡二叉树，他的平衡条件是左右子树的深度之差小于2.而关键问题在怎么计算深度之差。

一般的方法都是通过平衡度来衡量的。而平衡度怎么得到呢，一般是通过左右子树的深度差得到。其实别人怎么得到平衡度我也没搞明白，不过在这里我是参考了一中思路，就是在每个节点中 包含它自己的高度，而没有直接包含平衡度。

节点的结构：

[cpp]  view plain  copy
  1. template<typename T>  
  2. struct node  
  3. {  
  4.     typedef typename node*  PVOID;  
  5.     PVOID                   l_child;//指向左子树  
  6.     PVOID                   r_child;//右子树指针  
  7.     T                       value;//节点值  
  8. private:  
  9.     int                     height;//节点高度  
  10. public:  
  11.     int getHeight()//得到该节点的高度  
  12.     {  
  13.         if(NULL==this)  
  14.             return 0;  
  15.         else  
  16.             return this->height;  
  17.     }  
  18.     void setHeight()//设置节点的高度  
  19.     {  
  20.         if(NULL==this)  
  21.             return ;  
  22.         int lh,rh;  
  23.         lh=this->l_child->getHeight();  
  24.         rh=this->r_child->getHeight();  
  25.         this->height=lh>rh?(lh+1):(rh+1);  
  26.         return ;  
  27.     }  
  28.     bool ifBalance()//判断该节点是否破坏平衡条件  
  29.     {  
  30.         int flag=this->l_child->getHeight()-this->r_child->getHeight();  
  31.         return flag<2&&flag>-2;  
  32.     }  
  33.     node(T key):l_child(0),r_child(0),value(key),height(1){}  
  34. };  
 

其实AVL 的算法很简单，AVL算法的示意图和神马的前人都给你画出来了，而实现这些算法，主要就在内存分配上，和指针的处理上。

而这里面 最主要的就是 高度的处理上面。

AVL的基本算法：

[cpp]  view plain  copy
  1. void ll_rotation(PNODE& pNode)//左左  
  2.     {  
  3.         PNODE tempNode=pNode->l_child->r_child;  
  4.         pNode->l_child->r_child=pNode;  
  5.         pNode=pNode->l_child;  
  6.         pNode->r_child->l_child=tempNode;  
  7.         pNode->r_child->setHeight();  
  8.         pNode->setHeight();  
  9.     }     
  10.     void lr_rotation(PNODE& pNode)//左右  
  11.     {  
  12.         PNODE tempNode=pNode->l_child->r_child->l_child;  
  13.         pNode->l_child->r_child->l_child=pNode->l_child;  
  14.         pNode->l_child=pNode->l_child->r_child;  
  15.         pNode->l_child->l_child->r_child=tempNode;  
  16.         pNode->l_child->l_child->setHeight();  
  17.         pNode->l_child->setHeight();  
  18.         ll_rotation(pNode);  
  19.     }  
  20.     void rl_rotation(PNODE& pNode)//右左  
  21.     {  
  22.         PNODE tempNode=pNode->r_child->l_child->r_child;  
  23.         pNode->r_child->l_child->r_child=pNode->r_child;  
  24.         pNode->r_child=pNode->r_child->l_child;  
  25.         pNode->r_child->r_child->l_child=tempNode;  
  26.         pNode->r_child->r_child->setHeight();  
  27.         pNode->r_child->setHeight();  
  28.         rr_rotation(pNode);  
  29.     }  
  30.     void rr_rotation(PNODE& pNode)//右右  
  31.     {  
  32.         PNODE tempNode=pNode->r_child->l_child;  
  33.         pNode->r_child->l_child=pNode;  
  34.         pNode=pNode->r_child;  
  35.         pNode->l_child->r_child=tempNode;  
  36.         pNode->l_child->setHeight();  
  37.         pNode->setHeight();  
  38.     }  
 

怎么让AVL树恢复平衡：

[cpp]  view plain  copy
  1. void rebalance(PNODE& pNode)//恢复树的平衡  
  2.     {  
  3.         if(pNode->l_child->getHeight()>pNode->r_child->getHeight())  
  4.         {  
  5.             if(pNode->l_child->l_child->getHeight()>pNode->l_child->r_child->getHeight())  
  6.                 return ll_rotation(pNode);  
  7.             else  
  8.                 return lr_rotation(pNode);  
  9.         }  
  10.         else  
  11.         {  
  12.             if(pNode->r_child->l_child->getHeight()>pNode->r_child->r_child->getHeight())  
  13.                 return rl_rotation(pNode);  
  14.             else  
  15.                 return rr_rotation(pNode);  
  16.         }  
  17.     }  
 

具体代码：

[cpp]  view plain  copy
  1. template<typename T>  
  2. struct node  
  3. {  
  4.     typedef typename node*  PVOID;  
  5.     PVOID                   l_child;//指向左子树  
  6.     PVOID                   r_child;//右子树指针  
  7.     T                       value;//节点值  
  8. private:  
  9.     int                     height;//节点高度  
  10. public:  
  11.     int getHeight()//得到该节点的高度  
  12.     {  
  13.         if(NULL==this)  
  14.             return 0;  
  15.         else  
  16.             return this->height;  
  17.     }  
  18.     void setHeight()//设置节点的高度  
  19.     {  
  20.         if(NULL==this)  
  21.             return ;  
  22.         int lh,rh;  
  23.         lh=this->l_child->getHeight();  
  24.         rh=this->r_child->getHeight();  
  25.         this->height=lh>rh?(lh+1):(rh+1);  
  26.         return ;  
  27.     }  
  28.     bool ifBalance()//判断该节点是否破坏平衡条件  
  29.     {  
  30.         int flag=this->l_child->getHeight()-this->r_child->getHeight();  
  31.         return flag<2&&flag>-2;  
  32.     }  
  33.     node(T key):l_child(0),r_child(0),value(key),height(1){}  
  34. };  
  35. template<class T>  
  36. class AVLTree  
  37. {  
  38. public:  
  39.     typedef typename node<T>*   PNODE;  
  40. private:  
  41.     PNODE root;//跟节点，对于一颗搜索二叉树来说只需要保存跟节点 就可以遍历整棵树  
  42. private://这些函数负责 内存管理  
  43.     PNODE createNode(T  value)//分配内存 ，并构造  
  44.     {  
  45.         PNODE pNode=(PNODE)malloc(sizeof(node<T>));//首先分配内存  
  46.         new(pNode) node<T>(value);//对这段内存进行构造  
  47.         return pNode;  
  48.     }  
  49.     void deallocNode(PNODE& pNode)//释放空间  
  50.     {  
  51.         free(pNode);  
  52.         pNode=0;  
  53.     }  
  54. private:  
  55.     void ll_rotation(PNODE& pNode)//左左  
  56.     {  
  57.         PNODE tempNode=pNode->l_child->r_child;  
  58.         pNode->l_child->r_child=pNode;  
  59.         pNode=pNode->l_child;  
  60.         pNode->r_child->l_child=tempNode;  
  61.         pNode->r_child->setHeight();  
  62.         pNode->setHeight();  
  63.     }     
  64.     void lr_rotation(PNODE& pNode)//左右  
  65.     {  
  66.         PNODE tempNode=pNode->l_child->r_child->l_child;  
  67.         pNode->l_child->r_child->l_child=pNode->l_child;  
  68.         pNode->l_child=pNode->l_child->r_child;  
  69.         pNode->l_child->l_child->r_child=tempNode;  
  70.         pNode->l_child->l_child->setHeight();  
  71.         pNode->l_child->setHeight();  
  72.         ll_rotation(pNode);  
  73.     }  
  74.     void rl_rotation(PNODE& pNode)//右左  
  75.     {  
  76.         PNODE tempNode=pNode->r_child->l_child->r_child;  
  77.         pNode->r_child->l_child->r_child=pNode->r_child;  
  78.         pNode->r_child=pNode->r_child->l_child;  
  79.         pNode->r_child->r_child->l_child=tempNode;  
  80.         pNode->r_child->r_child->setHeight();  
  81.         pNode->r_child->setHeight();  
  82.         rr_rotation(pNode);  
  83.     }  
  84.     void rr_rotation(PNODE& pNode)//右右  
  85.     {  
  86.         PNODE tempNode=pNode->r_child->l_child;  
  87.         pNode->r_child->l_child=pNode;  
  88.         pNode=pNode->r_child;  
  89.         pNode->l_child->r_child=tempNode;  
  90.         pNode->l_child->setHeight();  
  91.         pNode->setHeight();  
  92.     }  
  93.     void rebalance(PNODE& pNode)//恢复树的平衡  
  94.     {  
  95.         if(pNode->l_child->getHeight()>pNode->r_child->getHeight())  
  96.         {  
  97.             if(pNode->l_child->l_child->getHeight()>pNode->l_child->r_child->getHeight())  
  98.                 return ll_rotation(pNode);  
  99.             else  
  100.                 return lr_rotation(pNode);  
  101.         }  
  102.         else  
  103.         {  
  104.             if(pNode->r_child->l_child->getHeight()>pNode->r_child->r_child->getHeight())  
  105.                 return rl_rotation(pNode);  
  106.             else  
  107.                 return rr_rotation(pNode);  
  108.         }  
  109.     }  
  110.     void insert(PNODE &pParent,PNODE pNode)//插入节点  
  111.     {  
  112.         if(0==pParent)  
  113.         {  
  114.             pParent=pNode;  
  115.             return ;  
  116.         }  
  117.         if(pNode->value>=pParent->value)  
  118.             insert(pParent->r_child,pNode);  
  119.         else if(pNode->value <pParent->value)  
  120.             insert(pParent->l_child,pNode);  
  121.         pParent->setHeight();  
  122.         if(pParent->ifBalance())  
  123.             return ;  
  124.         else  
  125.             rebalance(pParent);  
  126.     }  
  127.     void remove(PNODE& pParent,T value)//删除某个节点  
  128.     {  
  129.         if(0==pParent)  
  130.             return ;  
  131.         if(value>pParent->value)  
  132.             remove(pParent->r_child,value);  
  133.         else if(value<pParent->value)  
  134.             remove(pParent->l_child,value);  
  135.         else  
  136.         {  
  137.             if(0!=pParent->l_child&&0!=pParent->r_child)  
  138.             {  
  139.                 PNODE p=pParent->r_child;  
  140.                 while(p->l_child)  
  141.                     p=p->l_child;  
  142.                 pParent->value=p->value;  
  143.                 p->value=value;  
  144.                 remove(pParent->r_child,value);  
  145.             }  
  146.             else   
  147.             {  
  148.                 if(0!=pParent->l_child&&0==pParent->r_child)  
  149.                 {  
  150.                     PNODE tempNode=pParent;  
  151.                     pParent=pParent->l_child;  
  152.                     return this->deallocNode(tempNode);  
  153.                 }  
  154.                 else   
  155.                 {  
  156.                     if(0!=pParent->r_child&&0==pParent->l_child)  
  157.                     {  
  158.                         PNODE tempNode=pParent;  
  159.                         pParent=pParent->r_child;  
  160.                         return this->deallocNode(tempNode);  
  161.                     }  
  162.                     else if(0==pParent->r_child&&0==pParent->l_child)  
  163.                         return this->deallocNode(pParent);  
  164.                 }  
  165.             }  
  166.         }  
  167.         pParent->setHeight();  
  168.         if(pParent->ifBalance())  
  169.             return ;  
  170.         return rebalance(pParent);  
  171.     }  
  172. public:  
  173.     AVLTree():root(0){}//构造函数  
  174.     void insert(T value)//插入值  
  175.     {  
  176.         PNODE pNode=this->createNode(value);  
  177.         insert(root,pNode);  
  178.     }  
  179.     void remove(T value)//删除值  
  180.     {  
  181.         remove(root,value);  
  182.     }  
  183.     T getMax()//得到最大值  
  184.     {  
  185.         if(0==root)  
  186.             return T(0);  
  187.         T max=root->value;  
  188.         PNODE p=root;  
  189.         while(p)  
  190.         {  
  191.             max=p->value;  
  192.             p=p->r_child;  
  193.         }  
  194.         return max;  
  195.     }  
  196.     T getMin()//得到最小值  
  197.     {  
  198.         if(0==root)  
  199.             return T(0);  
  200.         T min=root->value;  
  201.         PNODE p=root;  
  202.         while(p)  
  203.         {  
  204.             min=p->value;  
  205.             p=p->l_child;  
  206.         }  
  207.         return min;  
  208.     }  
  209. };  
 


ldhshao
关注
专栏目录
数据结构浅析——AVL Tree
clown的博客
01-22 309
数据结构浅析——AVL Tree  今天我对AVL Tree的插入方式进行了研究，废话不多说直接进入正题。  AVL Tree是高度平衡的二叉搜索树，保留了搜索树中序遍历有序的特点，同时在每一个节点中加入了一个平衡因子，保证了树的高度平衡，搜索时的复杂度为O（log n）。  在插入时，每次插入都要更新相关的平衡因子并且检查相关节点的平衡因子是否异常（大于1或者小于-1），当平衡因子
avltree实现
10-16
平衡二叉树实现 平衡二叉树的实质就是保持树“尽量胖，尽量矮
AVL树的简单实现
yaoxiaokui的专栏
10-19 292
http://www.cnblogs.com/heqile/archive/2011/11/28/2265713.html http://www.cnblogs.com/heqile/archive/2011/11/28/2266385.html #include #include #include #include using namespace std; static
高度平衡二叉搜索树（AVLTree）
qq_49613557的博客
11-15 3756
高度平衡搜索二叉树（AVLTree） 目录AVL树的概念AVL树节点的定义AVL树的插入AVL树的旋转右单旋左单旋左右双旋右左双旋 AVL树的概念 二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当于在顺序表中搜索元素，效率低下。因此，两位俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landis在1962年发明了一种解决上述问题的方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，
AVL Tree
seayoung的博客
11-21 772
AVL Tree
AVLtree（平衡二叉树）
weixin_44024891的博客
03-18 1110
      AVLtree是一个 “加了额外平衡条件” 的二叉搜索树， 相对于二叉树搜索树而言， 在设计的时候可以说是节点信息添加了平衡因子（也就是个int变量）这个概念。       我们在设计节点信息类的时候，里面的成员变量有左孩子指针、有孩子指针、存储的值（value）， ...
AVL tree实现源码
06-25
AVL tree的源码实现。该AVL tree为模板容器，可以在其中放入任何东西。被放入的对象需要实现拷贝构造函数与赋值构造函数。该程序能够在linux下面顺利通过编译。平时随意开发，如有不足之处，还请见谅！！！
avltree算法.rar_avl_avl tree
09-21
在"www.pudn.com.txt"和"AVLTree"这两个文件中，可能包含了关于AVL树的更多详细信息，如实现代码、示例或进一步的解释。学习AVL树不仅能够理解其基本概念和操作，还能深入理解数据结构的设计和优化，这对于理解和...
AVLTree实现的源代码
04-12
在给定的代码中，主要展示了AVL树的插入操作的实现。 首先，我们看到`avlInsert`函数用于在AVL树中插入一个新节点。这个函数首先检查树是否为空，如果为空，则直接创建一个新节点作为树的根节点。接着，通过循环...
AVltree_avltree_
09-30
3. `avltree_test.c`：这是一个测试文件，用于验证`avltree.c`中的AVL树实现是否正确。通常，它会包含一些测试用例，通过插入、删除和查找操作来检查AVL树的正确性和性能。 4. `avltree_test`：这个可能是编译后的...
平衡二叉树（AVL Tree）
zjcool2012的博客
06-12 459
平衡二叉树（AVL树）是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。也就是说在符合二叉查找树的条件下，它还满足任何节点的两个子树的高度最大差为1。 下面的两张图片，左边是AVL树，它的任何节点的两个子树的高度差<=1；右边的不是AVL树，其根节点的左子树高度为3，而右子树高度为1； 如果在AVL树中进行插入或删除节点，可能导致AVL树失去平衡，这种失去平衡的二叉树可以概括为四种姿态：LL（左左）、RR（右右）、LR（左右）、RL（右左）。它们的示意图如下：
AVL树
sadzyf的博客
10-15 489
参考文献 https://www.cnblogs.com/skywang12345/p/3576969.html 严蔚敏老师的《数据结构》 特别感谢skywang12345大佬帮助我理解AVL树。 复制了文章中的某些图片和源码实现，若冒犯，请联系本人删除。 特点 是二叉搜索树（BST） AVL树中任何节点的两个子树的高度最大差别为1 源码实现 节点定义 typedef int Type; ...
AVL-Tree
最新发布
gjg244的博客
05-26 196
AVL-Tree是计算机科学中最早被发明的自平衡二叉查找树，在AVL树中，任一节点对应的两棵子树的最大高度差为1，因此它也被称为高度平衡树。：根节点的右节点称为新的根节点，同时，右节点的子节点作为之前根节点的右节点存在。：根节点的左节点作为新的根节点，同时，左节点的子节点作为之前根节点的左节点存在。（在节点左子树的右子树上添加节点），这是通过简单的右旋转无法得到avl树。先围绕根节点左子树根节点左旋转，再围绕左子树根节点右旋转。先围绕根节点右子树根节点右旋转，再围绕左子树根节点左旋转。
AVLTree
qq_49471950的博客
04-11 121
平衡二叉树 二叉查找树的问题 当我们依次添加n个有序键值对的时候，二叉查找树的高度为n，这样就大大降低了查找的效率，因为每次查找还要判断每个结点中一个空的链接，甚至比单链表还要慢，为了解决这个问题，我们希望构造的二叉查找树的高度为~lgN，这就是我们要说的平衡二叉树。 简单介绍 1）平衡二叉树也叫做平衡二叉查找树（Self-balancing binary search tree）又称为AVL树，可以保证查询效率高。 2）具有以下特点：它的左右两个子树的高度差绝对值不超过1，并且两个子树都是平衡二叉树。平衡
Sicily AVL Tree
monkey_rose的博客
12-09 650
Description 给出结点的插入序列，构造AVL Tree。           Input 第一行含一个整数t(0 每个测试样例包含两行；第1行为一个整数n，表示插入的结点数;第2行依照插入顺序给出n个结点的数值（整数），之间用一个空格分隔。 Output 对每个测试样例单独一行输出对应AVL Tree的前序遍历序列，每输出一个结点的数值（包
AVL树实现学生数据管理
6. `list_f(void)`: 列出所有学生数据，可以使用中序遍历（inorder traversal）来实现，依次打印每个学生的姓名和分数。 7. `sort_f(char[], char[])`: 对学生数据进行排序，可能采用了某种排序算法（如快速排序、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值