AVL树的插入删除查找算法实现和分析-1

至于什么是AVL树和AVL树的一些概念问题在这里就不多说了，下面是我写的代码，里面的注释非常详细地说明了实现的思想和方法。

因为在操作时真正需要的是子树高度的差，所以这里采用-1，0，1来表示左子树和右子树的高度差，而没有使用记录树的高度的方法。

代码如下：

typedef struct AVLNode
{
    DataType cData;
    int nBf;        //结点的平衡因子，-1表示右子树的深度比左子树高1
                    //0表示左子树与右子树深度相等
                    //1表示左子树的深度比右子树高1
    struct AVLNode *LChild;
    struct AVLNode *RChild;
}AVLNode,*AVLTree;

typedef int BOOL;

enum enumHight{LH = 1, EH = 0, RH = -1} eHight;
enum enumBool{FALSE = 0, TRUE = 1} eBool;

void R_Rotate(AVLTree *pAT)
{
    //对以*pAT为根的二叉树作右旋转处理，处理之后pAT指向新的树根结点
    //即旋转处理之前的左子树的根结点
    AVLTree lc = (*pAT)->LChild;
    (*pAT)->LChild = lc->RChild;
    lc->RChild = *pAT;
    *pAT = lc;
}
void L_Rotate(AVLTree *pAT)
{
    //对以*pAT为根的二叉树作左旋转处理，处理之后pAT指向新的树根结点
    //即旋转处理之前的右子树的根结点
    AVLTree rc = (*pAT)->RChild;
    (*pAT)->RChild = rc->LChild;
    rc->LChild = *pAT;
    *pAT = rc;
}
void LeftBalance(AVLTree *pAT)
{
    //对以指针pAT所指结点为根的二叉树作左平衡旋转处理，
    //本算法结束时指针pAT指向新的结点
    AVLTree lc = (*pAT)->LChild;    //lc指向*pAT的左子树根结点
    AVLTree rd = NULL;
    if(lc)
    switch(lc->nBf)     //检查*pAT的左子树的平衡度，并作相应平衡处理
    {
        case LH:    //新结点插入在*pAT的左孩子的左子树上，要作单右旋转处理
            (*pAT)->nBf = lc->nBf = EH;
            R_Rotate(pAT);
            break;
        case RH:    //新结点插入在*pAT的左孩子的右子树上，要作双旋转处理
            rd = lc->RChild;
            switch(rd->nBf) //修改*pAT及其左孩子的平衡因子
            {
                case LH:
                    (*pAT)->nBf = RH;
                    lc->nBf = EH;
                    break;
                case EH:
                    (*pAT)->nBf = lc->nBf = EH;
                    break;
                case RH:
                    (*pAT)->nBf = EH;
                    lc->nBf = LH;
                    break;
                default:;
            }
            rd->nBf = EH;
            L_Rotate(&(*pAT)->LChild);  //对*pAT的左子树作左平衡处理
            R_Rotate(pAT);      //对*pAT作右平衡处理
            break;
        default:;
    }
}
void RightBalance(AVLTree *pAT)
{
    //对以指针pAT所指结点为根的二叉树作右平衡旋转处理，
    //本算法结束时指针pAT指向新的结点
    AVLTree rc = (*pAT)->RChild;
    AVLTree rd = NULL;
    if(rc)
    switch(rc->nBf)
    {
        case RH:
            (*pAT)->nBf = rc->nBf = EH;
            L_Rotate(pAT);
            break;
        case LH:
            rd = rc->LChild;
            switch(rd->nBf)
            {
                case LH:
                    (*pAT)->nBf = EH;
                    rc->nBf = RH;
                    break;
                case EH:
                    (*pAT)->nBf = rc->nBf = EH;
                    break;
                case RH:
                    (*pAT)->nBf = LH;
                    rc->nBf = EH;
                    break;
            }
            rd->nBf = EH;
            R_Rotate(&(*pAT)->RChild);
            L_Rotate(pAT);
        default:;
    }
}
BOOL InsertATNode(AVLTree *pAT, DataType c)
{
    //若在平衡的二叉树pAT中不存在和c相同的关键字结点，
    //则插入一个以c为数据元素的新结点，并返回1，否则返回0
    //若因插入而使二叉排序树失去平衡，则作平衡旋转处理
    static int taller = FALSE;  //反映pAT树是否长高
    if(!(*pAT))
    {
        //插入新结点，树长高，taller为TRUE;
        (*pAT) = (AVLTree)malloc(sizeof(AVLNode));
        (*pAT)->cData = c;
        (*pAT)->LChild = (*pAT)->RChild = NULL;
        (*pAT)->nBf = EH;
        taller = TRUE;
    }
    else
    {
        if((*pAT)->cData == c)
        {
            //树中已存在和e相同关键字的结点，不插入
            taller = FALSE;
            return 0;
        }
        if(c < (*pAT)->cData)
        {
            //应该在*pAT的左子树中进行搜索
            if(!InsertATNode(&(*pAT)->LChild, c))   //未插入
                return 0;
            if(taller)  //已插入到树pAT并且左子树长高
            {
                switch((*pAT)->nBf) //检查*pAT的平衡因子
                {
                    case LH:    //原本左子树比右子树高，作左平衡处理
                        LeftBalance(pAT);
                        taller = FALSE;
                        break;
                    case EH:    //原本左右子树等高，现左子树比右子树高1
                        (*pAT)->nBf = LH;
                        taller = TRUE;
                        break;
                    case RH:    //原本右子树比左子树高，现左右子树等高
                        (*pAT)->nBf = EH;
                        taller = FALSE;
                        break;
                }
            }
        }
        else
        {
            //应该在*pAT的右子树中进行搜索
            if(!InsertATNode(&(*pAT)->RChild, c))   //未插入
                return 0;
            if(taller)  //已插入到树pAT并且右子树长高
            {
                switch((*pAT)->nBf) //检查*pAT的平衡因子
                {
                    case LH:    //原本左子树比右子树高，现左右子树等高
                        (*pAT)->nBf = EH;
                        taller = FALSE;
                        break;
                    case EH:    //原本左右子树等高，现右子树比左子树高1
                        (*pAT)->nBf = RH;
                        taller = TRUE;
                        break;
                    case RH:    //原本右子树比左子树高，作右平衡处理
                        RightBalance(pAT);
                        taller = FALSE;
                        break;
                }
            }
        }
    }
    return 1;
}
BOOL DeleteNode(AVLTree *pAT, DataType c)
{
    //若在平衡的二叉树pAT中存在和c相同的关键字结点，
    //则删除一个以c为数据元素的结点，并返回1，否则返回0
    //若因删除而使二叉排序树失去平衡，则作平衡旋转处理
    static int lower = FALSE;   //反映pAT树是否变矮
    if(!(*pAT))     //树为空或结点不存在返回0
        return 0;
    if(c == (*pAT)->cData)
    {
        //存在要删除的结点
        //查找用作替换的结点
        AVLTree Min = FindMin((*pAT)->RChild);
        if(Min != NULL) //存在右子树
        {
            //找到可以用作替换的点
            (*pAT)->cData = Min->cData;
            if(Min != (*pAT)->RChild)
            {
                AVLTree Parent = GetParent((*pAT)->RChild, Min->cData);
                Parent->LChild = Min->RChild;
            }
            else
            {
                (*pAT)->RChild = Min->RChild;
            }

free(Min);
        }
        else //不存在右子树
        {
            //找不到删除的结点
            Min = *pAT;
            *pAT = (*pAT)->LChild;
            free(Min);
        }
        lower = TRUE;
    }
    else if(c < (*pAT)->cData)
    {
        //应该在*pAT的左子树中进行搜索
        if(!DeleteNode(&(*pAT)->LChild, c)) //未删除
            return 0;

if(lower)   //树变矮
        {
            switch((*pAT)->nBf)
            {
                case LH:    //原本左子树比右子树高，现在等高
                    (*pAT)->nBf = EH;
                    lower = TRUE;
                    break;
                case EH:    //原本左右子树等高，现右子树比左子树高1
                    (*pAT)->nBf = RH;
                    lower = FALSE;
                    break;
                case RH:    //原本右子树比左子树高，则作右平衡处理
                    RightBalance(pAT);
                    lower = TRUE;
                    break;
            }
        }

}
    else if(c > (*pAT)->cData)
    {
        //应该在*pAT的右子树中进行搜索
        if(!DeleteNode(&(*pAT)->RChild, c))
            return 0;
        if(lower)
        {
            switch((*pAT)->nBf)
            {
                case LH:    //原本左子树比右子树高，则作左平衡处理
                    LeftBalance(pAT);
                    lower = TRUE;
                    break;
                case EH:    //原本左右子树等高，现左子树比右子树高1
                    (*pAT)->nBf = LH;
                    lower = FALSE;
                    break;
                case RH:    //原本右子树比左子树高，现左左子树等高
                    (*pAT)->nBf = EH;
                    lower = TRUE;
                    break;
            }
        }
    }

return 1;
}
AVLTree FindMin(AVLTree AT)
{
    //查找AT中最小的元素
    while(AT && AT->LChild)
    {
        AT = AT->LChild;
    }
    return AT;
}
AVLTree GetParent(AVLTree AT, DataType c)
{
    if(!AT || AT->cData == c)
        return NULL;
    if((AT->LChild && AT->LChild->cData == c) ||
            (AT->RChild && AT->RChild->cData == c))
        return AT;
    else if((AT->LChild && c < AT->LChild->cData))
        return GetParent(AT->LChild, c);
    else
        return GetParent(AT->RChild, c);
}

AVLTree FindATNode(AVLTree AT, DataType c)
{
    if(!AT)
        return NULL;
    else if(AT->cData == c)
        return AT;
    else if(c < AT->cData)
    {
        return FindATNode(AT->LChild, c);
    }
    else
    {
        return FindATNode(AT->RChild, c);
    }
}

现在对这种实现方法作一点小小的分析。

1、至于时间复杂度的分析就不必多说了，所有的算法的时间复杂度都为log2N。

2、从代码的数量可以看出这并不是一种好的实现方法，因为它的思路不太清晰和直观，操作实现比较复杂，还要用到二重指针，增加了程序出错的机会。

3、导致复杂的原因主要有两个，

1）第一个就是在高度信息储存方法上，不是采用每个结点保存自己作为一棵树的深度，而是保存着左右子树之差（左子树的深度 - 右子树的深度），从而产生了大量的判断和switch语句，让人眼花瞭乱，并且影响程序的效率和易读性，难以维护，所以用一个变量记录树的高度会让程序思路更清晰。

2）再者，在这里的旋转、插入的删除操作都要调节结点并改变指向结点的指针变量的值，在C语言中是没有引用的（C++有），所以就要用到双重指针，这无疑加大了程序的复杂度，而且使程序更容易出错。而避免这样的情况的做法是很简单的，只需要做一个简单的修改。就是让旋转插入等操作的返回值为指向结点的指针，而不是一个标志操作是否成功的状态值。而且这样做还有一个好处，就是通常最后插入的数据总是最先被访问，这样就可以根据返回的结点的指针马上访问该结点，而不用再在整棵树中查找。

算法如有错误，还请各位读者指出，谢谢！

改进后的算法会在下一篇的博客中给出。