04-树5 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 the 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

我看网课,的讲义，求height，让我百思不得其解，便索性按照自己心里的想法，编写代码，

果然，出问题了，就17分（25）

哦，原来csdn上，为什么要再插入时进行，因为可以利用递归使子树也规整，我的理想情况是好的，但万一是：

10

10 9 8 7 6 5 4 3 2 1

可就麻瓜了；哈哈，对递归又有了新的理解。

于是我解决了，添加了一个AVL_crue递归函数，上述案例为7，正确答案也为7，反过来也对噢，还是错了！

深度LL旋转是什么牛马啊！！！，还有深度RL旋转！！！

 补得测试样例

19
100 95 105 90 110 85 115 80 120 75 130 70 135 65 125 60 140 55 145
错误答案： 120

正确答案：100

20
10 20 30 40 50 60 70 80 90 100 110 120 130 140 150 160 170 180 190 200

错误答案： 40

正确答案：80

20
200 190 180 170 160 150 140 130 120 110 100 90 80 70 60 50 40 30 20 10

错误答案： 170

正确答案：130

果然，我的AVL_cure函数鲁棒性有点孬。

我去，有什么比手写验证，却出现问题更让人难受的吗！！！，写了半天

哈哈，原来如此，将AVL_Tree函数放Insert_Tree里完美解决了问题，果然不需要height;

测试点	提示	内存(KB)	用时(ms)	结果	得分
0	fig 1 - LL	172	1	答案正确	4 / 4
1	fig 2 - RR	188	1	答案正确	4 / 4
2	fig 3 - RL	376	1	答案正确	4 / 4
3	fig 4 - LR	372	1	答案正确	4 / 4
4	深度LL旋转	372	1	答案正确	4 / 4
5	最大N，深度RL旋转	376	1	答案正确	4 / 4
6	最小N	364	2	答案正确	1 / 1

我的AC 

 祭奠我AVL_crue函数

AVLTree AVL_cure(AT T)
{
	if(T){
		T = AVL_Tree(T);
		AVL_cure(T ->Left);
		AVL_cure(T ->Right);
	}
	return T;
}

#include<stdio.h>
#include<stdlib.h>


typedef struct TNode *AVLTree;
typedef AVLTree AT;
struct TNode{
	int data;
	AVLTree Left;
	AVLTree Right;
};

int Max(int a, int b);
AVLTree Build_Tree(int num);
AVLTree Insert_Tree(AT Tree, int data);
AVLTree Init_Tree(int data);
AVLTree AVL_Tree(AT T);
int Get_height(AT T);
AVLTree AVL_LeftTree(AT T);
AVLTree AVL_RightTree(AT T);
AVLTree AVL_LeftRightTree(AT T);
AVLTree AVL_RightLeftTree(AT T);
int IsNAVL(AT T);
int IsAVL(AT T);
void Free_Tree(AT T);

int main()
{
	AT T;
	int num;
	scanf("%d", &num);
	T = Build_Tree(num);
	printf("%d\n", T ->data);
	Free_Tree(T);
	return 0;
}

AVLTree Build_Tree(int num)
{
	AT T;
	int data;
	T = NULL;
	while(num--){
		scanf("%d", &data);
		T = Insert_Tree(T, data);
	}
	return T;
}
AVLTree Insert_Tree(AT Tree, int data)
{
	if(!Tree){
		Tree = Init_Tree(data);
	}else{
		if(data > Tree ->data){
			Tree ->Right = Insert_Tree(Tree->Right, data);
		}else{
			Tree ->Left = Insert_Tree(Tree->Left, data);
		}
		Tree = AVL_Tree(Tree);
	}
	return Tree;
}
AVLTree Init_Tree(int data)
{
	AT T;
	T = (AT)malloc(sizeof(struct TNode));
	T ->data = data;
	T ->Left = NULL;
	T ->Right = NULL;
	return T;
}

int Get_height(AT T)
{
	if(T){
		return Max(Get_height(T ->Left),Get_height(T ->Right)) + 1;
	}else{
		return 0;
	}
}

int Max(int a, int b)
{
	return a > b ? a : b;
}
int IsNAVL(AT T)
{
	if((Get_height(T ->Left) - Get_height(T ->Right)) == -2){
		return -1;
	}else if((Get_height(T ->Left) - Get_height(T ->Right)) == 2){
		return 1;
	}else{
		return 0;
	}
}
int IsAVL(AT T)
{
	return (Get_height(T ->Left) - Get_height(T ->Right));
}
AVLTree AVL_Tree(AT T)
{
	if(IsNAVL(T) > 0){
		if(IsNAVL(T ->Left) > 0){
			T ->Left = AVL_LeftTree(T ->Left);
		}else if(IsAVL(T ->Left) < 0){
			T = AVL_LeftRightTree(T);
		}else if(!IsNAVL(T ->Left)){
			T = AVL_LeftTree(T);
		}
	}
	else if(IsNAVL(T) < 0){
			if(IsNAVL(T ->Right) < 0){
				T ->Right = AVL_RightTree(T ->Right);
			}else if(IsAVL(T ->Right) > 0){
				T  = AVL_RightLeftTree(T);	
			}else if(!IsNAVL(T ->Right)){
				T = AVL_RightTree(T);
			}
	}
	return T;
}
AVLTree AVL_LeftTree(AT T)
{
	AT B;
	B = T ->Left;
	T ->Left = B ->Right;
	B ->Right = T;
	return B;
}
AVLTree AVL_RightTree(AT T)
{
	AT B;
	B = T ->Right;
	T ->Right = B ->Left;
	B ->Left = T;
	return B;
}
AVLTree AVL_LeftRightTree(AT T)
{
	T ->Left = AVL_RightTree(T ->Left);
	return AVL_LeftTree(T);
}
AVLTree AVL_RightLeftTree(AT T)
{
	T ->Right = AVL_LeftTree(T ->Right);
	return AVL_RightTree(T);
}
void Free_Tree(AT T)
{
	if(T){
		Free_Tree(T ->Left);
		Free_Tree(T ->Right);
		free(T);
	}
}

但是，还是要尝试一下，记录height的情况，理论上可以节约递归时间

当然，或许有疑问，怎么不清理空间呢，我认为可以在不

测试点	提示	内存(KB)	用时(ms)	结果	得分
0	fig 1 - LL	352	1	答案正确	4 / 4
1	fig 2 - RR	368	1	答案正确	4 / 4
2	fig 3 - RL	364	2	答案正确	4 / 4
3	fig 4 - LR	368	1	答案正确	4 / 4
4	深度LL旋转	284	1	答案正确	4 / 4
5	最大N，深度RL旋转	368	2	答案正确	4 / 4
6	最小N	188	1	答案正确	1 / 1

#include<stdio.h>
#include<stdlib.h>

typedef struct TNode *AVLTree;
typedef AVLTree AT;
struct TNode{
	int data;
	int height;
	AVLTree Left;
	AVLTree Right;
};

int Max(int a, int b);
AVLTree Build_Tree(int num);
AVLTree Insert_Tree(AT Tree, int data);
AVLTree Init_Tree(int data);
AVLTree AVL_Tree(AT T);
int Get_height(AT T);
AVLTree AVL_LeftTree(AT T);
AVLTree AVL_RightTree(AT T);
AVLTree AVL_LeftRightTree(AT T);
AVLTree AVL_RightLeftTree(AT T);
int IsAVL(AT T);
int Updata_Tree_height(AT T);
void Free_Tree(AT T);

int main()
{
	AT T;
	int num;
	scanf("%d", &num);
	T = Build_Tree(num);
	printf("%d\n", T ->data);
	Free_Tree(T);
	return 0;
}

AVLTree Build_Tree(int num)
{
	AT T;
	int data;
	T = NULL;
	while(num--){
		scanf("%d", &data);
		T = Insert_Tree(T, data);
	}
	return T;
}
AVLTree Insert_Tree(AT Tree, int data)
{
	if(!Tree){
		Tree = Init_Tree(data);
	}else{
		if(data > Tree ->data){
			Tree ->Right = Insert_Tree(Tree->Right, data);
			if(IsAVL(Tree) == -2)
			{
				if(data > Tree ->Right ->data){
					Tree = AVL_RightTree(Tree);
				}else{
					Tree = AVL_RightLeftTree(Tree);
				}		
			}
		}else{
			Tree ->Left = Insert_Tree(Tree->Left, data);
			if(IsAVL(Tree) == 2)
			{
				if(data <= Tree ->Left ->data){
					Tree = AVL_LeftTree(Tree);
				}else{
					Tree = AVL_LeftRightTree(Tree);
				}		
			}
		}
	}
	Tree ->height = Updata_Tree_height(Tree);
	return Tree;
}
AVLTree Init_Tree(int data)
{
	AT T;
	T = (AT)malloc(sizeof(struct TNode));
	T ->data = data;
	T ->height = 0;
	T ->Left = NULL;
	T ->Right = NULL;
	return T;
}

int Get_height(AT T)
{
	if(T){
		return T ->height;
	}else{
		return 0;
	}
}

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

int IsAVL(AT T)
{
	return (Get_height(T ->Left) - Get_height(T ->Right));
}
int Updata_Tree_height(AT T)
{
	return Max(Get_height(T ->Left) , Get_height(T ->Right)) + 1;
}
AVLTree AVL_LeftTree(AT T)
{
	AT B;
	B = T ->Left;
	T ->Left = B ->Right;
	B ->Right = T;
	T ->height = Updata_Tree_height(T);
	B ->height = Updata_Tree_height(B);
	return B;
}
AVLTree AVL_RightTree(AT T)
{
	AT B;
	B = T ->Right;
	T ->Right = B ->Left;
	B ->Left = T;
	T ->height = Updata_Tree_height(T);
	B ->height = Updata_Tree_height(B);
	return B;
}
AVLTree AVL_LeftRightTree(AT T)
{
	T ->Left = AVL_RightTree(T ->Left);
	return AVL_LeftTree(T);
}
AVLTree AVL_RightLeftTree(AT T)
{
	T ->Right = AVL_LeftTree(T ->Right);
	return AVL_RightTree(T);
}
void Free_Tree(AT T)
{
	if(T){
		Free_Tree(T ->Left);
		Free_Tree(T ->Right);
		free(T);
	}
}