AVL树详解

最新推荐文章于 2024-09-29 12:32:27 发布
最新推荐文章于 2024-09-29 12:32:27 发布
阅读量637 收藏
点赞数
分类专栏： 基本数据结构

      AVL树是最先发明的自平衡二叉查找树。在AVL树中任何节点的两个儿子子树的高度最大差别为一，所以它也被称为高度平衡树。

查找、插入和删除在平均和最坏情况下都是O（log n）。增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。

       对二叉树的平衡调整过程，主要包含四种旋转操作：LL，LR，RR，RL 。

 LR由当前节点左儿子的一次RR旋转和当前节点的一次LL旋转构成。同理， RR由当前节点右儿子的一次LL旋转和当前节点的一次RR旋转构成。

如图：

AVL树的 插入 和删除均要调整重新构成平衡树。

具体实现代码即注释如下：Head.h    fun.c    AvlTree.c

Head.h   

[cpp]  view plain  copy
  1. #ifndef HEAD_H_  
  2. #define HEAD_H_  
  3.   
  4. #include <stdio.h>  
  5. #include <stdlib.h>  
  6.   
  7. typedef int ElementType;  
  8. typedef struct AvlNode              // AVL树的节点  
  9. {  
  10.     ElementType data;  
  11.     struct AvlNode *left;           // 左孩子  
  12.     struct AvlNode *right;          // 右孩子  
  13.     int Height;  
  14. }*Position,*AvlTree;  
  15.   
  16. AvlTree MakeEmpty(AvlTree T);  
  17. Position Find(ElementType x,AvlTree T);  
  18. Position FindMin(AvlTree T);  
  19. Position FindMax(AvlTree T);  
  20. AvlTree  Insert(ElementType x,AvlTree T);  
  21. AvlTree  Delete(ElementType x,AvlTree T);  
  22. ElementType Retrieve(Position P);  
  23. void Display(AvlTree T);  
  24.   
  25. #endif /* HEAD_H_ */  


 fun.c   

[cpp]  view plain  copy
  1. #include"Head.h"  
  2. /* 
  3.  *   初始化AVL树 
  4.  */  
  5. AvlTree MakeEmpty(AvlTree T)  
  6. {  
  7.     if( T != NULL)  
  8.     {  
  9.         MakeEmpty(T->left);  
  10.         MakeEmpty(T->right);  
  11.         free(T);  
  12.     }  
  13.     return NULL;  
  14. }  
  15.   
  16. /* 
  17.  * 查找 可以像普通二叉查找树一样的进行，所以耗费O(log n)时间，因为AVL树总是保持平衡的。 
  18.  * 不需要特殊的准备，树的结构不会由于查找而改变。（这是与伸展树查找相对立的，它会因为查找而变更树结构。） 
  19.  */  
  20. Position Find(ElementType x,AvlTree T)  
  21. {  
  22.     if(T == NULL)  
  23.         return NULL;  
  24.     if(x < T->data)  
  25.         return Find(x,T->left);  
  26.     else if(x > T->data)  
  27.         return Find(x,T->right);  
  28.     else  
  29.         return  T;  
  30. }  
  31. /* 
  32.  *   FindMax，FindMin 查找最大和最小值， 
  33.  */  
  34. Position FindMin(AvlTree T)  
  35. {  
  36.     if(T == NULL)  
  37.         return NULL;  
  38.     if( T->left == NULL)  
  39.         return T;  
  40.     else  
  41.         return FindMin(T->left);  
  42. }  
  43. Position FindMax(AvlTree T)  
  44. {  
  45.     if(T != NULL)  
  46.         while(T->right != NULL)  
  47.             T=T->right;  
  48.     return T;  
  49. }  
  50. /* 
  51.  *  返回节点的高度 
  52.  */  
  53. static int Height(Position P)  
  54. {  
  55.     if(P == NULL)  
  56.         return -1;  
  57.     else  
  58.         return P->Height;  
  59. }  
  60. static int Max(int h1,int h2)  
  61. {  
  62.     return h1 > h2 ?h1:h2;  
  63. }  
  64. /* 
  65.  *  此函数用于k2只有一个左孩子的单旋转， 
  66.  *  在K2和它的左孩子之间旋转， 
  67.  *  更新高度，返回新的根节点 
  68.  */  
  69. static Position SingleRotateWithLeft(Position k2)     // LL旋转  
  70. {  
  71.     Position k1;  
  72.     k1=k2->left;  
  73.     k2->left=k1->right;  
  74.     k1->right=k2;  
  75.     // 因为比较的是左右孩子的高度，所以求父节点的高度要加1  
  76.     k2->Height=Max(Height(k2->left),Height(k2->right)) + 1;  
  77.     k1->Height=Max(Height(k1->left),Height(k2->right)) + 1;  
  78.     return k1;  
  79. }  
  80. /* 
  81.  *  此函数用于k1只有一个右孩子的单旋转， 
  82.  *  在K1和它的右孩子之间旋转， 
  83.  *  更新高度，返回新的根节点 
  84.  */  
  85. static Position SingleRotateWithRight(Position k1)  // RR旋转  
  86. {  
  87.     Position k2;  
  88.     k2=k1->right;  
  89.     k1->right=k2->left;  
  90.     k2->left=k1;  
  91.      /*结点的位置变了, 要更新结点的高度值*/  
  92.     k1->Height=Max(Height(k1->left),Height(k1->right)) + 1;  
  93.     k2->Height=Max(Height(k2->left),Height(k2->right)) + 1;  
  94.     return k2;  
  95. }  
  96. /* 
  97.  * 此函数用于当 如果 k3有一个左孩子，以及 
  98.  * 它的左孩子又有右孩子，执行这个双旋转 
  99.  * 更新高度，返回新的根节点 
  100.  */  
  101. static Position DoubleRotateLeft(Position k3)    // LR旋转  
  102. {  
  103.     //在 k3 的左孩子，执行右侧单旋转  
  104.     k3->left=SingleRotateWithRight(k3->left);  
  105.     // 再对 k3 进行 左侧单旋转  
  106.     return SingleRotateWithLeft(k3);  
  107. }  
  108. /* 
  109.  * 此函数用于当 如果 k4有一个右孩子，以及 
  110.  * 它的右孩子又有左孩子，执行这个双旋转 
  111.  * 更新高度，返回新的根节点 
  112.  */  
  113. static Position DoubleRotateRight(Position k4)    // RL旋转  
  114. {  
  115.     //在 k4 的右孩子，执行左侧单旋转  
  116.     k4->right = SingleRotateWithLeft(k4->right);  
  117.     // 再对 k4 进行 右侧单旋转  
  118.     return SingleRotateWithRight(k4);  
  119. }  
  120. /* 
  121.  *  向AVL树插入可以通过如同它是未平衡的二叉查找树一样把给定的值插入树中， 
  122.  *  接着自底向上向根节点折回，于在插入期间成为不平衡的所有节点上进行旋转来完成。 
  123.  *  因为折回到根节点的路途上最多有1.5乘log n个节点，而每次AVL旋转都耗费恒定的时间， 
  124.  *  插入处理在整体上耗费O(log n) 时间。 
  125.  */  
  126. AvlTree  Insert(ElementType x,AvlTree T)  
  127. {  
  128.     //如果T不存在，则创建一个节点树  
  129.     if(T == NULL)  
  130.     {  
  131.         T = (AvlTree)malloc(sizeof(struct AvlNode));  
  132.         {  
  133.             T->data = x;  
  134.             T->Height = 0;  
  135.             T->left = T->right = NULL;  
  136.         }  
  137.     }  
  138.     // 如果要插入的元素小于当前元素  
  139.     else if(x < T->data)  
  140.     {  
  141.         //递归插入  
  142.         T->left=Insert(x,T->left);  
  143.         //插入元素之后，若 T 的左子树比右子树高度 之差是 2，即不满足 AVL平衡特性，需要调整  
  144.         if(Height(T->left) - Height(T->right) == 2)  
  145.         {  
  146.             //把x插入到了T->left的左侧，只需 左侧单旋转  
  147.             if(x < T->left->data)  
  148.                 T = SingleRotateWithLeft(T);       // LL旋转  
  149.             else  
  150.                 // x 插入到了T->left的右侧，需要左侧双旋转  
  151.                 T =  DoubleRotateLeft(T);          // LR旋转  
  152.         }  
  153.     }  
  154.     // 如果要插入的元素大于当前元素  
  155.     else if(x > T->data)  
  156.     {  
  157.         T->right=Insert(x,T->right);  
  158.         if(Height(T->right) - Height(T->left) == 2)  
  159.         {  
  160.             if(x > T->right->data)  
  161.                 T = SingleRotateWithRight(T);     //RR 旋转  
  162.             else  
  163.                 T =  DoubleRotateRight(T);        //RL旋转  
  164.         }  
  165.     }  
  166.     T->Height=Max(Height(T->left),Height(T->right)) + 1;  
  167.     return T;  
  168. }  
  169. /* 
  170.  *  对单个节点进行的AVL调整 
  171.  */  
  172. AvlTree Rotate(AvlTree T)  
  173. {  
  174.   
  175.     if(Height(T->left) - Height(T->right) == 2)  
  176.     {  
  177.         if(Height(T->left->left) >= Height(T->left->right))  
  178.             T = SingleRotateWithLeft(T);  // LL旋转  
  179.         else  
  180.             T =  DoubleRotateLeft(T);     // LR旋转  
  181.     }  
  182.     if(Height(T->right) - Height(T->left) == 2)  
  183.     {  
  184.         if(Height(T->right->right) >= Height(T->right->left))  
  185.             T = SingleRotateWithRight(T);  // RR旋转  
  186.         else  
  187.             T =  DoubleRotateRight(T);     // RL旋转  
  188.     }  
  189.     return T;  
  190. }  
  191. /* 
  192.  * 首先定位要删除的节点，然后用该节点的右孩子的最左孩子替换该节点， 
  193.  * 并重新调整以该节点为根的子树为AVL树，具体调整方法跟插入数据类似 
  194.  * 删除处理在整体上耗费O(log n) 时间。 
  195.  */  
  196. AvlTree  Delete(ElementType x,AvlTree T)  
  197. {  
  198.     if(T == NULL)  
  199.         return NULL;  
  200.     if(T->data == x)           // 要删除的 x 等于当前节点元素  
  201.     {  
  202.         if(T->right == NULL )  // 若所要删除的节点 T 的右孩子为空,则直接删除  
  203.         {  
  204.             AvlTree tmp = T;  
  205.             T = T->left;  
  206.             free(tmp);  
  207.         }  
  208.         else                 /* 否则找到 T->right 的最左儿子代替 T */  
  209.         {  
  210.             AvlTree tmp = T->right;  
  211.             while(tmp->left)  
  212.                 tmp=tmp->left;  
  213.             T->data = tmp->data;  
  214.             /* 对于替代后的T 即其字节点进行调整*/  
  215.             T->right = Delete(T->data,T->right);  
  216.             T->Height = Max(Height(T->left),Height(T->right))+1;  
  217.         }  
  218.         return T;  
  219.     }  
  220.     else if(x > T->data)                       // 要删除的 x 大于当前节点元素，在T的右子树中查找删除  
  221.     {  
  222.         T->right=Delete(x,T->right);  
  223.     }  
  224.     else                                       // 要删除的 x 小于当前节点元素，在T的左子树中查找删除  
  225.     {  
  226.         T->left=Delete(x,T->left);  
  227.     }  
  228.     /* 
  229.      *   当删除元素后调整平衡 
  230.      */  
  231.     T->Height=Max(Height(T->left),Height(T->right)) + 1;  
  232.     if(T->left != NULL)  
  233.         T->left = Rotate(T->left);  
  234.     if(T->right != NULL)  
  235.         T->right = Rotate(T->right);  
  236.     if(T)  
  237.         T=Rotate(T);  
  238.     return T;  
  239. }  
  240. /* 
  241.  * 返回当前位置的元素 
  242.  */  
  243. ElementType Retrieve(Position P)  
  244. {  
  245.     return P->data;  
  246. }  
  247. /* 
  248.  * 遍历输出 
  249.  */  
  250. void Display(AvlTree T)  
  251. {  
  252.     static int n=0;  
  253.     if(NULL != T)  
  254.     {  
  255.         Display(T->left);  
  256.         printf("[%d] ndata=%d \n",++n,T->data);  
  257.         Display(T->right);  
  258.     }  
  259. }  
ljlstart
关注
专栏目录
基于双向堆栈的avl树双向迭代算法
05-23
### 基于双向堆栈的AVL树双向迭代算法详解 #### 一、引言与背景 在现代计算机科学中，数据结构的设计对于优化算法性能至关重要。平衡二叉搜索树，尤其是AVL树，因其良好的查找性能和有序的数据存储方式而被广泛...
c++函数不明确_C/C++学习笔记：算法知识之平衡树学习笔记，收藏一波吧
weixin_39722070的博客
12-14 388
平衡树存储：size就是节点的个数。value是节点代表的权值。权值相同的两个节点被视为一个，num记录折叠数量。rand是随机数，用来维护平衡树。son就是两个儿子。平衡树size更新：实际操作中，各个变量的值都是不断更新的，size也不例外。函数体：一个节点包括的节点个数用脚也能想到：左儿子size与右儿子size的和，加上这个节点折叠数量。完整的平衡树size更新代码：平衡树插入：学习完上面...
AVL树(平衡性调整)
xiaolu567的博客
06-18 1211
0）先找到key所在的节点 1）如果该节点没有左孩子、没有右孩子，直接删除即可 2）如果该节点有左孩子、没有右孩子，直接用左孩子顶替该节点 3）如果该节点没有左孩子、有右孩子，直接用右孩子顶替该节点 4）如果该节点有左孩子、有右孩子，用该节点后继节点顶替该节点: 后继节点,离X最近,且比X大的(右树上的最左节点)左旋，右旋是对头节点说的 对哪个节点实行左旋还是右旋对谁进行右旋,谁就倒向右方对谁进行左旋,谁就倒向左方 左旋:指明头结点,该头结点往左倒,头结点的右树上去,右树的左孩子变成头结点的右孩子 右旋
数据结构之AVL树（万字详解）
最新发布
都市隸人的博客
09-29 1240
本文介绍了数据结构中的AVL树，给出了C++的代码实现
AVL树
08-14 402
AVL树是最先发明的自平衡二叉查找树。在AVL树中任何节点的两个儿子子树的高度最大差别为一，所以它也被称为高度平衡树。 查找、插入和删除在平均和最坏情况下都是O（log n）。增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。        对二叉树的平衡调整过程，主要包含四种旋转操作：LL，LR，RR，RL 。  LR由当前节点左儿子的一次RR旋转和当前节点的一次LL旋转
数据结构 树 平衡二叉树（AVL树）
潘超博客
02-08 5096
AVL树是最先发明的自平衡二叉查找树。在AVL树中任何节点的两个子树的高度最大差别为1，所以它也被称为高度平衡树。增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。
平衡二叉搜索树：AVL树的实现与分析 以及 统一重平衡算法 （C++）
amoscykl的博客
08-11 1482
平衡二叉搜索树 既然二叉搜索树的性能主要取决于高度,故在节点数目固定的前提下,应尽可能地降低高度。 相应地,应尽可能地使兄弟子树的高度彼此接近,即全树尽可能地平衡。   等价变换 等价二叉搜索树：若两棵二叉搜索树的中序遍历序列相同,则称它们彼此等价;反之亦然。   旋转调整 最基本的修复手段，通过围绕特定节点的旋转，实现等价前提下的局部拓扑调整。 zig和zag：    ...
AVL树的C++实现
05-01
### AVL树的C++实现详解 #### 概述 本文档详细介绍了一个完整的AVL树C++实现案例。AVL树是一种自平衡二叉搜索树，它由Georgy Adelson-Velsky和Evgenii Landis在1962年提出。AVL树的特点在于任何节点的两个子树的...
基于C++ AVL树的航空客运订票系统【100012693】
06-12
《基于C++ AVL树的航空客运订票系统详解》 航空客运订票系统是现代航空公司运营中的关键组成部分，它能够高效地处理航班信息、预订和退票等业务。本项目以C++编程语言为基础，利用AVL树这一自平衡二叉搜索树的数据...
AVL树的删除
qq_39208237的博客
07-05 5509
引言 AVL树的定义及性质及其重要的插入方法，我已在AVL树的插入一文中详细阐述过了，其中重要的旋转也已进行详细描述。 本文就不再赘述了，直接使用，要是不清楚的小伙伴，还请移步AVL树的插入再回头复习一下下。 AVL树的删除 AVL树的删除步骤如下： 寻找删除目标（存不存在，定位出目标） 判断删除目标的类型，使用转换的思路，将其转化为删除叶子 将删除目标与AVL树链接断开，调整平衡，完成删除 寻找删除目标 寻找删除目标的思路很简单，因AVL树也属于BST，因此寻找目标的做法与BST的删除思路基本一致。
avl删除根节点图解_一文读懂平衡搜索树（AVL树）
weixin_42521949的博客
01-18 497
一、概念AVL树是由GM Adelson - Velsky 和 EM Landis 于1962年发明的。为了纪念其发明者，这树结构被命名为 AVL。AVL树可以定义为高度平衡二叉搜索树，其中每个结点与平衡因子相关联，该平衡因子通过从其左子树的子树中减去其右子树的高度来计算。如果每个结点的平衡因子在 -1 到 1 之间，则称树是平衡的，否则，树将是不平衡的并且需要平衡。平衡系数(K)= 高度(左(K...
【C++】-- AVL树详解
局部变量和全局变量
08-31 2502
一棵AVL树或者是空树，或者是具有以下性质的二叉搜索树： (1)它的左右子树都是AVL树 (2)左右子树高度之差(简称平衡因子=右子树高度-左子树高度)的绝对值不超过1(-1/0/1)
AVL树（动图详解）
热门推荐
2021dragon的博客
12-02 2万+
AVL树（C++实现）
数据结构——AVL树详解
rab1211764820的博客
03-28 3108
AVL树的模拟实现 AVL树的插入、旋转、删除、查找 AVL树的验证 AVL树的平衡因子
【C++ 高阶数据结构】AVL树详解
Hou_lang_LJ的博客
05-13 1409
①🐧AVL树的概念； ②🐧AVL树的插入和旋转；③🐧AVL树的应用常见和性能分析；
【高阶数据结构】AVL树（动图详解）
qq_42996461的博客
01-04 2043
但行好事，莫问前程
AVL树详解：平衡二叉树的关键与操作优化
平衡二叉树，又称AVL树，是一种自平衡的二叉搜索树，它的核心在于维护树的平衡性，确保对树中任意节点的查找、插入和删除操作的时间复杂度保持在最优化状态。以下是关于AVL树的详细介绍： 1. **基本概念**: - **...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值