04-树5 Root of AVL Tree (25 分)

An AVL tree is a self-balancing binary search tree. In an AVL tree, the heights of the two child subtrees of any node differ by at most one; if at any time they differ by more than one, rebalancing is done to restore this property.

Now given a sequence of insertions, you are supposed to tell the root of the resulting AVL tree.
Input Specification:
Each input file contains one test case. For each case, the first line contains a positive integer N (≤20) which is the total number of keys to be inserted. Then N distinct integer keys are given in the next line. All the numbers in a line are separated by a space.

Output Specification:
For each test case, print the root of the resulting AVL tree in one line.

Sample Input 1:

5
88 70 61 96 120

Sample Output 1:

70

Sample Input 2:

7
88 70 61 96 120 90 65

Sample Output 2:

88

平衡二叉树平衡的就是二叉搜索树的高度。

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

typedef struct TNode *AVLTree;
struct TNode
{
    int Data;
    AVLTree Left;
    AVLTree Right;
    int Height;
};
int GetHeight(AVLTree T) //求树高
{
    int HL, HR, MaxH;
    if (T)
    {
        HL = GetHeight(T->Left);
        HR = GetHeight(T->Right);
        MaxH = HL > HR ? HL : HR;
        return (MaxH + 1);
    }
    else
        return 0;
}
int Max(int a, int b)
{
    return a > b ? a : b;
}
AVLTree SingleLeftRotation(AVLTree T)
{
    AVLTree B = T->Left;
    T->Left = B->Right;
    B->Right = T;
    T->Height = Max(GetHeight(T->Left), GetHeight(T->Right)) + 1;
    B->Height = Max(GetHeight(B->Left), T->Height) + 1;
    return B;
}
AVLTree SingleRightRotation(AVLTree T)
{
    AVLTree B = T->Right;
    T->Right = B->Left;
    B->Left = T;
    T->Height = Max(GetHeight(T->Left), GetHeight(T->Right)) + 1; //给T和要旋转的那个节点更新树高
    B->Height = Max(GetHeight(B->Right), T->Height) + 1;
    return B;
}
AVLTree DoubleLeftRightRotation(AVLTree T)
{
    T->Left = SingleRightRotation(T->Left);
    return SingleLeftRotation(T);
}
AVLTree DoubleRightLeftRotation(AVLTree T)
{
    T->Right = SingleLeftRotation(T->Right);
    return SingleRightRotation(T);
}
AVLTree Insert(AVLTree T, int x)
{
    if (!T)
    {
        T = (AVLTree)malloc(sizeof(struct TNode));
        T->Data = x;
        T->Height = 1;
        T->Left = T->Right = NULL;
    }
    else if (x < T->Data) //插左小于左旋，否则左右
    {
        T->Left = Insert(T->Left, x);
        if (GetHeight(T->Left) - GetHeight(T->Right) == 2) //判断是否需要旋转就是，看要插入的那边子树高度减去另一边的高度是否为2
        {
            if (x < T->Left->Data)
            {
                T = SingleLeftRotation(T);
            }
            else
            {
                T = DoubleLeftRightRotation(T);
            }
        }
    }
    else if (x > T->Data) //插右大于右旋，否则右左
    {
        T->Right = Insert(T->Right, x);
        if (GetHeight(T->Right) - GetHeight(T->Left) == 2) //判断是否需要旋转就是，看要插入的那边子树高度减去另一边的高度是否为2
        {
            if (x > T->Right->Data) //
            {
                T = SingleRightRotation(T);
            }
            else
            {
                T = DoubleRightLeftRotation(T);
            }
        }
    }
    T->Height = Max(GetHeight(T->Left), GetHeight(T->Right)) + 1; //最后要记得更新新树根高
    return T;
}
int main()
{
    int N;
    int i;
    int d;
    AVLTree T = NULL;
    scanf("%d", &N);
    for (i = 0; i < N; i++)
    {
        scanf("%d", &d);
        T = Insert(T, d);
    }
    printf("%d", T->Data);
    return 0;
}