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$ (≤) 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 AVLNode* Position;
typedef Position AVLTree;
struct AVLNode{
    int data;
    AVLTree left;
    AVLTree right;
    int height;
};

int Max(int a, int b);
int GetHeight(AVLTree T);
AVLTree Insert(AVLTree T, int X);
AVLTree SingleLeftRotation(AVLTree A);
AVLTree SingleRightRotation(AVLTree A);
AVLTree DoubleLeftRightRotation(AVLTree A);
AVLTree DoubleRightLeftRotation(AVLTree A);

int main()
{
    int n, temp;
    AVLTree root = NULL;
    scanf("%d", &n);
    while(n--){
        scanf("%d", &temp);
        root = Insert(root, temp);
    }
    printf("%d", root->data);
    return 0;
}

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

int GetHeight(AVLTree T){
    int max, left, right;
    if(T){
        left = GetHeight(T->left);
        right = GetHeight(T->right);
        max = Max(left, right);
        return (max+1);
    }else return 0;
}

AVLTree Insert(AVLTree T, int X){
    if(!T){//空结点
        T = (AVLTree)malloc(sizeof(struct AVLNode));
        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){//破坏了平衡
            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->left) - GetHeight(T->right) == -2){
            if( X > T->right->data)//右旋
                T = SingleRightRotation(T);
            else//右左双旋
                T = DoubleRightLeftRotation(T);
        }
    }//X==T->data不作处理
    T->height = Max(GetHeight(T->left), GetHeight(T->right)) + 1;//更新高度，由于是递归，会自下往上更新高度
    return T;
}

AVLTree SingleLeftRotation(AVLTree A){
    AVLTree B = A->left;//左旋必有左结点
    A->left = B->right;//B的右子树成为A的左子树
    B->right = A;//A成为B的右子树
    A->height = Max(GetHeight(A->left), GetHeight(A->right)) + 1;//更新高度
    B->height = Max(GetHeight(B->left), GetHeight(B->right)) + 1;
    return B;//B作为根节点返回
}

AVLTree SingleRightRotation(AVLTree A){
    AVLTree B = A->right;//右旋必有右结点
    A->right = B->left;//B的左子树成为A的右子树
    B->left = A;//A成为B的左子树
    A->height = Max(GetHeight(A->left), GetHeight(A->right)) + 1;//更新高度
    B->height = Max(GetHeight(B->left), GetHeight(B->right)) + 1;
    return B;//B作为根节点返回
}

AVLTree DoubleLeftRightRotation(AVLTree A){//左右双旋 A必有左结点，其左结点必有右结点
    A->left = SingleRightRotation(A->left);//双旋实际上可以看作左结点右旋，根节点左旋两次单旋
    return SingleLeftRotation(A);//返回新的根结点
}

AVLTree DoubleRightLeftRotation(AVLTree A){//右左双旋，A必有右结点，其右结点必有左结点
    A->right = SingleLeftRotation(A->right);//实际上可以看作右结点左旋，根节点右旋
    return SingleRightRotation(A);//返回新的根结点
}