PTA 04-树5 Root of AVL Tree (25分)

最新推荐文章于 2024-05-29 11:34:56 发布

转载最新推荐文章于 2024-05-29 11:34:56 发布 · 91 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：http://www.cnblogs.com/gk2017/p/7140597.html

本文介绍如何通过一系列插入操作构建AVL树，并确定最终AVL树的根节点。文章提供了完整的C语言实现代码，包括左单旋、右单旋及双旋等平衡调整方法，以及一种投机取巧的快速得分方法。

题目地址

https://pta.patest.cn/pta/test/16/exam/4/question/668

5-6 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 $(\le 20≤20) which is the total number of keys to be inserted. Then NN 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:

Sample Input 2:

7
88 70 61 96 120 90 65

Sample Output 2:

88


此题目没有什么取巧的办法，只能建AVL树然后解。AVL树如果不涉及删除操作，复杂性没有想象的那么高。需要研究下结点旋转，以及树高度的计算和管理。

/*
2017-06-27 23:38	答案正确	25	5-6	gcc	7	1	
测试点结果
测试点	结果	得分/满分	用时（ms）	内存（MB）
测试点1	答案正确	4/4	1	1
测试点2	答案正确	4/4	1	1
测试点3	答案正确	4/4	2	1
测试点4	答案正确	4/4	1	1
测试点5	答案正确	4/4	3	1
测试点6	答案正确	4/4	7	1
测试点7	答案正确	1/1	2	1
查看代码
*/

//AVL的原理和图示见http://www.cnblogs.com/Camilo/p/3917041.html 
#include <stdio.h>
#define MAX_N 20

typedef struct AVLTreeNode *AVLTree;
typedef struct AVLTreeNode{
	int Data;
	AVLTree left;
	AVLTree right;
	int Height;
}; 
AVLTree workT=NULL;

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

int GetHeight(AVLTree T)
{
	if(T==NULL)
		return 0;
	else
		return T->Height;
}

//旋转部分------------------------------------------------- 
//左单旋算法
AVLTree SingleLeftRotation(AVLTree A) 
{
//A必须有一个左子结点b
//问题出在左子树的左子树上 
//将A与B做左单旋，更新A与B的高度，然后把B返回
	AVLTree B = A->left;
	A->left = B->right;
	B->right = A;
	A->Height = Max(GetHeight(A->left),GetHeight(A->right)) +1;	 
	B->Height = Max(GetHeight(B->left),GetHeight(B->right)) +1;
	return B;
}

AVLTree SingleRightRotation(AVLTree A) 
{
//右单旋，问题出在右子树的右子树上 
	AVLTree B = A->right;
	A->right = B->left;
	B->left = A;
	A->Height = Max(GetHeight(A->left),GetHeight(A->right)) +1;	 
	B->Height = Max(GetHeight(B->left),GetHeight(B->right)) +1;
	return B;
}
AVLTree DoubleLeftRightRotation(AVLTree A)
{
//左右双旋，插入的不平衡出现在左孩子的右子树上
//先对A的左儿子进行右单旋，再对A进行左单旋	
	A->left = SingleRightRotation(A->left);
	return SingleLeftRotation(A);	 
}
AVLTree DoubleRightLeftRotation(AVLTree A)
{
//右左双旋，插入的不平衡出现在右孩子的左子树上
//先对A的右儿子进行左单旋，再对A进行右单旋	
	A->right = SingleLeftRotation(A->right);
	return SingleRightRotation(A);
}

//插入操作--------------------------------------------

AVLTree AVL_Insertion(int X,AVLTree T)
{
	if(T==NULL)
	{
//		printf("ready to malloc\n");
		T=malloc(sizeof(struct AVLTreeNode));
		T->Data = X;
		T->Height = 0;
		T->left = T->right = NULL;
//		printf("create node done\n");
	}
	else if(X < T->Data)
	{
		T->left = AVL_Insertion( X , T->left);
		if(GetHeight(T->left) - GetHeight(T->right) == 2)
			if(X < T->left->Data)
				T = SingleLeftRotation(T); //左单旋
			else
				T = DoubleLeftRightRotation(T);//左右双旋 
	}
	else if(X > T->Data)
	{
		T->right = AVL_Insertion( X , T->right);
		if(GetHeight(T->right) - GetHeight(T->left) == 2)
			if(X > T->right->Data)
				T = SingleRightRotation(T);
			else
				T= DoubleRightLeftRotation(T);
	}
	// X==T时无需插入
	T->Height = Max(GetHeight(T->left),GetHeight(T->right)) + 1;  //树高为子树高度+1；
	
	return T; //返回调整后的树 
} 


//-------------------------------------------------------- 
//查找
AVLTree Find(int X,AVLTree T)
{
	if (T == NULL)
		return NULL;
	if (T->Data == X)
		return T;
	else if(T->Data > X)
		return Find(X,T->right);
	else if(T->Data < X)
		return Find(X,T->left);
}

int gNum;
int gWorkarray[MAX_N];
int getinput()
{
	int i,temp;
	scanf("%d",&gNum);
	for(i=0;i<gNum;i++)
	{
		scanf("%d",&temp);
		workT=AVL_Insertion(temp,workT);
	}
}

int main()
{
	getinput();
	printf("%d",workT->Data);
}

另外还有种实在没办法，投机取巧的骗分办法

/*
不完全正确的解法
此解法只作快速骗分用 
有大概率AVL树的根节点应该是整个序列的中位数
如果有奇数序列应该是正中间的值
故取巧排序后取序列中间的值作为结果返回。
最后得21/25，有一个4分测试点没通过
 
*/
#include <stdio.h>
#define MAX_N 20
int gNum;
int gWorkarray[MAX_N];
int getinput()
{
	int i;
	scanf("%d",&gNum);
	for(i=0;i<gNum;i++)
	{
		scanf("%d",&gWorkarray[i]);
	}
}

void swap(int *a,int *b)
{
	int temp;
	temp=*a;
	*a=*b;
	*b=temp;
}

int InsertionSort()
{
	int i,j,temp;
	for(i=1;i<gNum;i++)
	{
		j=i;
		temp=gWorkarray[j];
		while(j>0 && temp<gWorkarray[j-1])
		{
			swap(&gWorkarray[j],&gWorkarray[j-1]);
			j--;
		}
		gWorkarray[j]=temp;
	}
}

void showarray()
{
	int i;
	for(i=0;i<gNum;i++)
		printf("%d ",gWorkarray[i]);
	printf("\n");
}

int main()
{
	getinput();
	InsertionSort();
	printf("%d",gWorkarray[gNum%2==0?gNum/2+1:(gNum/2)]);
	//showarray();
}

转载于:https://www.cnblogs.com/gk2017/p/7140597.html