平衡树以及AVL树

　　平衡树是计算机科学中的一类数据结构。平衡树是计算机科学中的一类改进的二叉查找树。一般的二叉查找树的查询复杂度是跟目标结点到树根的距离（即深度）有关，因此当结点的深度普遍较大时，查询的均摊复杂度会上升，为了更高效的查询，平衡树应运而生了。

　　在这里，平衡指所有叶子的深度趋于平衡，更广义的是指在树上所有可能查找的均摊复杂度偏低。

　　几乎所有平衡树的操作都基于树操作，通过旋转操作可以使得树趋于平衡。对一棵查找树（search tree）进行查询/新增/删除等动作, 所花的时间与树的高度h 成比例, 并不与树的容量 n 成比例。如果可以让树维持矮矮胖胖的好身材, 也就是让h维持在O(lg n)左右, 完成上述工作就很省时间。能够一直维持好身材, 不因新增删除而长歪的搜寻树, 叫做balanced search tree（平衡树）。旋转Rotate —— 不破坏左小右大特性的小手术平衡树有很多种, 其中有几类树维持平衡的方法, 都是靠整形小手术。

　　各种平衡树：AVL树，经典平衡树，所有操作的最坏复杂度是O(lgN)的。

　　　　　　　　Treap，利用随机堆的期望深度来优化树的深度，达到较优的期望复杂度。

　　　　　　　　伸展树、红黑树，节点大小平衡树。2-3树、AA树。

AVL树：

　　AVL树是一棵自平衡的二叉搜索树，在AVL树中任何节点的两个子树的高度最大差别为一，所以它也被称为高度平衡树。查找、插入和删除在平均和最坏情况下都是O(lgN)

为什么需要AVL树：

　　大多数二叉查找操作（搜索、最大、最小、插入、删除...)会花费O(h)，h是二叉搜索树的高度。对于不平衡的二叉查找树，这些操作的时间复杂度为O(n)。如果我们保证在每一次插入和删除之后树的高度为O(lgN)，那么我们就能保证对于所有的操作都有O(lgN)的上界。AVL树的高度总是O(logN)，n是树中节点的数量。

2. 旋转

如果在AVL树中进行插入或删除节点后，可能导致AVL树失去平衡。这种失去平衡的可以概括为4种姿态：LL(左左)，LR(左右)，RR(右右)和RL(右左)。下面给出它们的示意图：

上图中的4棵树都是"失去平衡的AVL树"，从左往右的情况依次是：LL、LR、RL、RR。除了上面的情况之外，还有其它的失去平衡的AVL树，如下图：

上面的两张图都是为了便于理解，而列举的关于"失去平衡的AVL树"的例子。总的来说，AVL树失去平衡时的情况一定是LL、LR、RL、RR这4种之一，它们都由各自的定义：

(1) LL：LeftLeft，也称为"左左"。插入或删除一个节点后，根节点的左子树的左子树还有非空子节点，导致"根的左子树的高度"比"根的右子树的高度"大2，导致AVL树失去了平衡。
例如，在上面LL情况中，由于"根节点(8)的左子树(4)的左子树(2)还有非空子节点"，而"根节点(8)的右子树(12)没有子节点"；导致"根节点(8)的左子树(4)高度"比"根节点(8)的右子树(12)"高2。

(2) LR：LeftRight，也称为"左右"。插入或删除一个节点后，根节点的左子树的右子树还有非空子节点，导致"根的左子树的高度"比"根的右子树的高度"大2，导致AVL树失去了平衡。
例如，在上面LR情况中，由于"根节点(8)的左子树(4)的左子树(6)还有非空子节点"，而"根节点(8)的右子树(12)没有子节点"；导致"根节点(8)的左子树(4)高度"比"根节点(8)的右子树(12)"高2。

(3) RL：RightLeft，称为"右左"。插入或删除一个节点后，根节点的右子树的左子树还有非空子节点，导致"根的右子树的高度"比"根的左子树的高度"大2，导致AVL树失去了平衡。
例如，在上面RL情况中，由于"根节点(8)的右子树(12)的左子树(10)还有非空子节点"，而"根节点(8)的左子树(4)没有子节点"；导致"根节点(8)的右子树(12)高度"比"根节点(8)的左子树(4)"高2。

(4) RR：RightRight，称为"右右"。插入或删除一个节点后，根节点的右子树的右子树还有非空子节点，导致"根的右子树的高度"比"根的左子树的高度"大2，导致AVL树失去了平衡。
例如，在上面RR情况中，由于"根节点(8)的右子树(12)的右子树(14)还有非空子节点"，而"根节点(8)的左子树(4)没有子节点"；导致"根节点(8)的右子树(12)高度"比"根节点(8)的左子树(4)"高2。

前面说过，如果在AVL树中进行插入或删除节点后，可能导致AVL树失去平衡。AVL失去平衡之后，可以通过旋转使其恢复平衡，下面分别介绍"LL(左左)，LR(左右)，RR(右右)和RL(右左)"这4种情况对应的旋转方法。

2.1 LL的旋转

LL失去平衡的情况，可以通过一次旋转让AVL树恢复平衡。如下图：

图中左边是旋转之前的树，右边是旋转之后的树。从中可以发现，旋转之后的树又变成了AVL树，而且该旋转只需要一次即可完成。
对于LL旋转，你可以这样理解为：LL旋转是围绕"失去平衡的AVL根节点"进行的，也就是节点k2；而且由于是LL情况，即左左情况，就用手抓着"左孩子，即k1"使劲摇。将k1变成根节点，k2变成k1的右子树，"k1的右子树"变成"k2的左子树"。

LL的旋转代码

1 template<typename T>
2 void AVLTree<T>::RotateWithLeftChild(AVLTreeNode* &z) {
3     AVLTreeNode* y = z->left;
4     z->left = y->right;
5     y->right = z;
6     z->height = max(GetHeight(z->left), GetHeight(z->right)) + 1;
7     y->right = max(GetHeight(y->left), z->height)) + 1;
8     z = y;
9 }

2.2 RR的旋转

理解了LL之后，RR就相当容易理解了。RR是与LL对称的情况！RR恢复平衡的旋转方法如下：

图中左边是旋转之前的树，右边是旋转之后的树。RR旋转也只需要一次即可完成。

RR的旋转代码

1 template<typename T>
2 void AVLTree<T>::RotateWithRightChild(AVLTreeNode* &z) {
3     AVLTreeNode* y = z->right;
4     z->right = y->left;
5     y->left = z;
6     z->height = max(GetHeight(z->left), GetHeight(z->right)) + 1;
7     y->right = max(GetHeight(y->right), z->height)) + 1;
8     z = y;
9 }

2.3 LR的旋转

LR失去平衡的情况，需要经过两次旋转才能让AVL树恢复平衡。如下图：

第一次旋转是围绕"k1"进行的"RR旋转"，第二次是围绕"k3"进行的"LL旋转"。

LR的旋转代码

1 template<typename T>
2 void AVLTree<T>::DoubleWithLeftChild(AVLTreeNode* &z) {
3     RotateWithRightChild(z->left);
4     RotateWithLeftChild(z);
5 }

2.4 RL的旋转

RL是与LR的对称情况！RL恢复平衡的旋转方法如下：

第一次旋转是围绕"k3"进行的"LL旋转"，第二次是围绕"k1"进行的"RR旋转"。

RL的旋转代码

1 template<typename T>
2 void AVLTree<T>::DoubleWithRightChild(AVLTreeNode* &z) {
3     RotateWithRightChild(z->right);
4     RotateWithLeftChild(z);
5 }

插入：

　　向AVL树插入，可以透过如同它是未平衡的二叉查找树一样，把给定的值插入树中，接着自底往上向根节点折回，于在插入期间成为不平衡的所有节点上进行旋转来完成。因为折回到根节点的路途上最多有1.44乘log n个节点，而每次AVL旋转都耗费固定的时间，所以插入处理在整体上的耗费为O(log n) 时间。

删除：

　　从AVL树中删除，可以通过把要删除的节点向下旋转成一个叶子节点，接着直接移除这个叶子节点来完成。因为在旋转成叶子节点期间最多有log n个节点被旋转，而每次AVL旋转耗费固定的时间，所以删除处理在整体上耗费O(log n) 时间。

查找

　　可以像普通二叉查找树一样的进行，所以耗费O(log n)时间，因为AVL树总是保持平衡的。不需要特殊的准备，树的结构不会由于查找而改变。

代码：

　　头文件：

 1 #ifndef AVL_TREE_H_
 2 #define AVL_TREE_H_
 3 
 4 template<typename T>
 5 class AVLTree {
 6  public:
 7      AVLTree():root_(NULL){}
 8      AVLTree(const AVLTree &rhs){} 
 9      AVLTree& operator=(const AVLTree &rhs){}
10      ~AVLTree(){}
11 
12      void Insert(const T& k) {
13          Insert(root_, k);
14      }
15 
16      void Remove(const T& k) {
17          Remove(root_, k);
18      }
19 
20  private:
21      struct AVLTreeNode {
22          T key;
23          int height;
24          AVLTreeNode* left;
25          AVLTreeNode* right;
26 
27          AVLTreeNode(const T& k, AVLTreeNode* l = NULL, AVLTreeNode * r = NULL, int h = 0)
28              : key(k), left(l), right(r), height(h) {}
29      };
30 
31      AVLTreeNode *root_; //根节点
32 
33      int GetHeight(AVLTreeNode* p) const {
34          return p == NULL ? -1 : p->height;
35      }
36 
37      void Insert(AVLTreeNode* &p, const T& k);
38      void Remove(AVLTreeNode* &p, const T& k);
39 
40      void RotateWithLeftChild(AVLTreeNode* &z);
41      void RotateWithRightChild(AVLTreeNode* &z);
42 
43      void DoubleWithLeftChild(AVLTreeNode* &z);
44      void DoubleWithRightChild(AVLTreeNode* &z);
45 
46      AVLTreeNode* FindMin(AVLTreeNode* p) const;
47 };
48 #endif

源文件：

  1 #include "avl_tree.h"
  2 
  3 //LL
  4 template<typename T>
  5 void AVLTree<T>::RotateWithLeftChild(AVLTreeNode* &z) {
  6     AVLTreeNode* y = z->left;
  7     z->left = y->right;
  8     y->right = z;
  9     z->height = max(GetHeight(z->left), GetHeight(z->right)) + 1;
 10     y->right = max(GetHeight(y->left), z->height) + 1;
 11     z = y;
 12 }
 13 
 14 //RR
 15 template<typename T>
 16 void AVLTree<T>::RotateWithRightChild(AVLTreeNode* &z) {
 17     AVLTreeNode* y = z->right;
 18     z->right = y->left;
 19     y->left = z;
 20     z->height = max(GetHeight(z->left), GetHeight(z->right)) + 1;
 21     y->right = max(GetHeight(y->right), z->height) + 1;
 22     z = y;
 23 }
 24 
 25 //LR
 26 template<typename T>
 27 void AVLTree<T>::DoubleWithLeftChild(AVLTreeNode* &z) {
 28     RotateWithRightChild(z->left);
 29     RotateWithLeftChild(z);
 30 }
 31 
 32 //RL
 33 template<typename T>
 34 void AVLTree<T>::DoubleWithRightChild(AVLTreeNode* &z) {
 35     RotateWithRightChild(z->right);
 36     RotateWithLeftChild(z);
 37 }
 38 
 39 template<typename T>
 40 void AVLTree<T>::Insert(AVLTreeNode* &p, const T& k) {
 41     if (p == NULL) {
 42         t = new AVLTreeNode(k);
 43     } else if (k < p->key) { //左子树中插入
 44         Insert(p->left, k);
 45         if (GetHeight(p->left) - GetHeight(p->right) == 2) { //虽然每次都检查，但是只调整最后一次
 46             if (k < p->left->key) { //LL
 47                 RotateWithLeftChild(p);
 48             } else { //LR
 49                 DoubleWithLeftChild(p);
 50             }
 51         }
 52     } else if (k > p->val) {//在右子树中插入
 53         Insert(p->right, k);
 54         if (GetHeight(p->right) - GetHeight(p->left) == 2) {
 55             if (x > p->right->key) {//RR
 56                 RotateWithRightChild(p);
 57             } else { //RL
 58                 DoubleWithRightChild(p);
 59             }
 60         } 
 61     }else 
 62         ; //重复
 63 
 64     p->height = max(GetHeight(p->left), GetHeight(p->right)) + 1;
 65 }
 66 
 67 
 68 template<typename T>
 69 void AVLTree<T>::Remove(AVLTreeNode* &p, const T& k) {
 70     if (p == NULL) return;
 71     if (p->key > k) {
 72         Remove(p->left, k);
 73         if (GetHeight(p->right) - GetHeight(p->left) == 2) {
 74             if (p->right->right != NULL) {
 75                 RotateWithRightChild(p);
 76             } else {
 77                 DoubleWithRightChild(p);
 78             }
 79         } 
 80     }else if (p->key < k) {
 81         Remove(p->right, k);
 82         if (GetHeight(p->left) - GetHeight(p->right) == 2) {
 83             if (p->left->left != NULL) {
 84                 RotateWithLeftChild(p);
 85             } else {
 86                 DoubleWithLeftChild(p);
 87             }
 88         }
 89     } else if (p->left != NULL && p->right != NULL) {
 90         p->key = FindMin(p->right)->key; //用右子树最小节点键值代替要删除节点的键值，与二叉搜索树类似
 91         Remove(p->right, p->key);
 92         if (GetHeight(p->left) - GetHeight(p->right) == 2) {
 93             if (p->left->left != NULL) {
 94                 RotateWithLeftChild(p);
 95             } else {
 96                 DoubleWithLeftChild(p);
 97             }
 98         }
 99     } else {
100         AVLTreeNode* temp = p;
101         p = p->left ? p->left : p->right;
102         delete temp; 
103     }
104 
105     if (p != NULL) {
106         p->height = max(GetHeight(p->left), GetHeight(p->right)) + 1;
107     }
108 }
109 
110 
111 template<typename T>
112 typename AVLTree<T>::AVLTreeNode* AVLTree<T>::FindMin(AVLTreeNode* p) const {
113     AVLTreeNode* t = p;
114     while (t != NULL && t->left != NULL) {
115         t = t->left;
116     }
117 
118     return t;
119 }