2021-10-15

平衡二叉树AVL

typedef struct bst
{
    int val;
    int length;
    struct bst *left;
    struct bst *right;
}*BST;
BST Troot;
BST creat(BST Troot, int v)//创建
{
    Troot=(BST)malloc(sizeof(struct bst));
    Troot->val=v;
    Troot->length=0;
    Troot->left=Troot->right=NULL;
    return Troot;
}
int Max(a, b)
{
    return a>b?a:b;
}
int Height(BST Troot)//计算节点高度
{
    if(!Troot->left && !Troot->right)
    {
        return 0;

    }else
    {
        return Max(Height(Troot->left), Height(Troot->right))+1;
    }

}
BST Singleleft(BST A)//左旋
{
    BST B=A->left;
    A->left=B->right;
    B->right=A;
    A->length=Height(A);//计算A的高度
    B->length=Height(B);//计算B的高度
    return B;
}
BST Singleright(BST A)//右旋
{
    BST B=A->right;
    A->right=B->left;
    B->left=A;
    A->length=Height(A);//计算A的高度
    B->length=Height(B);//计算B的高度
    return B;
}
BST Doubleleftright(BST A)//左右旋
{   //A的左节点B， B的右节点C
    A->left=Singleright(A->left);//B,C右旋， 返回C
    return Singleleft(A);//A, C左旋， 返回C
}
BST Doublerightleft(BST A)//右左旋
{   //A的右节点B， B的左节点C
    A->right=Singleleft(A->right);//B,C左旋， 返回C
    return Singleright(A);//A,C右旋， 返回C
}



BST Insert(int v, BST Troot)
{
    if(!Troot)//为空时插入节点
    {
        Troot=(BST)malloc(sizeof(struct bst));
        Troot->val=v;
        Troot->length=0;
        Troot->left=Troot->right=NULL;
    }else
    {
        if(v<Troot->val)//在左节点插入
        {
            Troot->left=Insert(v, Troot->left);//递归左子树插入
            if(Height(Troot->left)-Height(Troot->right)==2)//判断左右子树的高度差
            {
                if(v<Troot->left->val)
                    Troot=Singleleft(Troot);//左旋
                else
                    Troot=Doubleleftright(Troot);//左右旋
            }
        }else if(v>Troot->val)
        {
            Troot->right=Insert(v, Troot->right);//递归右子树插入
            if(Height(Troot->left)-Height(Troot->right)==-2)//判断左右子树的高度差
            {
                if(v>Troot->right->val)
                    Troot=Singleright(Troot);//右旋
                else
                    Troot=Doublerightleft(Troot);//右左旋
            }
        }
    }
    Troot->length=Height(Troot);//计算高度
    return Troot;
}
BST Findmin(BST Troot)
{
    if(!Troot)
        return NULL;
    else if(!Troot->left)
        return Troot;
    else 
        return Findmin(Troot->left);

}
BST Delete(int v, BST Troot)        //平衡二叉树的删除
{
    BST temp;
    if(!Troot)
        printf("要删除的元素没找到");
    else if(v<Troot->val)//删除的数在左边
    {
        Troot->left=Delete(v, Troot->left);
        if(Height(Troot->left)-Height(Troot->right)==2)
        {
            if(v<Troot->left->val)
                Troot=Singleleft(Troot);//左旋
            else
                Troot=Doubleleftright(Troot);//左右旋
        }
    }else if(v>Troot->val)//删除的数在右边
    {
        Troot->right=Delete(v, Troot->right);
        if(Height(Troot->left)-Height(Troot->right)==-2)
        {
            if(v<Troot->right->val)//右旋
                Troot=Singleright(Troot);
            else
                Troot=Doublerightleft(Troot);//右左旋
        }
    }else//相等
    {
        if(Troot->left && Troot->right)//有俩个子节点
        {
            temp=Findmin(Troot->right);
            Troot->val=temp->val;//替换右子树的最小节点
            Troot->right=Delete(Troot->val, Troot->right);//删除右子树的最小节点
        }else
        {
            temp=Troot;
            if(!Troot->left)//有右节点或无节点
                Troot=Troot->right;
            else if(!Troot->right)//有左节点或无节点
                Troot=Troot->left;
        }
        free(temp);
    }
    Troot->length=Height(Troot);
    return Troot;

}