程序博客网 > 网络登录用户名和密码

平衡二叉树 之 AVL树

来源：互联网 发布：网络登录用户名和密码 编辑：程序博客网 时间：2024/06/04 18:51

AVL树是最先发明的自平衡二叉查找树。AVL树以其发明者前苏联学者 G.M. Adelson-Velsky 和 E.M. Landis 名字而命名，他们在1962年的论文《An algorithm for the organization of information》中发表了它。[参考WiKI]

AVL树中，一个非常重要的概念为平衡因子（Balance factor），对于任意节点 x ，其平衡因子定义为该节点右子树和左子树高度差，即 bf（x）=h（x-right）-h（x-left）。

带有平衡因子1、0或 -1的节点被认为是平衡的。带有平衡因子 -2或2的节点被认为是不平衡的，并需要重新平衡这个树。平衡因子可以直接存储在每个节点中，或从可能存储在节点中的子树高度计算出来。

1. AVL树数据结构

为了方便计算每个节点的平衡因子，对二叉树的数据结构进行修改，增加一个数据单元用于记录以该节点为root的子树高度，重新定义数据结构如下：
[cpp] view plain copy
 print?在CODE上查看代码片派生到我的代码片
  1. struct BinaryTreeNode {  
  2.     keyType key;  
  3.     int height; //记录以该节点为root的树高度  
  4.     BinaryTreeNode* left; // left child  
  5.     BinaryTreeNode* right; // right child  
  6. };  
  7.   
  8. // define AVL node  
  9. typedef BinaryTreeNode avlnode;  
  10.   
  11. // define AVL tree  
  12. typedef BinaryTreeNode avltree;  
  13.   
  14.   
  15. // 比较左右子树高度，取最大的  
  16. int maxh(int ha, int hb) {  
  17.     return ha > hb ? ha : hb;  
  18. }  
  19.   
  20. // 计算树的高度  
  21. int height(avltree* tree) {  
  22.     if (NULL == tree) return 0;   
  23.     return tree->height;  
  24. }  

2. AVL树旋转操作

AVL在插入和删除节点造成不平衡的时候需要对发生不平衡的节点及时调整，调整方法为旋转操作。根据造成不平衡的节点出构型可分为：LL 、RR 、LR 、RL型，对应的操作则为单旋和双旋，下面分析一下各种构型具体操作方法。

下图所示为LL构型，在B节点的左子树上插入节点导致A节点失衡，调整过程为：以B节点为轴心，A节点顺时针旋转至B的右子树，A的右子树又B的右子树代替。通过右旋操作，返回以B为Root的平衡子树。 RR够型和LL够型成对称关系，操作方向相反，此处就省略了。

LL型

下图所示为LR构型，在B节点的右子树上插入新节点导致A节点失衡，调整过程分两个步骤：首先以C为轴心，B绕C逆时针旋转，生成的子树作为A的左子树；这样就变化成了LL型，然后用上图所示的方法调整即可。通过先左旋后右旋，返回以C为Root的平衡子树。RL型和LR型呈对称状，此处也省略。

LR型


下表列出节点够型和选择操作关系。

构型操作对应的函数LL型单旋：

右旋
[cpp] view plain copy
 print?在CODE上查看代码片派生到我的代码片
  1. // single right rotate for LL model  
  2. avlnode* singleRightRotate(avlnode* aNode) {  
  3.     avlnode* bNode = aNode->left;  
  4.     // rebuild relation  
  5.     aNode->left = bNode->right;  
  6.     bNode->right = aNode;  
  7.     // adjust the height  
  8.     aNode->height = maxh(height(aNode->right), height(aNode->left)) + 1;  
  9.     bNode->height = maxh(height(bNode->right), height(bNode->left)) + 1;  
  10.     return bNode;  
  11. }  
RR型单旋：

左旋
[cpp] view plain copy
 print?在CODE上查看代码片派生到我的代码片
  1. // single left rotate for RR model  
  2. avlnode* singleLeftRotate(avlnode* aNode) {  
  3.     avlnode* bNode = aNode->right;  
  4.     // rebuild relation  
  5.     aNode->right = bNode->left;  
  6.     bNode->left = aNode;  
  7.     // adjust height  
  8.     aNode->height = maxh(height(aNode->right), height(aNode->left)) + 1;  
  9.     bNode->height = maxh(height(bNode->right), height(bNode->left)) + 1;  
  10.     return bNode;  
  11. }  
LR型双旋：
先左旋
后右旋
[cpp] view plain copy
 print?在CODE上查看代码片派生到我的代码片
  1. // double rotate for LR model  
  2. // left rotate first and then right rotate  
  3. avlnode* leftRightRotate(avlnode* aNode) {  
  4.     aNode->left = singleLeftRotate(aNode->left);  
  5.     return singleRightRotate(aNode);  
  6. }  
RL型双旋：
先右旋
后左旋
[cpp] view plain copy
 print?在CODE上查看代码片派生到我的代码片
  1. // double rotate for RL model  
  2. // right rotate first and then left rotate  
  3. avlnode* rightLeftRotate(avlnode* aNode) {  
  4.     aNode->right = singleRightRotate(aNode->right);  
  5.     return singleLeftRotate(aNode);  
  6. }  



3. 插入节点

向AVL树中插入节点后，要判断是否引起失衡，如果失衡则需要进一步确定构型，选择合适的基本旋转操作来调整。

[cpp] view plain copy
 print?在CODE上查看代码片派生到我的代码片
  1. // insert a key to AVL tree.  
  2. avlnode* avl_inssert(avltree* &tree, keyType key) {  
  3.     if (NULL == tree) {  
  4.         tree = (avlnode*) malloc(sizeof(avlnode));  
  5.         tree->key = key;  
  6.         tree->height = 1;  
  7.         tree->left = tree->right = NULL;  
  8.     } else if (key > tree->key) { // insert into the right subtree  
  9.         tree->right = avl_inssert(tree->right, key);  
  10.         int balanceFactor = height(tree->right) - height(tree->left);  
  11.         if (balanceFactor == 2) {  
  12.             if (key > tree->right->key) { // RR 型 , 右侧单旋  
  13.                 tree = singleLeftRotate(tree);  
  14.             } else { // RL型 , 右侧双旋  
  15.                 tree = rightLeftRotate(tree);  
  16.             }  
  17.         }  
  18.     } else if (key < tree->key) { // insert into the left subtree  
  19.         tree->left = avl_inssert(tree->left, key);  
  20.         int balanceFactor = height(tree->left) - height(tree->right);  
  21.         if (balanceFactor == 2) {  
  22.             if (key < tree->left->key) { // LL型 , 左侧单旋  
  23.                 tree = singleRightRotate(tree);  
  24.             } else { // LR型 ， 左侧双旋  
  25.                 tree = rightLeftRotate(tree);  
  26.             }  
  27.         }  
  28.     } else { // if the key is already exists, nothing to do....  
  29.     }  
  30.     // 重新计算树的高度  
  31.     tree->height = maxh(height(tree->left), height(tree->right)) + 1;  
  32.   
  33.     return tree;  
  34. }  

4. 删除节点

从AVL树中删除节点分为两个步骤：首先删除节点；然后调整平衡。删除操作对应为插入操作的逆向操作，调整平衡的时候也需要确定被删除节点的分支构型来选择合适的旋转方法。

[cpp] view plain copy
 print?在CODE上查看代码片派生到我的代码片
  1. // delete the given key from AVL tree.  
  2. avlnode* avl_delete(avltree* &tree, keyType key) {  
  3.     if (NULL == tree) {  
  4.         return NULL;  
  5.     }  
  6.     // delete the node with the given key  
  7.     if (key > tree->key) { // key exists in the right subtree  
  8.         tree->right = avl_delete(tree->right, key);  
  9.     } else if (key < tree->key) { // key exists in the left subtree  
  10.         tree->left = avl_delete(tree->left, key);  
  11.     } else {  
  12.         if (NULL != tree->left) { // when left is not NULL  
  13.             // find max node if left tree  
  14.             avlnode* dn = NULL;  
  15.             for (dn = tree->left; NULL != dn->right; dn = dn->right) {  
  16.             }  
  17.             // change the value  
  18.             tree->key = dn->key;  
  19.             // delete the max node  
  20.             tree->left = avl_delete(tree->left, dn->key);  
  21.         } else if (NULL != tree->right) { // when the right tree is not NULL  
  22.             // find the minimal node  
  23.             avlnode* dn = NULL;  
  24.             for (dn = tree->right; NULL != dn->left; dn = dn->left) {  
  25.             }  
  26.             // change the value  
  27.             tree->key = dn->key;  
  28.             // delete the minimal node  
  29.             tree->right = avl_delete(tree->right, dn->key);  
  30.         } else {            // when the node has no child  
  31.             free(tree);  
  32.             // the tree is Empty now, no need to do any operation  
  33.             return NULL;  
  34.         }  
  35.     }  
  36.     // adjust the tree to balance state after deletion  
  37.     if (height(tree->left) - height(tree->right) == 2) { // when the left subtree is too high  
  38.         if (height(tree->left->right) - height(tree->left->left) == 1) { // LR model  
  39.             tree = leftRightRotate(tree);  
  40.         } else { // LL model  
  41.             tree = singleRightRotate(tree);  
  42.         }  
  43.     } else if (height(tree->left) - height(tree->right) == -2) { // when the right subtree is too high  
  44.         if (height(tree->right->left) - height(tree->right->right) == 1) { // RL model  
  45.             tree = rightLeftRotate(tree);  
  46.         } else { // RR model  
  47.             tree = singleLeftRotate(tree);  
  48.         }  
  49.     } else {  
  50.         // the tree is already balanced, nothing to do ...  
  51.     }  
  52.   
  53.     // recalculate the height of the tree.  
  54.     tree->height = maxh(height(tree->right), height(tree->left)) + 1;  
  55.   
  56.     return tree;  
  57. }  

5. 测试

分别对 查找二叉树 和  AVL树进行下列操作：依次插入 0-15 ；依次删除 0, 3，6，10，15  

测试结果如下：

测试查找二叉树 ：依次插入 0 -15 构建如下：前序 : 0  1  2  3  4  5  6  7  8  9  10  11  12  13  14  中序 : 0  1  2  3  4  5  6  7  8  9  10  11  12  13  14  依次删除 0, 3，6，10，15 之后：前序 : 1  2  4  5  7  8  9  11  12  13  14  中序 : 1  2  4  5  7  8  9  11  12  13  14  
测试 AVL 平衡二叉树 ：依次插入 0 -15 构建如下：前序 : 7  3  1  0  2  5  4  6  11  9  8  10  13  12  14  中序 : 0  1  2  3  4  5  6  7  8  9  10  11  12  13  14  依次删除 0, 3，6，10，15 之后：前序 : 7  2  1  5  4  11  9  8  13  12  14  中序 : 1  2  4  5  7  8  9  11  12  13  14

对比来看， 查找二叉树退化为线性，而AVL树则形态匀称.

0 0
网络登录用户名和密码 网络登录用户名和密码
原创粉丝点击
热门IT博客
windows播放器没有声音windows播放器没有声音
矢量gif制作软件矢量gif制作软件
软件退税备案
会员违规淘宝怎么处罚
mac双用粉底液
装修工程报价软件
歌词创作软件
万网能注册到好域名吗
js获取时间差
tumblr mac客户端下载
淘宝逆战永久武器
软件 研究方法
淘宝淘客助手插件
宁海知豆电动汽车招聘
bat程序员都看什么书
java 泛型 成员变量
mysql 统计连续天数
元胞数组的访问
sql server 2000 msde
mysql 秒转换为时分秒
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 传骐 广传奇汽车 为什么都不建议买广汽传祺ga8 传统文化 传统节日 红色传统 传统锅包肉 传统玩具 传统手抄报 传统英文 传统 传统的英文 优良传统 传统图案 传统美德 传统钓 传统英语 中国传统 中华传统 传统与创新 传统的英语 传统的 传统教育 传统运动会 传统艺术 传统产业 传统中医 中国的传统 中国传统节日 张家界传统戏剧 中国传统文化 传统文化手抄报 苗族的传统节日 传统文化作文 正宗传统红烧肉做法 中国传统文化有哪些 中国传统节日有哪些 少数民族传统节日 弘扬传统文化 中华传统文化 中华民族传统美德

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里