C语言实现平衡二叉树-来源小甲鱼

源码

/* 平衡二叉树 (难）*/
#include<stdio.h>
#include<stdlib.h>
#define LH 1 //左子树高了
#define EH 0 //左右子树等高
#define RH -1 //右子树高了

typedef int Status; //Status是函数的类型,其值是函数结果状态代码，如OK等 
#define TRUE 1
#define FALSE 0
// #define Status bool

typedef struct BiTNode
{
    int data;
    int bf;//平衡因子
    struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;//两种命名方式，效果，BiTree 等价于 BiTNode *;

//右旋转操作
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 LeftBalance(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 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)->lchild);
			L_Rotate(T);
	}
}

//插入，创建平衡二叉树(递归插入)
Status InsertAVL(BiTree* T,int e,Status *taller)
{
    //taller变量存放，增加一个结点后，这棵树长高了没有，长高了就不平衡了。

    //找不到跟树中一样值的话，分配一个新结点插入。
    if(!*T)
    {
        *T = (BiTree)malloc(sizeof(BiTNode));
        (*T)->data = e;
        (*T)->lchild = (*T)->rchild = NULL;
        (*T)->bf = EH;
        *taller = 0;//默认长高
    }
    else
    {
        if(e == (*T)->data)
        {
            //树中已经存在要插入的值
            *taller = 1;
            return  FALSE;
        }
        if(e <(*T)->data)
        {
            if(!InsertAVL(&(*T)->lchild,e,taller))
            {
                return FALSE;
            }
            if(*taller)
            {
                switch((*T)->bf)
                {
                    case LH:
                        LeftBalance(T);//左高，左平衡。
                        *taller = FALSE;
                        break;
                    case EH:
                        (*T)->bf = LH;
                        *taller = TRUE;
                        break;
                    case RH:
                        (*T)->bf =EH;
                        *taller = FALSE;
                        break;

                }
            }
            
        }
        else
        {
            if(!InsertAVL(&(*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:
                        RightBalance(T);
                        *taller = FALSE;
                        break;

                }
            }
        }
        
    }
    
}


void inorder(BiTNode* node)//树的中序遍历
{
    if (node != NULL)
    {
        inorder(node->lchild);
        printf("%d ",node->data);
        inorder(node->rchild);
    }
}

int main(void)
{
    int i;
    int a[10]={3,2,1,4,5,6,7,10,9,8};
    BiTree T=NULL;
    Status taller;
    for(i=0;i<10;i++)
    {
        InsertAVL(&T,a[i],&taller);
    }
    printf("中序遍历二叉平衡树:\n");
    inorder(T);


    system("pause");
    return 0;
}

测试结果