平衡二叉树

Potato_土豆
266 阅读9分钟

  • 概念

    • 平衡二叉树：就是一个特殊的二叉排序树，特殊的点在于所有结点的左子树和右子树的高度差值的绝对值小于等于1
    • 平衡因子BF:左子树的深度减去右子树的深度
    • 最小不平衡子树：距离插⼊点最近的,且平衡因⼦的绝对值⼤于1的结点为根的⼦树如图圈住的就是该树的最小不平衡子树

  • 平衡二叉树的构建思想以及相关图解

    • 构建思想
      就是在构建⼆叉排序树的过程中, 每当插⼊⼀个结点时, 先检查是否因插⼊⽽破坏了树的平衡性. 若是,则找到最⼩不平衡⼦树.在保持⼆叉排 序树特性的前提下,调整最⼩不平衡⼦树中各结点之间的链接关系.进⾏相应的旋转, 使之成为新的平衡⼦树.

    • 插入步骤图解
      例如插入{3,2,1,4,5,6,7,10,9,8}（如果插入不会造成平衡二叉树失衡则和二叉排序树的插入一样大于放到右孩子小于放到左孩子，下图是几种会造成失衡的插入图解）


      总结一下左旋和右旋的步骤：
      左旋的步骤：

      1. 找到最小不平衡子树的根节点P；
      2. P的右结点Pr的左结点变成根结点P的右结点
      3. P变成Pr的左结点
      4. Pr替换P变成新的跟节点

      右旋的步骤：

      1. 找到最小不平衡子树的根节点P；
      2. P的左结点Pl的右结点变成了P的左结点
      3. P变成了Pl的右结点
      4. Pl替换P变成新的跟节点

      注：当跟结点的符号和子结点的符号一致只需要左旋或者右旋，不一致的时候需要双旋先旋转一次让符号一致，然后在旋转调整二叉树的平衡，如果符号一致符号为负则右高需要左旋，如果符号为正则左高需要右旋

  • 代码实现

    #include "stdio.h"
#include "stdlib.h"

#include "math.h"
#include "time.h"

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXSIZE 100

typedef int Status;

//二叉树的二叉链表结点结构定义
//结点结构
typedef  struct BiTNode
{
    //结点数据
    int data;
    //结点的平衡因子
    int bf;
    //左右孩子指针
    struct BiTNode *lchild, *rchild;
} BiTNode, *BiTree;

//1.二叉排序树--查找
/*
 递归查找二叉排序树T中,是否存在key;
 指针f指向T的双亲,器初始值为NULL;
 若查找成功,则指针p指向该数据元素的结点,并且返回TRUE;
 若指针p指向查找路径上访问的最后一个结点则返回FALSE;
 */
Status SearchBST(BiTree T,int key,BiTree f, BiTree *p){
   
    if (!T)    /*  查找不成功 */
    {
        *p = f;
        return FALSE;
    }
    else if (key==T->data) /*  查找成功 */
    {
        *p = T;
        return TRUE;
    }
    else if (key<T->data)
        return SearchBST(T->lchild, key, T, p);  /*  在左子树中继续查找 */
    else
        return SearchBST(T->rchild, key, T, p);  /*  在右子树中继续查找 */
}

//2.二叉排序树-插入
/*  当二叉排序树T中不存在关键字等于key的数据元素时， */
/*  插入key并返回TRUE，否则返回FALSE */
Status InsertBST(BiTree *T, int key) {
    
    BiTree p,s;
    
    
    return FALSE;
}

//3.从二叉排序树中删除结点p,并重接它的左或者右子树;
Status Delete(BiTree *p){
    
    BiTree temp,s;
    
    
    if((*p)->rchild == NULL){
       
        //情况1: 如果当前删除的结点,右子树为空.那么则只需要重新连接它的左子树;
        //①将结点p临时存储到temp中;
        temp = *p;
        //②将p指向到p的左子树上;
        *p = (*p)->lchild;
        //③释放需要删除的temp结点;
        free(temp);
        
    }else if((*p)->lchild == NULL){
        
        //情况2:如果当前删除的结点,左子树为空.那么则只需要重新连接它的右子树;
        //①将结点p存储到temp中;
        temp = *p;
        //②将p指向到p的右子树上;
        *p = (*p)->rchild;
        //③释放需要删除的temp结点
        free(temp);
    }else{
        
        //情况③:删除的当前结点的左右子树均不为空;
       
        //①将结点p存储到临时变量temp, 并且让结点s指向p的左子树
        temp = *p;
        s = (*p)->lchild;
      
        //②将s指针,向右到尽头(目的是找到待删结点的前驱)
        //-在待删除的结点的左子树中,从右边找到直接前驱
        //-使用`temp`保存好直接前驱的双亲结点
        while (s->rchild) {
            temp = s;
            s = s->rchild;
        }
        
        //③将要删除的结点p数据赋值成s->data;
        (*p)->data = s->data;
        
        //④重连子树
        //-如果temp 不等于p,则将S->lchild 赋值给temp->rchild
        //-如果temp 等于p,则将S->lchild 赋值给temp->lchild
        if(temp != *p)
            temp->rchild = s->lchild;
        else
            temp->lchild = s->lchild;
        
        //⑤删除s指向的结点; free(s)
        free(s);
    }
    
    return  TRUE;
}

//4.查找结点,并将其在二叉排序中删除;
/* 若二叉排序树T中存在关键字等于key的数据元素时，则删除该数据元素结点, */
/* 并返回TRUE；否则返回FALSE。 */
Status DeleteBST(BiTree *T,int key)
{
    //不存在关键字等于key的数据元素
    if(!*T)
        return FALSE;
    else
    {
        //找到关键字等于key的数据元素
        if (key==(*T)->data)
            return Delete(T);
        else if (key<(*T)->data)
            //关键字key小于当前结点,则缩小查找范围到它的左子树;
            return DeleteBST(&(*T)->lchild,key);
        else
            //关键字key大于当前结点,则缩小查找范围到它的右子树;
            return DeleteBST(&(*T)->rchild,key);
        
    }
}
//1.右旋
/*
 对以p为根的二叉排序树作右旋处理;
 处理之后p指向新的树根结点,即旋转处理之前的左子树的根结点;
 步骤：
 1.p作为右旋的根结点
 2.p的左结点的右结点成为了p的左结点
 3.p成为左节点的右结点
 4.p的初始左节点替换p成为新的根结点
 */
void R_Rotate(BiTree *p){
    BiTree L = (*p)->lchild;
    (*p)->lchild = L->rchild;
    L->rchild = (*p);
    (*p) = L;
}

/*
 2.左旋
 对以P为根的二叉排序树作左旋处理
 处理之后P指向新的树根结点，即旋转处理之前的右子树的根结点
 步骤：
 1.p作为左旋的根结点
 2.p的右结点的左节点成为了p的右结点
 3.p成为了p的右结点的左结点
 4.p的初始右结点替换p成为了新的根结点
 */

void L_Rotate(BiTree *p){
    BiTree R = (*p)->rchild;
    (*p)->rchild = R->lchild;
    R->lchild = *p;
    *p = R;
}


#define LH +1 /*  左高 */
#define EH 0  /*  等高 */
#define RH -1 /*  右高 */
/*
 3. 对指针T所指结点为根的二叉树作左平衡旋转处理,算法结束后,指针T指向平衡处理后新的根结点
 */
void LeftBalance(BiTree *T){
    BiTree L,Lr;
    L = (*T)->lchild;
    switch (L->bf) {
        case LH:
            //符号相同只需要右旋即可
            L->bf = (*T)->bf = EH;
            R_Rotate(T);
            break;
        case RH:
            //符号不相同需要双旋，这里现需要将符号全部修改成功后再双旋
            Lr = L->rchild;
            switch (Lr->bf) {
                case LH:
                    L->bf = Lr->bf = EH;
                    (*T)->bf = RH;
                    break;
                case EH:
                    L->bf = Lr->bf = (*T)->bf = EH;
                    break;
                case RH:
                    L->bf = LH;
                    Lr->bf = (*T)->bf = EH;
                    break;
                    
                default:
                    break;
            }
            L_Rotate(&(*T)->lchild);
            R_Rotate(T);
            break;
            
        default:
            break;
    }
}


/*
 4. 右平衡树失衡处理
 对以指针T所指结点为根的二叉树作右平衡旋转处理
 本算法结束时，指针T指向新的根结点
 */
void RightBalance(BiTree *T){
    BiTree R,Rl;
    R=(*T)->rchild;
    switch(R->bf)
    {
        case RH:
            (*T)->bf=R->bf=EH;
            L_Rotate(T);
            break;
        case LH:
            Rl=R->lchild;
            switch(Rl->bf)
                {
                    case RH:
                        (*T)->bf=LH;
                        R->bf=EH;
                        break;
                    case EH:
                        (*T)->bf=R->bf=EH;
                        break;
                    case LH:
                        (*T)->bf=EH;
                        R->bf=RH;
                        break;
                }
            
            Rl->bf=EH;
            R_Rotate(&(*T)->rchild);
            L_Rotate(T);
    }
}

/*
 5. 平衡二叉树的插入实现
 若在平衡的二叉排序树T中不存在和e有相同关键字的结点，则插入一个数据元素为e的新结点，并返回1，否则返回0。若因插入而使二叉排序树失去平衡，则作平衡旋转处理，布尔变量taller反映T长高与否
 思路:
 1.如果T为空时,则创建一个新结点;
 2.如果T不为空,判断是否存在相同的结点.如果二叉树中存在相同结点,则不需要插入;
 3.如果新结点值e小于T的根结点值,则在T的左子树查找;
 -如果能在左子树中查找到,则不插入进去.返回False; 如果没有找到,则插入
 -插入成功taller为TRUE,说明新结点e已经插入进去; 此时需要判断T的平衡因子;
 -如果平衡因子是1,则说明左子树高于右子树,那么需要调用leftBalance进行左平衡旋转处理;
 -如果为0或者-1,则说明新插入的结点没有让整颗二叉排序树失去平衡性,只需要修改BF值即可;
 4.如果新结点值e大于T的根结点值,则在T的右子树查找;
 -如果能在右子树中查找到,则不插入进去.返回False; 如果没有找到,则插入
 -插入成功taller为TRUE,说明新结点e已经插入进去; 此时需要判断T的平衡因子;
 -如果平衡因子是-1,则说明右子树高于左子树,那么需要调用RightBalance进行右平衡旋转处理;
 -如果为0或者1,则说明新插入的结点没有让整颗二叉排序树失去平衡性,只需要修改BF值即可;
 */
Status InsertAVL(BiTree *T,int e,Status *taller){
    if(!*T){
        *T = (BiTree)malloc(sizeof(BiTNode));
        (*T)->bf = 0;
        (*T)->lchild = (*T)->rchild = NULL;
        (*T)->data = e;
        *taller = TRUE;
        return OK;
    }else{
        if((*T)->data == e){
            *taller = FALSE;
            return ERROR;
        }else if((*T)->data > e){
            //根节点的数据大于目标值则插到左子树
            if(InsertAVL(&(*T)->lchild, e, taller)){
                *taller = TRUE;
                //插入成功
                switch ((*T)->bf) {
                    case EH:
                        (*T)->bf = LH;
                        break;
                    case LH:
                        LeftBalance(T);
                        *taller=FALSE;
                        break;
                    case RH:
                        (*T)->bf = EH;
                        break;
                        
                    default:
                        break;
                }
                return OK;
            }else{
                *taller = FALSE;
                return ERROR;
            }
        }else{
            //根节点的数据大于目标值则插到左子树
            if(InsertAVL(&(*T)->rchild, e, taller)){
                *taller = TRUE;
                //插入成功
                switch ((*T)->bf) {
                    case EH:
                        (*T)->bf = RH;
                        break;
                    case LH:
                        (*T)->bf = EH;
                        break;
                    case RH:
                        RightBalance(T);
                        *taller=FALSE;
                        break;
                        
                    default:
                        break;
                }
                return OK;
            }else{
                *taller = FALSE;
                return ERROR;
            }
        }
    }
}


int main(int argc, const char * argv[]) {
    // insert code here...
    printf("平衡二叉树 !\n");
    int i;
    int a[10]={3,2,1,4,5,6,7,10,9,8};
    //调整数组的顺序,最终生成的平衡二叉树高度是一样的.
    //int a[10]={8,9,1,4,5,6,7,10,2,3};
    //int a[10]={9,4,1,2,7,6,5,10,3,8};
    
    BiTree T=NULL;
    Status taller;
    int sum = 0;
    for(i=0;i<10;i++)
    {
        InsertAVL(&T,a[i],&taller);
        sum += taller;
        printf("插入%d,是否增加树的高度(%d)[YES->1 / NO->0]\n",a[i],taller);
    }
    
    printf("将数组a插入到平衡二叉树后,最终形成高度为%d的平衡二叉树\n",sum);
    
    BiTree p;
    int statusValue = SearchBST(T, 10, NULL, &p);
    printf("查找%d是否成功:%d (1->YES/0->NO)\n",p->data,statusValue);
    return 0;
}
avatar
文章
阅读
粉丝