【PAT】1066. Root of AVL Tree (25)

 题目网址： http://pat.zju.edu.cn/contests/pat-a-practise/1066

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树（自平衡二叉查找树）的常规操作，参考  http://www.cnblogs.com/baochuan/archive/2012/10/16/2716641.html 网址。

代码如下：

/*
http://pat.zju.edu.cn/contests/pat-a-practise/1066

AVL树为自平衡二叉查找树。
在AVL树中任何节点的两个子树的高度最大差别为一，所以它也被称为高度平衡树.
*/

#include <iostream>
#include <fstream>

using namespace std;

ifstream fin("in.txt");
#define cin fin 

struct Node
{
	int value;
	Node* leftChild;
	Node* rightChild;
	int height;		//左子树高度 - 右子树高度
	Node(int v):value(v),leftChild(NULL),rightChild(NULL),height(0){}
};

int getHeight(Node* node)
{
	if(node == NULL)return -1;
	return node->height;

}

bool isBalanced(Node* parent)
{
	return abs(getHeight(parent->leftChild) - getHeight(parent->rightChild)) < 2;
}

Node* rotate_LL(Node* parent)
{
	Node* child = parent->leftChild;
	parent->leftChild = child->rightChild;
	child->rightChild = parent;

	parent->height = max(getHeight(parent->leftChild),getHeight(parent->rightChild)) + 1;
	child->height = max(getHeight(child->leftChild),getHeight(child->rightChild)) + 1;
	return child;
}

Node* rotate_RR(Node* parent)
{
	Node* child = parent->rightChild;
	parent->rightChild = child->leftChild;
	child->leftChild = parent;

	parent->height = max(getHeight(parent->leftChild),getHeight(parent->rightChild)) + 1;
	child->height = max(getHeight(child->leftChild),getHeight(child->rightChild)) + 1;
	return child;
}

Node* rotate_LR(Node* parent)
{
	Node* child = parent->leftChild;
    parent->leftChild = rotate_RR(child);
    return rotate_LL(parent);
}

Node* rotate_RL(Node* parent)
{
	Node* child = parent->rightChild;
	parent->rightChild = rotate_LL(child);
	return rotate_RR(parent);
}

Node* InsertNode(Node* root,int newValue)
{
	if(root!=NULL)
	{
		if(newValue > root->value)		//R
		{
			root->rightChild = InsertNode(root->rightChild,newValue);
			if(!isBalanced(root))
			{
				if(newValue > root->rightChild->value)	//R-R
				{
					root = rotate_RR(root);
				}else							//R-L
				{
					root = rotate_RL(root);
				}
			}
		}else							//L
		{
			root->leftChild = InsertNode(root->leftChild,newValue);
			if(!isBalanced(root))
			{
				if(newValue > root->leftChild->value)	//L-R
				{
					root = rotate_LR(root);
				}else							//L-L
				{
					root = rotate_LL(root);
				}
			}
		}
	}else
	{
		root = new Node(newValue);
	}
	root->height = max(getHeight(root->leftChild),getHeight(root->rightChild)) + 1;
	return root;
}

void PrintTree(Node* root)
{
	if(root != NULL)
	{
		cout<<root->value<<"--";
		PrintTree(root->leftChild);
		PrintTree(root->rightChild);
	}
}

int main()
{
	int n;
	cin>>n;

	Node *root = NULL;

	int x;
	int i;
	for(i=0;i<n;i++)
	{
		cin>>x;
		root = InsertNode(root,x);
	}
	cout<<root->value<<endl;
	system("PAUSE");
	return 0;
}