AVL树的插入删除查找算法实现和分析-1(平衡因子法）

布满荆棘的人生 2021-09-19 23:46 259阅读 0赞

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

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

代码如下：

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

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++有），所以就要用到双重指针，这无疑加大了程序的复杂度，而且使程序更容易出错。而避免这样的情况的做法是很简单的，只需要做一个简单的修改。就是让旋转插入等操作的返回值为指向结点的指针，而不是一个标志操作是否成功的状态值。而且这样做还有一个好处，就是通常最后插入的数据总是最先被访问，这样就可以根据返回的结点的指针马上访问该结点，而不用再在整棵树中查找。

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

改进后的算法会在下一篇文章（[AVL树的插入删除查找算法实现和分析-2（树高度法）][AVL_-2]）中给出。

[AVL_-2]: http://blog.csdn.net/ljianhui/article/details/9204667