AVL的c++详解——插入

AVL 树是带有平衡条件的二叉查找树，所谓的平衡条件就是每个节点的左子树和右子树的高度最大差别为1。平衡二叉树的实现大部分过程和二叉查找树是一样的，区别在于要时刻保持树的平衡，所以在插入和删除之后要添加一个旋转算法来保持平衡，保持平衡需要借助一个节点高度的属性。

一、AVL 节点

[cpp] view plain copy

 print?

1. class AvlTree;  
2.   
3. class AvlNode  
4. {  
5. public:  
6.     AvlNode(int val) :data(val), leftchild(NULL),  
7.         rightchild(NULL)/*, height(0)*/ {}  
8.     //~AvlNode();  
9.     friend class AvlTree;  
10.   
11. private:  
12.     int data;  
13.     AvlNode *leftchild;  
14.     AvlNode *rightchild;  
15. //  int height;  
16. };  

AVL 节点同二叉查找树节点类似，这里可以额外添加一个节点的高度属性，来判断是否平衡。考虑到后面都需要函数来获取节点的高度以及尽量减少类对象的大小，这里单独通过函数获取高度属性并比较（后面程序）。

二、AVL 树class

[cpp] view plain copy

 print?

1. class AvlTree  
2. {  
3. public:  
4.     AvlTree() :Root(NULL) {}  
5.     ~AvlTree(){  
6.         MakeEmpty(Root);  
7.     }  
8.   
9.     void Insert(int);  
10.     void Insert(AvlNode *&, int);  
11.     void Delete(int);  
12.     void Delete(AvlNode *&, int);  
13.   
14.     AvlNode* findMin(AvlNode *node);  
15.     AvlNode* findMax(AvlNode *node);  
16.     //void Find(AvlNode *&, int);  
17.     void MakeEmpty(AvlNode *&);  
18.     int Height(AvlNode *);  
19.   
20.     void RotationLeftOnce(AvlNode *&);  
21.     void RotationRightOnce(AvlNode *&);  
22.     void RotaionLeftTwice(AvlNode *&);  
23.     void RotaionRightTwice(AvlNode *&);  
24.   
25. private:  
26.     AvlNode *Root;  
27. };  

三、计算节点的高度

节点的高度：该节点到该树叶子节点的最长路径的长。

定义：空二叉树的高度为-1，只有根节点的二叉树的高度为0。

[cpp] view plain copy

 print?

1. //计算节点的高度  
2. int AvlTree::Height(AvlNode *node)  
3. {  
4.     int left, right;  
5.     if (NULL == node)  
6.         return -1;  
7.   
8.     left = Height(node->leftchild);  
9.     right = Height(node->rightchild);  
10.   
11.     return (left > right) ? (left + 1) : (right + 1);  
12. }  

递归：不必纠结于内部实现，明确其功能即可。节点存在儿子，高度累加。

四、节点的插入

这是平衡二叉树的重头戏，分几部分讨论。只有当节点的插入打乱了平衡才需要调整，也就是节点的插入导致某个节点 X 的两棵子树的高度差2，因为插入之前树一定是平衡的（子树高度差最大为1），这种不平衡出现在一下四种情况：

1. 插入点位于 X 的左子节点的左子树——左左；

2. 插入点位于 X 的左子节点的右子树——左右；

3. 插入点位于 X 的右子结点的左子树——右左；

4. 插入点位于 X 的右子结点的右子树——右右；

具体的就不说了，随便参考哪本靠谱点的数据结构书，上面都有详细介绍

由于只有 “插入点至根节点” 路径上的各节点可能改变平衡状态，因此，只要调整其中最深（区分深度和高度）的那个节点，便可以使整棵树重新获得平衡，调整最深的节点就是调整不平衡节点当中距离根节点最长的那个节点。

另外，所有的旋转调整后的最终结果必须遵循二叉查找树的规则。

如上图（来源于《STL源码剖析》）右图中违反AVL tree规则的最深的节点是 18，所以调整之后，节点 22 还是根节点，且其右子树不变，后面我们会验证。

4.1 插入点位于 X 的左子节点的左子树——左左

上面违反AVL-tree平衡条件的是节点18，其不平衡是由于在其左子节点14的左子树插入新结点11所致，插入节点13也是左左，A 所划定的区域都属于左子节点的左子树范围。

左左类型用单旋转就可以调整，代码如下

[cpp] view plain copy

 print?

1. //左左单旋转  
2. void AvlTree::RotationLeftOnce(AvlNode *&k2)  
3. {  
4.     AvlNode *k1;  
5.   
6.     k1 = k2->leftchild;  
7.     k2->leftchild = k1->rightchild;  
8.     k1->rightchild = k2;  
9.     k2 = k1;  
10. }  

指针的引用当做指针的指针来理解

4.2 插入点位于 X 的右子节点的右子树——右右

[cpp] view plain copy

 print?

1. //右右单旋转  
2. void AvlTree::RotationRightOnce(AvlNode *&k2)  
3. {  
4.     AvlNode* k1;  
5.   
6.     k1 = k2->rightchild;  
7.     k2->rightchild = k1->leftchild;  
8.     k1->leftchild = k2;  
9.     k2 = k1;  
10. }  

注意的是调整后需要修改不平衡区域的根节点。

4.3 插入点位于 X 的左子节点的右子树——左右

这种情况和右左少许有些特殊，不能通过单旋转达到平衡状态，先看左右情况，就是插入点15位于是不平衡节点18左子节点14的右子树（B和C都是右子树部分）

上面单次旋转不能调整平衡，需要进行两次旋转，也就是双旋转。关键就在于两次旋转的先后顺序，从上图可知，要保持平衡只能k2，也就是节点16作为新的根节点，由于16节点比较深，需要进行两次旋转，每次旋转之后16节点深度降低一层，也就是单旋转之后要保证节点16成为该旋转区域的根节点。需要清楚的是单次旋转只能将某节点的深度降低一层。首先需要对不平衡节点18的左子树进行旋转，要想将16旋转之后成为其左子树的根节点，只能对其左子树进行右旋转，旋转之后节点16就成为了节点18的左子节点，然后以节点18作为根据点进行左旋转，这样节点16就成为了根节点，所有旋转都是满足二叉查找树规则的。

[cpp] view plain copy

 print?

1. //左右双旋转  
2. void AvlTree::RotaionLeftTwice(AvlNode *&k3)  
3. {  
4.     RotationRightOnce(k3->leftchild);  
5.     RotationLeftOnce(k3);  
6. }  

由上面可知，单旋转就是在满足二叉查找树的基础上，将某节点的深度降低一层，获得平衡。左旋转就是将左子节点降低一层，右旋转就是将右子结点降低一层（深度降低）。

4.4 插入点位于 X 的右子节点的左子树——右左

这种情况和4.3情况类似，上面已经详细介绍过了，这里就不画图分析了。

[cpp] view plain copy

 print?

1. //右左双旋转  
2. void AvlTree::RotaionRightTwice(AvlNode *&k3)  
3. {  
4.     RotationLeftOnce(k3->rightchild);  
5.     RotationRightOnce(k3);  
6. }  

根据4.3的分析，从上面代码就可以直接看出，两次旋转过程，第一次单旋转就是将k3节点的右子结点的左子节点旋转为该区域根节点，也就是成为k3的右子结点，然后以k3为根据点将其右子结点旋转为新的根节点。两次旋转之后，新的根节点就是原根节点k3的右子结点的左子节点。其余节点的变换则基于二叉查找树规则。

有了上面的分析，节点的插入就好办了。与二叉查找树的区别在于需要添加一个旋转的过程。

[cpp] view plain copy

 print?

1. //插入节点  
2. void AvlTree::Insert(int val)  
3. {  
4.     if (NULL == Root)        //空树  
5.         Root = new AvlNode(val);  
6.     else  
7.         Insert(Root, val);  
8. }  
9.   
10. //插入前树本身是平衡的，必须时刻保留二叉查找树的特性  
11. void AvlTree::Insert(AvlNode *&node, int val)  
12. {  
13.     if (NULL == node)                           //为空  
14.         node = new AvlNode(val);  
15.     else if (val > node->data)  
16.     {  
17.         Insert(node->rightchild, val);  
18.         //右子树高度大于左子树  
19.         if (2 == Height(node->rightchild) - Height(node->leftchild))  
20.         {  
21.             if (val > node->rightchild->data)   //右右单旋转  
22.                 RotationRightOnce(node);  
23.             else                                //右左双旋转  
24.                 RotaionRightTwice(node);  
25.         }  
26.     }  
27.     else if (val < node->data)  
28.     {  
29.         Insert(node->leftchild, val);  
30.         //左子树高度大于右子树  
31.         if (2 == Height(node->leftchild) - Height(node->rightchild))  
32.         {  
33.             if (val < node->leftchild->data)    //左左单旋转  
34.                 RotationLeftOnce(node);  
35.             else                                //左右双旋转  
36.                 RotaionLeftTwice(node);  
37.         }  
38.     }  
39. }