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

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

原题链接：

https://www.patest.cn/contests/pat-a-practise/1066

https://www.nowcoder.com/pat/5/problem/4117

思路：

比较裸的平衡树。（却写的晕头转向。。菜鸡。。）

针对四种情况，做四种不同的旋转

CODE：

#include<iostream>
#define max(a, b) (((a) > (b)) ? (a) : (b))
using namespace std;
typedef struct S
{
	int v;
	int ls,rs;	
	int ll,rl;
};
S T[25];
int rro(int a)
{
	int oa=a, ob=T[a].ls;
	int va=T[a].v;
	int sal=T[a].ls, sar=T[a].rs;
	int lal=T[a].ll, lar=T[a].rl;
	int vb=T[ob].v;
	int sbl=T[ob].ls, sbr=T[ob].rs;
	int lbl=T[ob].ll, lbr=T[ob].rl;
	{
		T[oa].v=vb;
		T[oa].ls=sbl;	T[oa].rs=ob;
		T[oa].ll=lbl;	T[oa].rl=1+max(lar,lbr);
		T[ob].v=va;
		T[ob].ls=sbr;	T[ob].rs=sar;
		T[ob].ll=lbr;	T[ob].rl=lar;
	}
	return max(T[a].ll,T[a].rl)+1;
}
int lro(int a)
{
	int oa=a, ob=T[a].rs;
	int va=T[a].v;
	int sal=T[a].ls, sar=T[a].rs;
	int lal=T[a].ll, lar=T[a].rl;
	int vb=T[ob].v;
	int sbl=T[ob].ls, sbr=T[ob].rs;
	int lbl=T[ob].ll, lbr=T[ob].rl;
	{
		T[oa].v=vb;
		T[oa].rs=sbr;	T[oa].ls=ob;
		T[oa].rl=lbr;	T[oa].ll=1+max(lal,lbl);
		T[ob].v=va;		
		T[ob].ls=sal;	T[ob].rs=sbl;
		T[ob].ll=lal;	T[ob].rl=lbl;
	}
	return max(T[a].ll,T[a].rl)+1;
}

int ins(int a,int b)
{
	if (T[b].v>T[a].v)
	{
		if (T[a].rs!=-1)
		 	T[a].rl=ins(T[a].rs,b);
		else
		{
			T[a].rs=b;
			T[a].rl=1;
		}
	}
	else
	{
		if (T[a].ls!=-1)
		 	T[a].ll=ins(T[a].ls,b);
		else
		{
			T[a].ls=b;
			T[a].ll=1;
		}
	}
	if (T[a].ll-T[a].rl>1)
	{
		if (T[T[a].ls].ll>T[T[a].ls].rl)
		{
			return rro(a);
		}
		else
		{
			T[a].ll=lro(T[a].ls);
			return rro(a);
		}
	}
	else if (T[a].ll-T[a].rl<-1)
	{
		if (T[T[a].rs].ll>T[T[a].rs].rl)
		{
			T[a].rl=rro(T[a].rs);
			return lro(a); 
		}
		else
			return lro(a);
	}
	else
		return max(T[a].ll,T[a].rl)+1;
}
int main()
{
	int n;
	cin>>n;
	int head=-1;
	for (int i=0;i<n;i++)
	{
		cin>>T[i].v;
		T[i].ls=T[i].rs=-1;
		T[i].ll=T[i].rl=0;
		if (head==-1) 	head=i;
		else 	ins(head,i);
	}
	cout<<T[head].v;	
	return 0; 
}