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 *AVLTree;
struct AVLNode{
	int Data;
	AVLTree left;
	AVLTree right;
	int h;
};

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

int main()
{
	int N,i,V;
	AVLTree T;
	
	scanf("%d",&N);
	scanf("%d",&V);
	T=BuiltTree(V);
	for(i=1;i<N;i++)
	{
		scanf("%d",&V);
		T=Insert(T,V);
	}
	printf("%d\n",T->Data);
	return 0;
}

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

int Geth(AVLTree T)
{
	if(T)
		return T->h;
	else
		return 0;
}

AVLTree BuiltTree(int V)
{
	AVLTree T=(AVLTree)malloc(sizeof(struct AVLNode));
	T->Data =V;
	T->left=NULL;
	T->right=NULL;
	T->h=1;
	return T;
}

AVLTree SingleLeftRotation(AVLTree A)
{
	AVLTree B=A->left;
	A->left=B->right;
	B->right=A;
	A->h=Max(Geth(A->left),Geth(A->right))+1;
	B->h=Max(Geth(B->left),A->h)+1;
	return B;
}

AVLTree SingleRightRotation(AVLTree A)
{
	AVLTree B=A->right;
	A->right=B->left;
	B->left=A;
	A->h=Max(Geth(A->left),Geth(A->right))+1;
	B->h=Max(Geth(B->right),A->h)+1;
	return B;
}

AVLTree DoubleLeftRightRotation(AVLTree A)
{
	A->left=SingleRightRotation(A->left);
	return SingleLeftRotation(A);
}

AVLTree DoubleRightLeftRotation(AVLTree A)
{
	A->right=SingleLeftRotation(A->right);
	return SingleRightRotation(A);
}

AVLTree Insert(AVLTree T,int X)
{
	 if(!T)
	 {
	 	T=BuiltTree(X);
	 }
	 else if(X<T->Data)
	 {
	 	T->left=Insert(T->left,X);
	 	if(Geth(T->left)-Geth(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(Geth(T->left)-Geth(T->right)==-2)
	 		if(X>T->right->Data)
	 			T=SingleRightRotation(T);
	 		else
	 			T=DoubleRightLeftRotation(T);
	 }
	 T->h=Max(Geth(T->left),Geth(T->right))+1;
	 return T;
}