数据结构-平衡二叉树

最新推荐文章于 2024-02-06 16:09:32 发布

背后——NULL

最新推荐文章于 2024-02-06 16:09:32 发布

阅读量185

点赞数

分类专栏：数据结构文章标签：数据结构

本文链接：https://blog.youkuaiyun.com/qq_41433183/article/details/99611012

版权

数据结构专栏收录该内容

14 篇文章

订阅专栏

一、平衡二叉树介绍

在这里插入图片描述

二、代码实现

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

#define LH 1
#define EH 0
#define RH -1

#define TRUE 1
#define FALSE 0

typedef int ElemType;

typedef struct BiTNode
{
    ElemType data;
    ElemType bf;
    struct BiTNode *lchild, *rchild;
} BiTNode, *BiTree;


void R_Rotate(BiTree *p)
{
    BiTree L;
    L = (*p)->lchild;
    (*p)->lchild = L->rchild;
    L->rchild = (*p);
    *p = L;
}

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

void LeftBanlance(BiTree *T)
{
    BiTree L, Lr;
    L = (*T)->lchild;
    switch (L->bf)
    {
    case LH:
        (*T)->bf = L->bf = EH;
        R_Rotate(T);
        break;
    case RH:
        Lr = L->rchild;
        switch (Lr->bf)
        {
        case LH:
            (*T)->bf = RH;
            L->bf = EH;
            break;
        case EH:
            (*T)->bf = L->bf = EH;
            break;
        case RH:
            (*T)->bf = EH;
            L->bf = LH;
            break;
        }
        Lr->bf = EH;
        L_Rotate((*T)->lchild);
        R_Rotate(T);
    }
}


void RightBanlance(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);
    }
}

int InsertVAL(BiTree *T, int e, int *taller)
{
    if (!*T)
    {
        *T = (BiTree)malloc(sizeof(BiTNode));
        (*T)->data = e;
        (*T)->lchild = (*T)->rchild = NULL;
        (*T)->bf = EH;
        (*taller) = TRUE;
    }
    else
    {
        if (e == (*T)->data)
        {
            *taller = FALSE;
            return FALSE;
        }
        if (e < (*T)->data)
        {
            if (!InsertVAL(&(*T)->lchild, e, taller))
            {
                return FALSE;
            }
            if (*taller)
            {
                switch ((*T)->bf)
                {
                case LH:
                    LeftBanlance(T);
                    *taller = FALSE;
                    break;
                case EH:
                    (*T)->bf = LH;
                    *taller = TRUE;
                    break;
                case RH:
                    (*T)->bf = EH;
                    *taller = FALSE;
                    break;
                }
            }
        }

        else
        {
             if (!InsertVAL(&(*T)->rchild, e, taller))
            {
                return FALSE;
            }
            if (*taller)
            {
                switch ((*T)->bf)
                {
                case LH:
                    (*T)->bf = EH;
                    *taller = FALSE;
                    break;
                case EH:
                    (*T)->bf = RH;
                    *taller = TRUE;
                    break;
                case RH:
                    RightBanlance(T);
                    *taller = FALSE;
                    break;
                }
            }
        }
    }
    return TRUE;
}