AVL树

AVL树称为自平衡二叉查找书。其中任何节点的两个子树的高度最大差别为一。查找、插入和删除在平均和最坏情况下都是O(log  n)。增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。

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

AVL树的基本操作一般同在不平衡的二叉查找树的操作类似，但是要进行预先或随后做一次或多次所谓的"AVL 旋转"。 

假设由于在二叉排序树上插入结点而失去平衡的最小子树根结点的指针为a(即a是离插入点最近，且平衡因子绝对值超过1的祖先结点)，则失去平衡后进行进行的规律可归纳为下列四种情况： 

1. 单向右旋平衡处理RR：由于在*a的左子树根结点的左子树上插入结点，*a的平衡因子由1增至2，致使以*a为根的子树失去平衡，则需进行一次右旋转操作； 
2. 单向左旋平衡处理LL：由于在*a的右子树根结点的右子树上插入结点，*a的平衡因子由-1变为-2，致使以*a为根的子树失去平衡，则需进行一次左旋转操作； 
3. 双向旋转（先左后右）平衡处理LR：由于在*a的左子树根结点的右子树上插入结点，*a的平衡因子由1增至2，致使以*a为根的子树失去平衡，则需进行两次旋转（先左旋后右旋）操作。 
4. 双向旋转（先右后左）平衡处理RL：由于在*a的右子树根结点的左子树上插入结点，*a的平衡因子由-1变为-2，致使以*a为根的子树失去平衡，则需进行两次旋转（先右旋后左旋）操作。 

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

在平衡的的二叉排序树Balanced BST上插入一个新的数据元素e的递归算法可描述如下： 

1. 若BBST为空树，则插入一个数据元素为e的新结点作为BBST的根结点，树的深度增1； 
2. 若e的关键字和BBST的根结点的关键字相等，则不进行； 
3. 若e的关键字小于BBST的根结点的关键字，而且在BBST的左子树中不存在和e有相同关键字的结点，则将e插入在BBST的左子树上，并且当插入之后的左子树深度增加(+1)时，分别就下列不同情况处理之： 
   1. BBST的根结点的平衡因子为-1(右子树的浓度大于左子树的深度，则将根结点的平衡因子更改为0，BBST的深度不变； 
   2. BBST的根结点的平衡因子为0（左、右子树的深度相等）：则将根结点的平衡因子更改为1，BBST的深度增1； 
   3. BBST的根结点的平衡因子为1（左子树的深度大于右子树的深度）：则若BBST的左子树根结点的平衡因子为1：则需进行单向右旋平衡处理，并且在右旋处理之后，将根结点和其右子树根结点的平衡因子更改为0，树的深度不变； 
4. 若e的关键字大于BBST的根结点的关键字，而且在BBST的右子树中不存在和e有相同关键字的结点，则将e插入在BBST的右子树上，并且当插入之后的右子树深度增加(+1)时，分别就不同情况处理之。 

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

查找同在一般BST完全一样的进行，所以耗费 O(log n) 时间，因为AVL树是保持平衡的。不需要特殊的准备，树的结构不会由于查询而改变。

 #include  < stdio.h >
#include  < stdlib.h >
#include  < time .h >

typedef struct AVLTree
{
     int  nData;
    struct AVLTree *  pLeft;
    struct AVLTree *  pRight;
     int  nHeight;
}AVLTree;

int  Max( int  a,  int  b);
int  Height(AVLTree *  pNode);
AVLTree *  Insert( int  nData, AVLTree *  pNode);
AVLTree *  SingleRotateWithLeft(AVLTree *  pNode);
AVLTree *  SingleRotateWithRight(AVLTree *  pNode);
AVLTree *  DoubleRotateWithLeft(AVLTree *  pNode);
AVLTree *  DoubleRotateWithRight(AVLTree *  pNode);
void DeleteTree(AVLTree **  ppRoot);
void PrintTree(AVLTree *  pRoot);

int  main()
{
     int  i;
    AVLTree *  pRoot  =   NULL ;

    srand((unsigned  int ):: time ( NULL ));
    
     for  (i  =   0 ; i  <   100000000 ;  ++ i)
    {
        pRoot  =  Insert(::rand(), pRoot);
    }

     // PrintTree(pRoot);

    DeleteTree( & pRoot);

    return  0 ;
}

int  Max( int  a,  int  b)
{
    return (a  >  b ? a : b);
}

int  Height(AVLTree *  pNode)
{
     if  ( NULL   ==  pNode)
        return  - 1 ;

    return pNode -> nHeight;
}

AVLTree *  Insert( int  nData, AVLTree *  pNode)
{
     if  ( NULL   ==  pNode)
    {
        pNode  =  (AVLTree * )malloc(sizeof(AVLTree));
        pNode -> nData  =  nData;
        pNode -> nHeight  =   0 ;
        pNode -> pLeft  =  pNode -> pRight  =   NULL ;
    }
     else   if  (nData  <  pNode -> nData)           //  插入到左子树中
    {
        pNode -> pLeft  =  Insert(nData, pNode -> pLeft);
         if  (Height(pNode -> pLeft)  -  Height(pNode -> pRight)  ==   2 )     //  AVL树不平衡
        {
             if  (nData  <  pNode -> pLeft -> nData)
            {
                 //  插入到了左子树左边, 做单旋转
                pNode  =  SingleRotateWithLeft(pNode);
            }
             else  
            {
                 //  插入到了左子树右边, 做双旋转
                pNode  =  DoubleRotateWithLeft(pNode);
            }
        }
    }
     else   if  (nData  >  pNode -> nData)           //  插入到右子树中
    {
        pNode -> pRight  =  Insert(nData, pNode -> pRight);
         if  (Height(pNode -> pRight)  -  Height(pNode -> pLeft)  ==   2 )     //  AVL树不平衡
        {
             if  (nData  >  pNode -> pRight -> nData)
            {
                 //  插入到了右子树右边, 做单旋转
                pNode  =  SingleRotateWithRight(pNode);
            }
             else  
            {
                 //  插入到了右子树左边, 做双旋转
                pNode  =  DoubleRotateWithRight(pNode);
            }
        }
    }

    pNode -> nHeight  =  Max(Height(pNode -> pLeft), Height(pNode -> pRight))  +   1 ;

    return pNode;
}

/********************************************************************
      pNode                                pNode -> pLeft 
       /                                               /
pNode -> pLeft                       ==>               pNode
            /                                         /
          pNode -> pLeft -> pRight                   pNode -> pLeft -> pRight
*********************************************************************/
AVLTree *  SingleRotateWithLeft(AVLTree *  pNode)
{
    AVLTree *  pNode1;

    pNode1  =  pNode -> pLeft;
    pNode -> pLeft  =  pNode1 -> pRight;
    pNode1 -> pRight  =  pNode;

     //  结点的位置变了, 要更新结点的高度值
    pNode -> nHeight  =  Max(Height(pNode -> pLeft), Height(pNode -> pRight))  +   1 ;
    pNode1 -> nHeight  =  Max(Height(pNode1 -> pLeft), pNode -> nHeight)  +   1 ;

    return pNode1;
}

/********************************************************************
pNode                                   pNode -> pRight
      /                                    /
     pNode -> pRight            ==>     pNode 
      /                                     /
pNode -> pRight -> pLeft                     pNode -> pRight -> pLeft
*********************************************************************/
AVLTree *  SingleRotateWithRight(AVLTree *  pNode)
{
    AVLTree *  pNode1;

    pNode1  =  pNode -> pRight;
    pNode -> pRight  =  pNode1 -> pLeft;
    pNode1 -> pLeft  =  pNode;

     //  结点的位置变了, 要更新结点的高度值
    pNode -> nHeight  =  Max(Height(pNode -> pLeft), Height(pNode -> pRight))  +   1 ;
    pNode1 -> nHeight  =  Max(Height(pNode1 -> pRight), pNode -> nHeight)  +   1 ;

    return pNode1;
}

AVLTree *  DoubleRotateWithLeft(AVLTree *  pNode)
{
    pNode -> pLeft  =  SingleRotateWithRight(pNode -> pLeft);

    return SingleRotateWithLeft(pNode);
}

AVLTree *  DoubleRotateWithRight(AVLTree *  pNode)
{
    pNode -> pRight  =  SingleRotateWithLeft(pNode -> pRight);

    return SingleRotateWithRight(pNode);
}

//  后序遍历树以删除树
void DeleteTree(AVLTree **  ppRoot)
{
     if  ( NULL   ==  ppRoot ||  NULL   ==   * ppRoot)
        return;

    DeleteTree( & (( * ppRoot) -> pLeft));
    DeleteTree( & (( * ppRoot) -> pRight));
    free( * ppRoot);
     * ppRoot  =   NULL ;
}

//  中序遍历打印树的所有结点, 因为左结点  <  父结点  <  右结点, 因此打印出来数据的大小是递增的
void PrintTree(AVLTree *  pRoot)
{
     if  ( NULL   ==  pRoot)
        return;

    static  int  n  =   0 ;

    PrintTree(pRoot -> pLeft);
    printf( " [%d]nData = %d/n " ,  ++ n, pRoot -> nData);
    PrintTree(pRoot -> pRight);
}