PAT 1066. Root of AVL Tree (25)

1066. Root of AVL Tree (25)

时间限制

100 ms

内存限制

65536 kB

代码长度限制

16000 B

判题程序

Standard

作者

CHEN, Yue

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 tree的insert操作，代码如下：

#include <iostream>
#include <algorithm>
#include <cmath>
#include <vector>
#include <cstring>
using namespace std;
typedef struct nodes{
	int element;
	int height;
	nodes* leftchild;
	nodes* rightchild;
	nodes(){
		leftchild=NULL;
		rightchild=NULL;
		height=0;
	}
}nodes;

int getheight(nodes* x)
{
	if(x==NULL)
		return -1;
	else
		return x->height;
}
nodes* LLrotation(nodes* x)
{
	nodes* left=x->leftchild;
	x->leftchild=left->rightchild;
	left->rightchild=x;
	x->height=max(getheight(x->leftchild),getheight(x->rightchild))+1;
	left->height=max(getheight(left->leftchild),getheight(left->rightchild))+1;
	return left;
}
nodes* RRrotation(nodes* x)
{
	nodes* right=x->rightchild;
	x->rightchild=right->leftchild;
	right->leftchild=x;
	x->height=max(getheight(x->leftchild),getheight(x->rightchild))+1;
	right->height=max(getheight(right->leftchild),getheight(right->rightchild))+1;
	return right;
}
nodes* LRrotation(nodes* x)
{
	nodes* left=x->leftchild;
	x->leftchild=RRrotation(left);
	return LLrotation(x);
}
nodes* RLrotation(nodes* x)
{
	nodes* right=x->rightchild;
	x->rightchild=LLrotation(right);
	return RRrotation(x);
}


nodes* insertNode(nodes* target,int node)
{
	if(target==NULL)
	{
		target=new nodes;
		target->element=node;
	}	
	else if(node<target->element)
	{
		target->leftchild=insertNode(target->leftchild,node);
		int left=getheight(target->leftchild);
		int right=getheight(target->rightchild);
		if(left-right>1)
		{
			if(node<target->leftchild->element)
				target=LLrotation(target);
			else
				target=LRrotation(target);	
		}
		else
			target->height=max(left,right)+1;
	}
	else
	{
		target->rightchild=insertNode(target->rightchild,node);
		int left=getheight(target->leftchild);
		int right=getheight(target->rightchild);
		if(left-right<-1)
		{
			if(node<target->rightchild->element)
				target=RLrotation(target);
			else
				target=RRrotation(target);
		}
		else
			target->height=max(left,right)+1;
	}
	return target;
}
int main(void)
{
	int N;
	cin>>N;
	nodes* root=NULL;
	while(N--)
	{
		int node;
		cin>>node;
		root=insertNode(root,node);
	}
	cout<<root->element;
}