PAT(甲级)1066

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

#include <iostream>

using namespace std;
//try to use non-recurrsive way to calculate the node height next time
struct Node{
	Node(int v):value(v),height(0),left(NULL),right(NULL){}
	Node():value(),height(0),left(NULL),right(NULL){}
	
	int value;
	int height;
	Node *left;
	Node *right;
};

int Getheight(Node *pnode){
	if(pnode == NULL)
	    return 0;
	else
	    return pnode->height;
}

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

Node * SingleRotateLeft(Node *k1){
	Node *k2 = k1->left;
	k1->left = k2->right;
	k2->right = k1;
	
	k2->height = maxheight(Getheight(k2->left),Getheight(k2->right)) +1;
	k1->height = maxheight(Getheight(k1->left),Getheight(k1->right)) +1;
	return k2;
}

Node *SingleRotateRight(Node *k1){
	Node *k2 = k1->right;
	k1->right = k2->left;
	k2->left = k1;
	
	k2->height = maxheight(Getheight(k2->left),Getheight(k2->right)) +1;
	k1->height = maxheight(Getheight(k1->left),Getheight(k1->right)) +1;
	return k2;	
}

Node *DoubleRotateLeft(Node *k1){
	k1->left = SingleRotateRight(k1->left);
	return SingleRotateLeft(k1);
}

Node *DoubleRotateRight(Node *k1){
	k1->right = SingleRotateLeft(k1->right);
	return SingleRotateRight(k1);
}

bool checkbalance(Node *proot){
	int diff = Getheight(proot->left) - Getheight(proot->right);
    if(diff <2 && diff >-2)
        return true;
    return false;
}

Node * Insert(int value,Node *root){
	if(root ==NULL){
		root = new Node(value);
	}else if(value < root->value){
		root->left = Insert(value,root->left);
		if(!checkbalance(root)){
			if(value < root->left->value)
			    root = SingleRotateLeft(root);
			else
			    root = DoubleRotateLeft(root);
		}
	}else{
		root->right = Insert(value,root->right);
		if(!checkbalance(root)){
			if(value > root->right->value)
			    root = SingleRotateRight(root);
			else
			    root = DoubleRotateRight(root);
		}		
	}
	root->height =  maxheight(Getheight(root->left),Getheight(root->right)) +1;
	
	return root;
}

int main()
{
	int number;
	Node *root;
//	freopen("test.txt","r",stdin);
	scanf("%d",&number);
	for(int i=0;i<number;i++){
		int value;
		scanf("%d",&value);
		root = Insert(value,root);
	}
	
	cout <<root->value <<endl;
	
	return 0;
}