PAT 数据结构 04-树4. 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树失去平衡，分别为左子树外侧，左子树内侧，右子树外侧，右子树内侧；外侧的情况比较简单，对根结点一次单旋转即可使树平衡，内侧的情况需要两次单旋转，首先将与根结点的值最接近的结点旋转为根结点的子结点，然后对根节点进行一次单旋转。

   创建树时使用递归找到插入点，然后判断AVL树是否失去平衡（左右子树的高度差变为2），若失衡，则从插入点递归返回二级或三级父结点会检测到，判断是四种情况中的哪种，并作相应处理。
/*2015.7.11*/
#include <iostream>
#include <vector>
using namespace std;
//Tree-04 AVL Tree
struct TNode{
	int val;
	TNode* left;
	TNode* right;
	TNode(int x):val(x),left(nullptr),right(nullptr){}
};
int height(TNode *&root){
	if(root==nullptr)
		return 0;
	else
		return max(height(root->left),height(root->right))+1;
}
TNode* singleRotateWithLeft(TNode* &root){//左外侧太深，单旋转
	TNode* tmp=root->left;
	root->left=tmp->right;
	tmp->right=root;
	return tmp;
}
TNode* singleRotateWithRight(TNode* &root){
	TNode* tmp=root->right;
	root->right=tmp->left;
	tmp->left=root;
	return tmp;
}
TNode* doubleRotateWithLeft(TNode* &root){//左内侧太深，双旋转
	root->left=singleRotateWithRight(root->left);
	return singleRotateWithLeft(root);
}
TNode* doubleRotateWithRight(TNode* &root){
	root->right=singleRotateWithLeft(root->right);
	return singleRotateWithRight(root);
}
TNode* insert(TNode *root,int x){
	if(root==nullptr){
		root=new TNode(x);
	}else if(x< root->val){
		root->left=insert(root->left,x);
		if(height(root->left)-height(root->right)==2){
			if(x< root->left->val)
				root=singleRotateWithLeft(root);
			else
				root=doubleRotateWithLeft(root);
		}
	}else{
		root->right=insert(root->right,x);
		if(height(root->right)-height(root->left)==2){
			if(x> root->right->val)
				root=singleRotateWithRight(root);
			else
				root=doubleRotateWithRight(root);
		}
	}
	return root;
}
/* test rotate
void preCreateTree(TNode *&root,int *&p){
	if(*p==0){
		root=nullptr;
		p++;
	}else{
		root=new TNode(*p);
		p++;
		preCreateTree(root->left,p);
		preCreateTree(root->right,p);
	}
}
void preorder(TNode *&root){
	if(root!=nullptr){
		cout<<root->val<<endl;
		preorder(root->left);
		preorder(root->right);
	}
}*/
int main(){
	int N;
	cin>>N;
	int x;
	TNode *root=nullptr;
	while(N--){
		cin>>x;
		root=insert(root,x);
	}
	cout<<root->val<<endl;
	/* test rotate
	int a[]={4,2,1,0,0,3,0,0,6,5,0,0,7,0,0};
	int *p=a;
	TNode* root;
	preCreateTree(root,p);
	root=singleRotateWithLeft(root);
	preorder(root);
	root->right=singleRotateWithRight(root->right);
	preorder(root);
	root=doubleRotateWithRight(root);
	preorder(root);*/
	return 0;
}