AVL树是带有平衡条件的BST。

AVL树满足以下两个条件：

（1）任何一个节点的左子树上的数值都比该节点小，右子树上的数值都比该节点大

（2）每个节点的左右子树的高度差的绝对值不差过1

c语言实现：

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

//#define Max(a,b)  ((a)>(b))?(a):(b)

typedef struct avltree{
    int key;
    struct avltree* lchild;
    struct avltree* rchild;
    int height;
}avltree,*avlptr;

avltree* avl_insert(int x,avltree* t);

avltree* avl_delete(int x,avltree* t);

avltree* findmin(avltree* t);

avltree* findmax(avltree* t);

avltree* Rrotation(avltree*);

avltree* Lrotation(avltree*);

avltree* LRrotation(avltree*);

avltree* RLrotation(avltree*);

void avl_print(avltree* t);

void pre_print(avltree* t);

int height(avltree* t)
{
    if(t==NULL)
        return -1;
    else
        return t->height;
}

int Max(int x,int y)
{
    if(x>y)
        return x;
    else 
        return y;
}
main()
{
    avltree* root=NULL;
    root=avl_insert(2,root);
    root=avl_insert(1,root);
    root=avl_insert(3,root);
    root=avl_insert(4,root);
    root=avl_insert(5,root);
    root=avl_insert(6,root);
    root=avl_insert(7,root);
    root=avl_insert(16,root);
    root=avl_delete(4,root);
    root=avl_insert(15,root);
    root=avl_insert(14,root);
    root=avl_insert(13,root);
    avl_print(root);
    printf("\n");
    printf("%d\n",root->key);

    return 0;
}

void avl_print(avltree * t)
{
    if(t!=NULL)
    {
        printf("%d (%d) ",t->key,t->height);
        avl_print(t->lchild);
        //printf("%d ",t->key);
        avl_print(t->rchild);
    }
}

avltree* avl_insert(int x,avltree* root)//插入操作
{
    avltree* cur;

    if(root==NULL)
    {
        cur=(avltree *)malloc(sizeof(struct avltree));
        assert(cur!=NULL);
        cur->key=x;
        cur->height=0;
        cur->lchild=cur->rchild=NULL;
        root=cur;
        return root;
    }
    else if(x<root->key){
        root->lchild=avl_insert(x,root->lchild);
        if(height(root->lchild)-height(root->rchild)==2){
            if(x<root->lchild->key)
                root=Lrotation(root);
            else
                root=LRrotation(root);}
        else
            ;
            //root->height=Max(height(root->lchild),height(root->rchild)) +1;
    }
    else if(x>root->key){
        root->rchild=avl_insert(x,root->rchild);
        if(height(root->rchild)-height(root->lchild)==2){
            if(x>root->rchild->key)
                root=Rrotation(root);
            else
                root=RLrotation(root);}
        else
            //root->height=Max(height(root->lchild),height(root->rchild)) +1;
            ;
    }

    root->height=Max(height(root->lchild),height(root->rchild)) +1;

    return root;
}

avltree* findmin(avltree* t)
{
    if(t==NULL)
        return NULL;
    else if(t->lchild==NULL)
        return t;
    else
        return t->lchild;
}

avltree* findmax(avltree * t)
{
    if(t==NULL)
        return NULL;
    else if(t->rchild!=NULL)
        return t->rchild;
    else
        return t;
}

avltree* Rrotation(avltree* k1)
{
    avltree* k2;
    k2=k1->rchild;
    k1->rchild=k2->lchild;
    k2->lchild=k1;
    k1->height=1+Max(height(k1->lchild),height(k1->rchild));
    k2->height=1+Max(height(k2->lchild),height(k2->rchild));
    return k2;
}

avltree* Lrotation(avltree* k1)
{
    avltree * k2;
    k2=k1->lchild;
    k1->lchild=k2->rchild;
    k2->rchild=k1;
    k1->height=1+Max(height(k1->lchild),height(k1->rchild));
    k2->height=1+Max(height(k2->lchild),height(k2->rchild));
    return k2;
}

avltree* LRrotation(avltree* k1)
{
    k1->lchild=Rrotation(k1->lchild);

    return Lrotation(k1);
}

avltree* RLrotation(avltree* k1)
{
    k1->rchild=Lrotation(k1->rchild);

    return Rrotation(k1);
}

avltree* avl_delete(int x,avltree* proot)//删除操作
{
    avltree* cur;
    //assert(proot!=NULL);
    if(proot!=NULL){
    if(x<proot->key){
        proot->lchild=avl_delete(x,proot->lchild);
        if(height(proot->rchild)-height(proot->lchild)==2)
            if(height(proot->rchild->rchild)>height(proot->rchild->lchild))
                proot=Rrotation(proot);
            else
                proot=RLrotation(proot);
        else
            proot->height=Max(height(proot->lchild),height(proot->rchild))+1;
    }
    else if(x>proot->key){
        proot->rchild=avl_delete(x,proot->rchild);
        if(height(proot->lchild)-height(proot->rchild)==2)
            if(height(proot->lchild->lchild)>height(proot->lchild->rchild))
                proot=Lrotation(proot);
            else
                proot=LRrotation(proot);
        else
            proot->height=Max(height(proot->lchild),height(proot->rchild))+1;
    }
    else if(proot->lchild&&proot->rchild)
    {
        if(height(proot->rchild)>height(proot->lchild))
        {
            cur=findmin(proot->rchild);
            proot->key=cur->key;
            proot->rchild=avl_delete(proot->key,proot->rchild);
        }
        else
        {
            cur=findmax(proot->lchild);
            proot->key=cur->key;
            proot->lchild=avl_delete(proot->key,proot->lchild);
        }
    }
    else
    {
        cur=proot;
        if(proot->lchild==NULL)
            proot=proot->rchild;
        else if(proot->rchild==NULL)
            proot=proot->rchild;
        else 
            proot=NULL;
        free(cur);
    }
    //proot->height=Max(height(proot->lchild),height(proot->rchild))+1;
    }
    return proot;
}

参考：数据结构与算法分析