AVL树-查找-插入

1. 简述

    AVL树要求每个结点的左右子树高度相差绝对值小于2。查找、插入和删除在平均和最坏情况下都是O（log n）。

2. 查找

    查找比较简单与普通二叉搜索树的查找是一样的。从根开始，要么向左，要么向右，要么找到，如果到达了NULL，则表示查找失败。   

AVLNode *  avl_search(AVLNode *  node,  int  value) {
   while (node  !=  NULL) {
     if (value  <  node -> value)  //  向左 
      node  =  node -> left;
     else   if (value  >  node -> value)  //  向右 
      node  =  node -> right;
     else   //  找到 
       return  node;
  }
   return  NULL;  //  失败 
}

3. 插入

    插入元素可能导致从根到被插入结点的这条路径的平衡会被打破，如果平衡被打破，高度差超过了1，那么需要旋转。基本流程是首先在合适位置插入结点，然后从插入位置沿着路径倒回去，逐个更新平衡度并且对需要旋转的进行合适的选择。
    旋转分四类：设当前结点为A，插入结点为C
    RR型：A的平衡度为-2，C->value > A->value并且C->value > A->right->value。C在A的右孩子的右子树中，需要一次左旋。
    LL型：A的平衡度为2，C->value < A->value并且C->value < A->left->value。C在A的左孩子的左子树中，需要一次右旋。
    RL型：A的平衡度为-2，C->value > A->value并且C->value<A->left->value。C在A的右孩子的左子树中，需要先进行一次右旋，转化为LL型，再进行一次左旋。
　 LR型：A的平衡度为2，Ｃ->value  < A->value并且C->value>A->right->value。C在A的左孩子的右子树中，需要先进行一次左旋，转化为RR型，再进行一次右旋。
    注：LL，LR这些符号，在百度百科和维基百科中的含义不一致，本文与维基百科是一致的，因为感觉维基百科的解释直观理解更清楚。LL表明C与A的位置关系是左左，LR表明C与A的位置关系时左右。
    对于双旋以前一直记不住，其实很好记，对于RR型需要左旋；对于LL型需要右旋；对于RL型，先解决后面的L，右旋，然后解决R，左旋；对于LR型，先解决后面的R，左旋，然后解决前面的L右旋。
    关于代码，网上很多都是递归的代码，我看了几篇博客文章，没发现简洁且正确的，旋转一般都没问题，但是一般旋转之后，所谓的A结点就不再是这个子树的根了，因此需要让A的父结点指向新的根，有的代码实现没有考虑到这个情况，有的代码实现虽然考虑到了这个情况，但是没有在递归的过程中，没有注意如果A的结点为空的情况，即A是根节点，根节点变了，而根是没有父结点的，此时要更新根指针。
    这里我尝试给出一个非递归的实现，不保证正确，如有错误，希望指出。   

#include < iostream >
#include < stack >
using   namespace  std;

struct  AVLNode {
  AVLNode *  left;
  AVLNode *  right;
   int  height;
   int  value;
}; 

//  更新某个结点的高度，对于多个结点分别更新，需要从叶子向根的方向调用
//  否则可能出现更新错误 
void  update_height(AVLNode  * node) {
  assert(NULL  !=  node);
   int  lheight  =  node -> left == NULL  ?   0 :(node -> left -> height + 1 );
   int  rheight  =  node -> right == NULL  ?   0 :(node -> right -> height + 1 );
  node -> height  =  lheight  >  rheight  ?  lheight : rheight;
}

//  左左情况右旋，返回子树旋转后的根 
AVLNode *  LL(AVLNode *  A) { 
  assert(NULL  !=  A);
  AVLNode *  B  =  A -> left;
  A -> left  =  B -> right;
  B -> right  =  A;
  update_height(A);
  update_height(B);
   return  B;
}
//  右右情况左旋，返回子树旋转后的根 
AVLNode *  RR(AVLNode *  A) {
  assert(NULL  !=  A);
  AVLNode *  B  =  A -> right;
  A -> right  =  B -> left;
  B -> left  =  A;
  update_height(A);
  update_height(B);
   return  B;
}
//  左右情况，先左旋后右旋，返回子树旋转后的根
AVLNode *  LR(AVLNode *  A) {
  assert(NULL  !=  A);
  A -> left  =  RR(A -> left);  //  左旋并更新A的父结点指针
   return  LL(A);  
}
//  右左情况，先右旋后左旋，返回子树旋转后的根
AVLNode *  RL(AVLNode *  A) {
  assert(NULL  !=  A);
  A -> right  =  LL(A -> right);
   return  RR(A);
}

bool  avl_insert(AVLNode *&  root,  int  value) {
  stack < AVLNode *>  store;
  AVLNode *  node, * A, * B, * C,  * tmp;
  tmp  =  root;
   //  寻找插入位置，并且保证路径 
   while (tmp  !=  NULL) {
    store.push(tmp);
     if (value  <  tmp -> value) 
      tmp  =  tmp -> left;
     else   if (value  >  tmp -> value)
      tmp  =  tmp -> right;
     else   //  插入识别 
       return   false ;
  }
   //  建立新结点
  node  =   new  AVLNode;
  node -> left  =  node -> right  =  NULL; 
  node -> height  =   0 ;
  node -> value  =  value;
   //  插入新结点 
   if (store.empty()) {  //  根结点为空 
    root  =  node;
     return   true ;
  }
   else  {
    tmp  =  store.top();
    node -> value < tmp -> value  ?  (tmp -> left = node):(tmp -> right = node);
  }
   //  对打破平衡的结点进行旋转，并且更新所有需要改变高度的结点高度 
  C  =  node;
   while ( ! store.empty()) {
    A  =  store.top();
    store.pop();
     int  lheight  =  A -> left == NULL  ?   0 :(A -> left -> height + 1 );
     int  rheight  =  A -> right == NULL  ?   0 :(A -> right -> height + 1 );
     switch (lheight - rheight) {
       case   - 1 :
       case   1 :
       case   0 :
        A -> height  =  lheight  >  rheight  ?  lheight : rheight;
         break ;
       case   2 :  //  L
         //  旋转 
         if (C -> value  <  A -> left -> value)  //  LL
          A  =  LL(A);        
         else   //  LR
          A  =  LR(A);
         //  更新父结点 
         if (store.empty())
          root  =  A;
         else  
          A -> value  <  store.top() -> value  ?  store.top() -> left  =  A : store.top() -> right  =  A;
         break ;
       case   - 2 :  //  R
         //  旋转 
         if (C -> value  >  A -> right -> value)  //  RR
          A  =  RR(A);        
         else   //  RL
          A  =  RL(A);        
         //  更新父结点
         if (store.empty())
          root  =  A;
         else  
          A -> value  <  store.top() -> value  ?  store.top() -> left  =  A : store.top() -> right  =  A;
         break ;
    }
  }
}

void  print_father_child(AVLNode *  root) {
  stack < AVLNode *>  store;
  store.push(root);
   while ( ! store.empty()) {
    root  =  store.top();
    store.pop();    
    cout  <<  root -> value  <<   "  :  " ;
     if (root -> left == NULL)
      cout  <<   " NULL " ;
     else  
      cout  <<  root -> left -> value;
    cout  <<   "  ,  " ;
     if (root -> right == NULL)
      cout  <<   " NULL " ;
     else  
      cout  <<  root -> right -> value;
    cout  <<  endl;
     if (root -> right)
      store.push(root -> right);
     if (root -> left)
      store.push(root -> left);
  }
}

int  main() {
  AVLNode *  root  =  NULL;
   for ( int  i = 0 ; i < 10 ; i ++ )
    avl_insert(root, i);
  print_father_child(root);
  system( " PAUSE " );
   return   0 ;
}

   输出结果如下： 
  

4. 删除

    写插入写了半天，删除懒得写了，就先这样的，思路是按照二叉排序树删除的方法先删除该结点，并且用栈记录从该结点到根的路径上所有结点，然后从下往上依次更新高度、检查是否平衡，对于需要旋转的情况进行旋转。
    注意更新父结点的指向以及没有父结点的情况，还有就是对于既有左孩子又有右孩子的结点，普通二叉排序树会将待删除结点交换到左子树的最右结点（或者右子树的最左结点），因此入栈记录路径时，需要分情况对待。
    代码基本上大致是普通二叉排序树的删除代码，然后加上更新检查路径的代码。

5. 参考

    维基百科_AVL树    http://zh.wikipedia.org/wiki/AVL%E6%A0%91
    百度百科_AVL树    http://baike.baidu.com/view/671745.html?tp=6_01