平衡树

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

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

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

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

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

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

 本篇博客主要描述AVL树

 AVL树：

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

为什么需要AVL树：

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

旋转

如果在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。

（1）LL的旋转

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

 

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

(2)RR的旋转

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

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

(3） LR的旋转

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

 

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

（4）RL的旋转

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

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

 

插入：

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

 

 删除：

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

 查找

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

头文件：AVLTree.h
  1 #pragma once
template<class K,class V>
struct AVLTreeNode
{
   AVLTreeNode<K, V>* _left;
   AVLTreeNode<K, V>* _right;
   AVLTreeNode<K, V>* _parent;
   K _key;
   V _value;
   int _bf;
   AVLTreeNode(const K&key,const V&value)
    :_key(key), _value(value), _bf(0), _left(NULL), _right(NULL), _parent(NULL)
   {}
};

 

template<class K,class V> 

class AVLTree 

{ 

   typedef AVLTreeNode<K, V> Node;

public:  

  AVLTree() :_root(NULL)  

  {}

  bool Insert(const K&key, const V&value)  

 {   

　　if (_root == NULL)  

　　 {    

　　　　_root = new Node(key, value);   

　　　　 return true;   

　　}   

　　Node* parent = NULL;   

　　Node* cur = _root;   while (cur)  

　　 {   

　　　　 if (cur->_key > key)    

　　　　{     

　　　　　　parent = cur;     

　　　　　　cur = cur->_left;   

　　　　 }    

　　　　else if (cur->_key < key)    

　　　　{    

　　　　　　 parent = cur;    

　　　　　　 cur = cur->_right;    

　　　　}    

　　　　else    

　　　　{     

　　　　　　return false;   

　　　　 }  

   }

  cur = new Node(key, value);
  if (parent->_key < key)
  {
  　　 parent->_right = cur;
  　　 cur->_parent = parent;
  }
  else
  {
  　　 parent->_left = cur;
  　　 cur->_parent = parent;
  }
  bool isRotate = false;
  while (parent)
  {
　　   if (parent->_left == cur)
   　　{
   　　　　 parent->_bf--;
   　　}
  　　 else
  　　 {
  　　　　  parent->_bf++;
   　　}
  　　 if (parent->_bf == 0)
   　　{
    　　　　break;
  　　 }
   　　else if (parent->_bf == 1 || parent->_bf == -1)
 　　  {
   　　　　 cur = parent;//回溯继续调整平衡因子
   　　　　 parent = cur->_parent;
  　　 }
  　　 else
  　　 {
   　　　　 isRotate = true;
   　　　　 if (parent->_bf == 2)
   　　　　 {
     　　　　　　if (cur->_bf == 1)
    　　　　　　 {
   　　　　　　　　   _RotateL(parent);
   　　　　　　  }
   　　　　　　  else
    　　　　　　 {
   　　　　　　　　   _RotateRL(parent);
    　　　　　　 }
   　　　　 }
   　　　　 else
    　　　　{
    　　　　　　 if (cur->_bf == -1)
    　　　　　　 {
     　　　　　　　　 _RotateR(parent);
    　　　　　　 }
    　　　　　　 else
   　　　　　　  {
    　　　　　　　　  _RotateLR(parent);
    　　　　　　 }
    　　　　}
  　　　　  break;
   　　}
  }

 if (isRotate)
  {
   　　Node* ppNode = parent->_parent;
  　　 if (ppNode == NULL)
  　　 {
  　　　　  _root = parent;
   　　}
   　　else
   　　{
  　　　　  if (ppNode->_key < parent->_key)
   　　　　 {
   　　　　　　  ppNode->_right = parent;
   　　　　 }
  　　　　  else
   　　　　 {
    　　　　　　 ppNode->_left = parent;
   　　　　 }
   　　}
  　　 return true;
   }
}

bool IsBalance() 

 {   

　　　　return _IsBalance(_root);  

} 

 int Height()  

{   

　　　　return _Height(_root);  

}

 void Inorder()  

{   

　　　　return _Inorder(_root);  

}

protected:
 void _RotateL(Node*& parent)
 {
 　　 Node* subR = parent->_right;
 　　 Node* subRL = subR->_left;
  　　parent->_right = subRL;
 　　 if (subRL)
  　　{
 　　　　  subRL->_parent = parent;
　　  }
  　　subR->_left = parent;
 　　 subR->_parent = parent->_parent;
  　　parent->_parent = subR;
  　　parent->_bf = subR->_bf = 0;
  　　parent = subR;
 }

void _RotateR(Node*& parent)
 {
  　　Node* subL = parent->_left;
  　　Node* subLR = subL->_right;
  　　parent->_left = subLR;
  　　if (subLR)
  　　{
  　　　　 subLR->_parent = parent;
 　　 }
 　　 subL->_right = parent;
 　　 subL->_parent = parent->_parent;
  　　parent->_parent = subL;
 　　 parent->_bf = subL->_bf = 0;
 　　 parent = subL;
 } 

 
 void _RotateLR(Node*& parent)
 {
  　　Node* subL = parent->_left;
 　　 Node* subLR = subL->_right;
  　　subL->_right = subLR->_left;
  　　if (subLR->_left)
 　　 {
  　　　　 subLR->_left->_parent = subL;
  　　}
 　　 subLR->_left = subL;
 　　 subLR->_parent = subL->_parent;
 　　 subL->_parent = subLR;
 　　 if (subLR->_bf == 0 || subLR->_bf == -1)
 　　 {
  　　　　 subL->_bf = 0;
  　　}
  　　else
  　　{
  　　　　 subL->_bf = -1;
 　　 }

　　 parent->_left = subLR->_right;

 　   if (subLR->_right)  

 　　{    

　　　　subLR->_right->_parent = parent;   

　　}   

　　subLR->_right = parent;   

　　subLR->_parent = parent->_parent;   

　　parent->_parent = subLR;  

 　　if (subLR->_bf == 0 || subLR->_bf ==1 )   

　　{    

　　　　parent->_bf = 0;  

 　　}  

 　　else   

　　{    

　　　　parent->_bf = 1;   

　　}   

　　subLR->_bf = 0;   

　　parent = subLR;  

}

void _RotateRL(Node*& parent)
 {
 　　 Node* subR = parent->_right;
　　  Node* subRL = subR->_left;
  　　subR->_left = subRL->_right;
 　　 if (subRL->_right)
  　　{
  　　　　 subRL->_right->_parent = subR;
  　　}
  　　subRL->_right = subR;
  　　subRL->_parent = subR->_parent; 
  　　subR->_parent = subRL;
  　　if (subRL->_bf == 0 || subRL->_bf == 1)
  　　{
  　　　　 subR->_bf = 0;
  　　}
 　　 else
  　　{
  　　　　 subR->_bf = 1;
 　　 }
 　　 parent->_right = subRL->_left;
 　　 if (subRL->_left)
  　　{
   　　　　subRL->_left->_parent = parent;
  　　}
  　　subRL->_left = parent;
  　　subRL->_parent= parent->_parent;
 　　 parent->_parent = subRL;
 　　 if (subRL->_bf == 0 || subRL->_bf == -1)
  　　{
 　　　　  parent->_bf = 0;
 　　 }
 　　 else
  　　{
  　　　　 parent->_bf = -1;
 　　 }
  　　subRL->_bf = 0;
  　　parent = subRL;
 }

int _Height(Node* root)
 {
  　　if (root == NULL)
  　　　　 return 0;
  　　int left = _Height(root->_left) + 1;
 　　 int right = _Height(root->_right) + 1;
  　　return left > right ? left : right;
 }

bool _IsBalance(Node* root)
 {
  　　if (root == NULL)
 　　 {
 　　　　  return true;
 　　 }
 　　 int left = _Height(root->_left);
 　　 int right = _Height(root->_right);
 　　 int bf = abs(right - left);
 　　 if (bf > 1)
 　　 {
 　　　　  return false;
 　　 }
　　  if (bf != abs(root->_bf))
 　　 {
  　　　　 cout << root->_key << "平衡因子有问题";
  　　　　 return false;
 　　 }
  　　return _IsBalance(root->_left) && _IsBalance(root->_right);
 }

void _Inorder(Node* root)
 {
  　　if (root == NULL)
  　　{
  　　　　 return;
  　　}
  　　else
 　　 {
 　　　　  _Inorder(root->_left);
   　　　　cout << root->_key << " ";
   　　　　_Inorder(root->_right);
  　　}　　
 }

protected:   

　　Node* _root; 

}; 

void Test() 

{　　 

　　 AVLTree<int, int> t;  

　　int a[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };  

　　for (size_t i = 0; i < sizeof(a) / sizeof(int); ++i)  

　　{   

　　　　t.Insert(a[i], i);  

　　}  

　　t.Inorder();  

　　cout << endl;  

　　cout << t.IsBalance()<< endl;

}