04-树5 Root of AVL Tree

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. Figures 1-4 illustrate the rotation rules.

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>

#define Max(a,b) ( ( (a)>(b) )?(a):(b) )
typedef int ElementType;
typedef struct AvlNode * AvlTree;
typedef AvlTree Position;
struct AvlNode{
    ElementType Data;
    int Height;
    AvlTree Left;
    AvlTree Right;
};

int Height(Position P);

//返回旋转结果树的新根，并更新Height
Position LLRotation(Position A);

Position RRRotation(Position A);

Position LRRotation(Position A);

Position RLRotation(Position A);

AvlTree Insert(AvlTree T,ElementType X);


int main()
{
    int N,v;
    AvlTree tree=NULL;
    scanf("%d",&N);
    while(N){
        scanf("%d",&v);
        tree=Insert(tree,v);
        N--;
    }
    printf("%d",tree->Data);
}
int Height(Position P)
{
    if(P==NULL) return -1;
    else return Max( Height(P->Left),Height(P->Right) )+1;
}
Position LLRotation(Position A)
{
    Position B=A->Left;
    A->Left=B->Right;
    B->Right=A;
    A->Height=Max(Height(A->Left),Height(A->Right))+1;
    B->Height=Max(Height(B->Left),Height(B->Right))+1;
    return B;
}
Position RRRotation(Position A)
{
    Position B=A->Right;
    A->Right=B->Left;
    B->Left=A;
    A->Height=Max(Height(A->Left),Height(A->Right))+1;
    B->Height=Max(Height(B->Left),Height(B->Right))+1;
    return B;
}
Position LRRotation(Position A)
{
    A->Left=RRRotation(A->Left);
    return LLRotation(A);
}
Position RLRotation(Position A)
{
    A->Right=LLRotation(A->Right);
    return RRRotation(A);
}
AvlTree Insert(AvlTree T,ElementType X)
{
    if(T==NULL){
        T=(AvlTree)malloc(sizeof(struct AvlNode));
        T->Left=T->Right=NULL;
        T->Data=X;
        T->Height=0;
    }else if(X<T->Data){
        T->Left=Insert(T->Left,X);
        if( Height((T->Left))-Height(T->Right)==2 ){
            if(X<T->Left->Data)
                T=LLRotation(T);
            else
                T=LRRotation(T);
        }
    }else if(X>T->Data){
        T->Right=Insert(T->Right,X);
        if( Height((T->Right))-Height(T->Left)==2 ){
            if(X>T->Right->Data)
                T=RRRotation(T);
            else
                T=RLRotation(T);
        }
    }
    T->Height=Max( Height(T->Left),Height(T->Right) )+1;
    return T;
}