平衡二叉树的建立，插入

输入测试数据：

 5 4 10 0 0 8 14 0 0 0 0

15

和

 5 4 10 0 0 8 14 0 0 0 0 

13

头文件：head.h

#ifndef HEAD_H_INCLUDE
#define HEAD_H_INCLUDE

#include <stdio.h>
#include <stdlib.h>

#define MAXSIZE 15
#define NoInfo 0
typedef int ElementType;


typedef struct AVLNode* Position;
typedef Position AVLTree;
struct AVLNode {
    ElementType Data;    //结点数据
    AVLTree Left;        //指向左子树
    AVLTree Right;        //指向右子树
    int Height;            //树高
};

typedef AVLTree ElemType;        //队列中的每个元素是AVL树的结点指针类型
typedef struct QNode* Queue;

struct QNode {
    ElemType Data[MAXSIZE];
    int front, rear;
};

int Max(int a, int b);

//获取T树的高度
int GetHeight(AVLTree T);

//T结点的平衡因子大于2，进行右单旋
AVLTree SingleRightRotation(AVLTree T);

//T结点的平衡因子小于-2， 进行左单旋
AVLTree SingleLeftRotation(AVLTree T);

//T结点的平衡因子小于-2， 但是插入的结点位于T结点的左子树的右子树上，进行左右双旋
AVLTree DoubleLeftRightRotation(AVLTree T);

//T结点的平衡因子大于2， 但是插入的界定啊位于T结点的右子树的左子树上，进行右左双旋
AVLTree DoubleRightLeftRotation(AVLTree T);

//AVL树的层序建立
AVLTree CreateAVLTree();

//打印结点
void printNode(AVLTree T, int height);

//中序递归遍历平衡二叉树
void InorderTraversal(AVLTree T, int height);

//平衡二叉树的插入
AVLTree Insert(AVLTree T, ElementType X);

#include "head.h"

//建立一个空的队列
Queue CreateQueue();

//队列的插入
void AddQ(Queue Q, ElemType X);

//判断队列是否为空
int IsEmpty(Queue Q);

//队列元素的删除
AVLTree DeleteQ(Queue Q);
#endif

平衡二叉树源文件：AVLTree.c

插入元素：

   #include "head.h"
 1 AVLTree Insert(AVLTree T, ElementType X)
{
    //将X插入AVL树T中，并且返回调整后的AVL数
    if (!T)        //如果树为空，或递归到最后的结点为空
    {
        T = (AVLTree)malloc(sizeof(struct AVLNode));
        T->Data = X;
        T->Left = T->Right = NULL;
    }

    else if (X < T->Data)
    {
        //先将X插入到二叉树中
        T->Left = Insert(T->Left, X);

        //如果二叉树的平衡被破坏，那么需要调整使之平衡
        if (GetHeight(T->Left) - GetHeight(T->Right) == 2)
        {
            if (X < T->Left->Data)
                T = SingleLeftRotation(T);        //进行左单旋
            else
                T = DoubleLeftRightRotation(T);    //进行左右双旋
        }
    }
    else if (X > T->Data)
    {
        //先将X插入到二叉树中
        T->Right = Insert(T->Right, X);

        //如果插入X结点后，T的平衡被破坏，那么需要调整使之达到平衡
        if (GetHeight(T->Left) - GetHeight(T->Right) == -2)
        {
            if (X > T->Right->Data)
                T = SingleRightRotation(T);        //将对T结点进行右单旋后结果返回给T
            else
                T = DoubleRightLeftRotation(T);        //将对T结点进行右左双旋后结果返回给T
        }
    }
    //else X = T->Data;        //无需插入

    //重新计算树高
    T->Height = Max(GetHeight(T->Left), GetHeight(T->Right)) + 1;

    return T;

}

四种旋转方式：

//左单旋
AVLTree SingleLeftRotation(AVLTree A)
{
    //A必有一个左子结点B
    AVLTree B = A->Left;
    A->Right = B->Right;
    B->Right = A;

    //重新计算树高
    A->Height = Max(GetHeight(A->Left), GetHeight(A->Right)) + 1;
    B->Height = Max(GetHeight(B->Left), GetHeight(B->Right)) + 1;
    return B;
}

//左右双旋
AVLTree DoubleLeftRightRotation(AVLTree A)
{
    //先进行一次右单旋，再进行一次左单旋
    A->Left = SingleRightRotation(A->Left);    //将B 、C做右单旋，并返回C

    //将A与C做左单旋，C被返回
    return SingleLeftRotation(A);
}


//右单旋
AVLTree SingleRightRotation(AVLTree A)
{
    //A必有一个右子结点B
    AVLTree B = A->Right;
    A->Right = B->Left;
    B->Left = A;

    //重新计算高度
    A->Height = Max(GetHeight(A->Left), GetHeight(A->Right)) + 1;
    B->Height = Max(GetHeight(B->Left), GetHeight(B->Right)) + 1;

    return B;
}

//右左双旋
AVLTree DoubleRightLeftRotation(AVLTree A)
{
    //先进行一次左单旋，再进行一次右单旋
    A->Right = SingleLeftRotation(A->Right);    //将B、C做左单旋，并返回C

    return SingleRightRotation(A);        //将A、C做右单旋，并返回结果，即返回C
}

平衡二叉树的层序建立：

//AVL树的层序建立
AVLTree CreateAVLTree()
{
    ElementType dt;
    AVLTree BT, T;
    Queue Q = CreateQueue();

    //建立第一个结点，即根节点
    scanf_s("%d", &dt);
    if (dt != NoInfo)
    {
        BT = (AVLTree)malloc(sizeof(struct AVLNode));
        BT->Data = dt;
        BT->Left = NULL;



        BT->Right = NULL;
        BT->Height = 0;
        AddQ(Q, BT);
    }
    else
        return NULL;        //若第一个结点就建立不成功， 则返回空树

    while (!IsEmpty(Q))
    {
        T = DeleteQ(Q);
        scanf_s("%d", &dt);
        if (dt == NoInfo)
            T->Left = NULL;
        else
        {
            //分配新结点，作为出队结点左孩子，新结点入队
            T->Left = (AVLTree)malloc(sizeof(struct AVLNode));
            T->Left->Data = dt;
            T->Left->Left = T->Left->Right = NULL;
            T->Left->Height = 0;
            AddQ(Q, T->Left);
        }
        scanf_s("%d", &dt);
        if (dt == NoInfo)
            T->Right = NULL;
        else
        {
            //分配新结点，作为出队结点的右孩子，新结点入队
            T->Right = (AVLTree)malloc(sizeof(struct AVLNode));
            T->Right->Data = dt;
            T->Right->Left = T->Right->Right = NULL;
            T->Right->Height = 0;
            AddQ(Q, T->Right);
        }
    }
    return BT;
}

二叉树的遍历：

//打印结点
void printNode(AVLTree T, int height)
{
    while (height--)
        printf("  ");
    printf("%d
", T->Data);
}

//中序递归遍历平衡二叉树
void InorderTraversal(AVLTree T, int height)
{
    if (T)
    {
        InorderTraversal(T->Right, height + 1);
        printNode(T, height);
        InorderTraversal(T->Left, height + 1);
    }
}

求树高和Max的函数：

int GetHeight(AVLTree T)
{
    int HL, HR, MaxH;
    if (T)
    {
        HL = GetHeight(T->Left);
        HR = GetHeight(T->Right);
        MaxH = Max(HL, HR) + 1;
        return MaxH;
    }
    else return 0;    //该数为空树或该结点的父节点为叶节点
}

int Max(int a, int b)
{
    return a > b ? a : b;
}

队列操作的源文件：Queue.c

#include "head.h"

//建立一个空的队列
Queue CreateQueue()
{
    Queue Q = (Queue)malloc(sizeof(struct QNode));
    Q->front = Q->rear = 0;
    return Q;
}

//判断队列是否已满
int IsFull(Queue Q)
{
    return (Q->rear + 1) % MAXSIZE == Q->front;
}


//队列的插入
void AddQ(Queue Q, ElemType X)
{
    if (IsFull(Q))
    {
        printf("The queue is full!
");
        return;
    }
    else
    {
        Q->Data[Q->rear] = X;
        Q->rear = (Q->rear + 1) % MAXSIZE;
    }
}

//判断队列是否为空
int IsEmpty(Queue Q)
{
    return Q->front == Q->rear;
}

//队列元素的删除
AVLTree DeleteQ(Queue Q)
{
    if (IsEmpty(Q))
    {
        printf("The Queue is empty!
");
        return NULL;
    }
    else
    {
        AVLTree T = Q->Data[Q->front];
        Q->front = (Q->front + 1) % MAXSIZE;
        return T;
    }
}

主函数源文件：main.c

#include "head.h"

int main()
{
    int elem;
    AVLTree T = CreateAVLTree();
    InorderTraversal(T, 0);
    printf("

Please the element that you want to insert: ");
    scanf_s("%d", &elem);
    T = Insert(T, elem);
    InorderTraversal(T, 0);

    return 0;
}