1066. 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. 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 ythe 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

avl树的基本操作。

#include <iostream>
using namespace std;
inline int MAX(int x,int y){return x > y ? x : y;}
struct avl_node
{
	int key;
	avl_node * left;
	avl_node * right;
	int height;
	avl_node(int k,avl_node * l=NULL,avl_node * r = NULL,int h = 0):key(k),left(l),right(r),height(h){}
	//h in single node is defined as 1 and that in NULL node defined as -1
};
inline int height(avl_node * node){return node == NULL?-1:node->height;}
void rotate_left_chiled(avl_node * & root)
{
	avl_node  * tmp=root->left;
	root->left=tmp->right;
	tmp->right=root;
	tmp->height=MAX(height(tmp->left),height(tmp->right))+1;
	root->height=MAX(height(root->left),height(root->right))+1;
	root=tmp;
}
void rotate_right_chiled(avl_node * & root)
{
	avl_node * tmp=root->right;
	root->right = tmp->left;
	tmp->left=root;
	tmp->height=MAX(height(tmp->left),height(tmp->right))+1;
	root->height=MAX(height(root->left),height(root->right))+1;
	root=tmp;
}
void double_rotate_left(avl_node * & root)
{
	rotate_right_chiled(root->left);
	rotate_left_chiled(root);
}
void double_rotate_right(avl_node * & root)
{
	rotate_left_chiled(root->right);
	rotate_right_chiled(root);
}
void insert(avl_node * & root,int key)
{
	if( root == NULL )
	{
		root = new avl_node(key);
	}
	else
	{
		if(key < root -> key)
		{
			insert(root->left,key);
			if(height(root->left) - height(root->right) == 2)
			{
				if(key < root->left->key)
					rotate_left_chiled(root);
				else
					double_rotate_left(root);
			}
		}
		else
		{
			insert(root->right,key);
			if(height(root->right)-height(root->left) == 2)
			{
				if(key>root->right->key)
					rotate_right_chiled(root);
				else
					double_rotate_right(root);
			}
		}
	}
	root->height=MAX(height(root->left),height(root->right))+1;
}
int main()
{
	int n;
	cin>>n;
	avl_node * root;
	for(int i=0;i<n;i++)
	{
		int node;
		cin>>node;
		insert(root,node);
	}
	cout<<root->key;
	return 0;
}