【学校OJ】avl平衡树 普通平衡树

题目描述

你需要写一种数据结构（可参考题目标题），来维护一些数，其中需要提供以下操作：
1. 插入一个整数x
2. 删除一个整数x(若有多个相同的数，只删除一个)
3. 查询整数x的排名(若有多个相同的数，输出最小的排名)，相同的数依次排名，不并列排名
4. 查询排名为x的数，排名的概念同3
5. 求x的前驱(前驱定义为小于x，且最大的数)，保证x有前驱
6. 求x的后继(后继定义为大于x，且最小的数)，保证x有后继

输入

第一行为n，表示操作的个数(n <= 500000)

下面n行每行有两个数opt和x，opt表示操作的序号(1<=opt<=6,   -10^7 <= x <= 10^7)

大规模输入数据，建立读入优化

输出

对于操作3,4,5,6每行输出一个数，表示对应答案

样例输入

Copy (如果复制到控制台无换行，可以先粘贴到文本编辑器，再复制)

8
1 10
1 20
1 30
3 20
4 2
2 10
5 25
6 -1

样例输出

2
20
20
20

    好久没诈尸了，不太爽。所以又来一发。。。

    学了avl平衡树，才懂得了什么叫做200行代码。。。然而平衡树写得也是一道猥琐过一道，那么就选取最经典的普通平衡树作为这次诈尸的工具吧！

    题目与题目描述很直接的告诉了我们——平衡树！所以我们可以很容易分析出实现的方法。

    结构体成员配备：左儿子ls，右儿子rs，数值data，高度h，同样数量sum，总结点size（包括左子树、右子树、自己）

    维护方式：ls、rs用旋转维护，data永不变更，h取ls和rs的最大h加1，sum删除插入时维护。size在各种时候都别忘了用ls的size、rs的size和sum相加进行维护

    1.插入节点。这种简单粗暴的事情还需要说吗？直接进行一般的插入，由于使用惰性删除，所以我们可以遇到相同节点就将sum++，就很容易的解决了！当然你也可以用普通删除然后就保存相同节点啦~

    2.删除节点。你们会插入了还不会删除吗？懒人就用惰性删除，你要是真的喜欢普通删除或者希望能过（是的，惰性删除偏偏在学校OJ上过不了TAT，不过大部分OJ都是可以过的），就使用删除后慢慢转到顶部……

    3.查询数的排名。这就比较简单了，因为数是一定存在的，所以只要找到一个节点，然后比较大小即可。惰性删除很好解决排名问题，如果刚好等于，只需输出最小的即可，即avl[avl[x].ls].size+1，看出来了吗？ls全体比自己小，排名只需加一，如果比自己小就往ls找，大的话就加上ls的size和sum，再往rs找即可。直接删除就方便了，处理方法一模一样，只是找到一样的后要先记录一下，再往ls那边找（因为有可能有重复的）。

    4.查询排名的数。就是3的逆操作，依然是比较ls的size就完了，自己慢慢思考吧……还不需要考虑重复的问题

    5.前驱，后继。由于操作过于相似，可以当成一种来看。

    直接删除：如果遇到一个节点，比较大小，然后很直接地转入ls或rs即可，不需要考虑其他的。

    惰性删除：这就比较麻烦了，如果遇到节点，且sum不为0，那么只需要直接转入ls或rs，因为至少有data比另外一边更接近这个数。但是如果sum为0，就不得不两边兼顾一下，不然很有可能某一边虽然不为空，但可能没有一个符合，现在就只能判断一下是否为空，然后慢慢两边搜……这会浪费一些时间……

    至此，我一句代码也没有给你们，然后将这道题讲完了~当然不能坑你们，代码来了（200行+）~

    

#include<cstdio>
#include<algorithm>
#include<climits>
using namespace std;
const int inf=100000000;
int n,cnt,lmax,rmin,root,ans;
inline int getint()
{
	register int f=1,p=0;
	register char c=getchar();
	while((c<'0'||c>'9')&&c!='-')
		c=getchar();
	if(c=='-')
	{
		f=-1;c=getchar();
	}
	for(;c>='0'&&c<='9';)
	{
		p=p*10+c-'0';
		c=getchar();
	}
	p*=f;
	return p;
}
inline void putint(int p)
{
	if(p<0)
	{
		putchar('-');
		p=-p;
	}
	if(p>9)putint(p/10);
	putchar(p%10+'0');
}
struct avl
{
	int ls,rs,p,h,si,sum;
}d[500005];
inline int zig(int r)
{
	register int t=d[r].ls;
	d[r].ls=d[t].rs;
	d[t].rs=r;
	d[r].h=max(d[d[r].rs].h,d[d[r].ls].h)+1;
    d[t].h=max(d[d[t].rs].h,d[d[t].ls].h)+1;
	d[r].si=d[d[r].ls].si+d[d[r].rs].si+d[r].sum;
	d[t].si=d[d[t].ls].si+d[d[t].rs].si+d[r].sum;
	return t;
}
inline int zag(int r)
{
	register int t=d[r].rs;
	d[r].rs=d[t].ls;
	d[t].ls=r;
	d[r].h=max(d[d[r].rs].h,d[d[r].ls].h)+1;
    d[t].h=max(d[d[t].rs].h,d[d[t].ls].h)+1;
	d[r].si=d[d[r].ls].si+d[d[r].rs].si+d[r].sum;
	d[t].si=d[d[t].ls].si+d[d[t].rs].si+d[r].sum;
	return t;
}
inline int zigzag(int r)
{
	d[r].rs=zig(d[r].rs);
	r=zag(r);
	return r;
}
inline int zagzig(int r)
{
	d[r].ls=zag(d[r].ls);
	r=zig(r);
	return r;
}
inline void move(int &q)
{
	if(d[d[q].ls].h-d[d[q].rs].h==2)
	{
		register int t=d[q].ls;
		if(d[d[t].ls].h>d[d[t].rs].h)
			q=zig(q);
		else
			q=zagzig(q);
	}
	else
	{
		if(d[d[q].ls].h-d[d[q].rs].h==-2)
		{
			register int t=d[q].rs;
			if(d[d[t].rs].h>d[d[t].ls].h)
				q=zag(q);
			else
				q=zigzag(q);
		}
	}
	d[q].si=d[d[q].ls].si+d[d[q].rs].si+d[q].sum;
	d[q].h=max(d[d[q].ls].h,d[d[q].rs].h)+1;
}
inline void insert(int a,int &q)
{
	if(q==0)
	{
		q=++cnt;
		d[q].p=a;
		d[q].h=1;
		d[q].si=1;
		d[q].sum=1;
		return;
	}
	if(d[q].p==a)
		d[q].sum++;
	else
	{
		if(d[q].p>a)
			insert(a,d[q].ls);
		else
			insert(a,d[q].rs);
	}
	move(q);
}
inline void dele(int a,int q)
{
	if(q==0)return;
	if(d[q].p==a)
		d[q].sum--;
	else
	{
		if(a<d[q].p)
			dele(a,d[q].ls);
		else
			dele(a,d[q].rs);
	}
	d[q].si=d[d[q].ls].si+d[d[q].rs].si+d[q].sum;
}
inline int find(int k,int q)
{
	if(q==0)return inf;
	register int l=d[q].sum;
	if(k>=d[d[q].ls].si+1&&k<=d[d[q].ls].si+l)return d[q].p;
	else
	{
		if(k<d[d[q].ls].si+1)return find(k,d[q].ls);
		else return find(k-d[d[q].ls].si-l,d[q].rs);
	}
}
inline int ask(int k,int q)
{
	if(q==0)return inf;
	if(d[q].p==k)
		return d[d[q].ls].si+1;
	else
	{
		if(k<d[q].p)
			return ask(k,d[q].ls);
		else
			return ask(k,d[q].rs)+d[d[q].ls].si+d[q].sum;
	}
}
inline void left(int x,int q)
{
	if(q==0)return;
	if(d[q].p<x)
	{
		if(d[q].sum)
			lmax=max(lmax,d[q].p);
		else
			left(x,d[q].ls);
		if(d[d[q].rs].si)
			left(x,d[q].rs);
	}
	else
		left(x,d[q].ls);
}
inline void right(int x,int q)
{
	if(q==0)return;
	if(d[q].p>x)
	{
		if(d[q].sum)
			rmin=min(rmin,d[q].p);
		else
			right(x,d[q].rs);
		if(d[d[q].ls].si)
			right(x,d[q].ls);
	}
	else
		right(x,d[q].rs);
}
int main()
{
	n=getint();
	for(int i=1;i<=n;i++)
	{
		register int opt,p;
		opt=getint();p=getint();
		if(opt==1)
		{
			insert(p,root);
			continue;
		}
		if(opt==2)
		{
			dele(p,root);
			continue;
		}
		if(opt==3)
		{
			ans=ask(p,root);
			putint(ans);
		}
		if(opt==4)
		{
			ans=find(p,root);
			putint(ans);
		}
		if(opt==5)
		{
			lmax=-inf;
			left(p,root);
			putint(lmax);
		}
		if(opt==6)
		{
			rmin=inf;
			right(p,root);
			putint(rmin);
		}
		putchar('\n');
	}
}

    我不会说这段代码是会超时的……