专题学习——平衡树

这里着重讲解旋转treap（虽然旋转treap可以被splay和非旋treap代替而它本身并没有什么明显的优势，让我严重怀疑自己学了个没用的东西）

Treap也是一种平衡树，它在普通二叉查找树的基础上，给每个结点多赋予了一个属性：优先级。对于Treap中的每个结点，除了它的权值满足二叉查找树的性质外，它的优先级还满足堆性质，也就是结点的优先级小于它所有孩子的优先级。
换句话说，从权值上看，Treap是一个二叉查找树；从优先级上看，Treap是一个堆。所以我们发现Treap其实可以看做是Tree+Heap。

我们发现普通BST会不平衡是因为有序的数据会使查找路径退化成链，而随机数据使其退化的概率非常小。因此我们在Treap中赋予的这个优先级的值采用随机生成的办法，这样Treap的结构就趋于平衡了。

为了使Treap满足性质，有时我们不可避免地要对结构进行调整，而我们调整的方式是旋转。在维护Treap的过程中，我们会出现两种旋转：左旋与右旋。
左旋一个子树，这个子树的根节点为x，则旋转后会把x变为这个子树的新根的左儿子，x的右儿子会成为子树新的根。
右旋一个子树，这个子树的根节点为x，则旋转后会把x变为这个子树的新根的右儿子，x的右儿子会成为子树新的根。
显然旋转后这个Treap仍然满足权值的BST性质，因此这个旋转操作就保证了，若我们满足了BST性质，那么不满足堆性质的部分我们可以通过旋转，使其满足堆性质。旋转的意义也正是在此，使不满足堆序的两个节点通过调整位置，重新满足堆序，而不改变BST性质。

变量声明：l：左儿子编号，r：右儿子编号，dat：优先级，cnt：节点值数目，
size：子树大小，val：节点的值

接下来介绍操作：
新建节点操作New：

int New(int val)
{
	a[++tot].val=val;
	a[tot].dat=rand();  //用rand（）更新优先级
	a[tot].cnt=a[tot].size=1;
	return tot;
}

更新操作update：将节点的size更新为左右儿子的size及它自己的cnt的和

void update(int p) {a[p].size=a[a[p].l].size+a[a[p].r].size+a[p].cnt;}

初始化操作build

void build()
{
	New(-INF);New(INF);
	root=1;a[1].r=2;
	update(root);
}

操作后可以得到这样一棵初始树：

查询数值的排名：Kth
一个值的排名就是它的左子树的size+1
往右子树查询的时候要记录下左子树的size，因为右子树的节点都比左子树的大

int Kth(int p,int val)
{
	if(p==0) return 0;//空节点
	if(val==a[p].val) return a[a[p].l].size+1; //找到
	if(val<a[p].val) return Kth(a[p].l,val);//往左查
	return Kth(a[p].r,val)+a[a[p].l].size+a[p].cnt; //往右查
}

时刻记住treap的节点的左子树里的节点编号都小于它，右子树里的节点编号都大于它。所以我们在查询节点的时候可以判断一下，若查询值大于当前节点就往右子树走，反之则往左子树走，走到空节点时就返回0。

查询排名的数值：getit
和上面的类似，用size表示排名

int getit(int p,int rank)
{
	if(p==0) return INF;
	if(a[a[p].l].size>=rank) return getit(a[p].l,rank); //左子树的节点数比rank大，说明当前节点的rank比要查询的大
	if(a[a[p].l].size+a[p].cnt>=rank) return a[p].val;//没有执行上一条语句说明左子树的节点数比rank小，若加上cnt后等于rank或比rank大说明找到了
	return getit(a[p].r,rank-a[a[p].l].size-a[p].cnt);//往右边找，要减去比查询值小的节点数
}

左旋和右旋：zag，zig
旋转在上面讲解过了，不明白可以画图理解一下

void zig(int &p)
{
	int q=a[p].l;
	a[p].l=a[q].r,a[q].r=p,p=q;
	update(a[p].r),update(p);
}

void zag(int &p)
{
	int q=a[p].r;
	a[p].r=a[q].l,a[q].l=p,p=q;
	update(a[p].l),update(p);
}

注意要update

插入操作：insert

void insert(int &p,int val)
{
	if(p==0) //空节点，直接插入
	{
		p=New(val);
		return;
	}
	if(val==a[p].val) //存在值相等的节点，cnt++
	{
		a[p].cnt++,update(p);
		return;	
	}
	if(val<a[p].val) //往左走
	{
		insert(a[p].l,val);
		if(a[p].dat<a[a[p].l].dat) zig(p);  //右旋调整
	}
	else //往右走
	{
		insert(a[p].r,val);
		if(a[p].dat<a[a[p].r].dat) zag(p); //左旋调整
	}
	update(p);
}

删除操作：remove

void remove(int &p,int val)
{
	if(p==0) return; //空节点
	if(val==a[p].val) //有值相同的节点
	{
		if(a[p].cnt>1) //有多个值
		{
			a[p].cnt--;update(p);
			return;
		}
		if(a[p].l || a[p].r)
		{
			//比较优先级，然后调整
			if(a[p].r==0 || a[a[p].l].dat>a[a[p].r].dat) zig(p),remove(a[p].r,val);
			else zag(p),remove(a[p].l,val);
			update(p);
		}
		else p=0;
		return;
	}
	val<a[p].val?remove(a[p].l,val):remove(a[p].r,val); //递归remove
	update(p);
}

求前驱：getpre

int getpre(int val)
{
	int ans=1;
	int p=root;
	while(p)
	{
		if(val==a[p].val) 找到val
		{
			if(a[p].l>0) //有左子树
			{
				p=a[p].l;
				while(a[p].r>0) p=a[p].r;//不断往右边找，最后就会找到一个最大的小于val的值
				ans=p;//更新答案
			}
			break;
		}
		if(a[p].val<val && a[p].val>a[ans].val) ans=p; //更新一下
		p=val<a[p].val?a[p].l:a[p].r;//往左（右）走
	}
	return a[ans].val;
}

求后继：getnext
和求前驱类似

int getnext(int val)
{
	int ans=2;
	int p=root;
	while(p)
	{
		if(val==a[p].val)
		{
			if(a[p].r>0) 
			{
				p=a[p].r;
				while(a[p].l>0) p=a[p].l;
				ans=p;
			}
			break;
		}
		if(a[p].val>val && a[p].val<a[ans].val) ans=p;
		p=val<a[p].val?a[p].l:a[p].r;
	}
	return a[ans].val;
}

例题：普通平衡树（BZOJ3224）
Description
您需要写一种数据结构（可参考题目标题），来维护一些数，其中需要提供以下操作：

1. 插入x数
2. 删除x数(若有多个相同的数，因只删除一个)
3. 查询x数的排名(若有多个相同的数，因输出最小的排名)
4. 查询排名为x的数
5. 求x的前驱(前驱定义为小于x，且最大的数)
6. 求x的后继(后继定义为大于x，且最小的数)

Input
第一行为n，表示操作的个数,下面n行每行有两个数opt和x，opt表示操作的序号(1<=opt<=6)

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

Sample Input
10

1 106465

4 1

1 317721

1 460929

1 644985

1 84185

1 89851

6 81968

1 492737

5 493598

Sample Output
106465

84185

492737

HINT
1.n的数据范围：n<=100000

2.每个数的数据范围：[-2e9,2e9]

代码：（将上面的所有操作合并）

#include<bits/stdc++.h>
using namespace std;
const int N=100005;
struct treap
{
	int l,r;
	int val,dat;
	int cnt,size;
}a[N];
int tot,root,n,INF=0x7fffffff;

int New(int val)
{
	a[++tot].val=val;
	a[tot].dat=rand();
	a[tot].cnt=a[tot].size=1;
	return tot;
}

void update(int p) {a[p].size=a[a[p].l].size+a[a[p].r].size+a[p].cnt;}

void build()
{
	New(-INF);New(INF);
	root=1;a[1].r=2;
	update(root);
}

int Kth(int p,int val)
{
	if(p==0) return 0;
	if(val==a[p].val) return a[a[p].l].size+1;
	if(val<a[p].val) return Kth(a[p].l,val);
	return Kth(a[p].r,val)+a[a[p].l].size+a[p].cnt;
}

int getit(int p,int rank)
{
	if(p==0) return INF;
	if(a[a[p].l].size>=rank) return getit(a[p].l,rank);
	if(a[a[p].l].size+a[p].cnt>=rank) return a[p].val;
	return getit(a[p].r,rank-a[a[p].l].size-a[p].cnt);
}

void zig(int &p)
{
	int q=a[p].l;
	a[p].l=a[q].r,a[q].r=p,p=q;
	update(a[p].r),update(p);
}

void zag(int &p)
{
	int q=a[p].r;
	a[p].r=a[q].l,a[q].l=p,p=q;
	update(a[p].l),update(p);
}

void insert(int &p,int val)
{
	if(p==0)
	{
		p=New(val);
		return;
	}
	if(val==a[p].val)
	{
		a[p].cnt++,update(p);
		return;	
	}
	if(val<a[p].val)
	{
		insert(a[p].l,val);
		if(a[p].dat<a[a[p].l].dat) zig(p);
	}
	else
	{
		insert(a[p].r,val);
		if(a[p].dat<a[a[p].r].dat) zag(p);
	}
	update(p);
}

int getpre(int val)
{
	int ans=1;
	int p=root;
	while(p)
	{
		if(val==a[p].val)
		{
			if(a[p].l>0) 
			{
				p=a[p].l;
				while(a[p].r>0) p=a[p].r;
				ans=p;
			}
			break;
		}
		if(a[p].val<val && a[p].val>a[ans].val) ans=p;
		p=val<a[p].val?a[p].l:a[p].r;
	}
	return a[ans].val;
}

int getnext(int val)
{
	int ans=2;
	int p=root;
	while(p)
	{
		if(val==a[p].val)
		{
			if(a[p].r>0) 
			{
				p=a[p].r;
				while(a[p].l>0) p=a[p].l;
				ans=p;
			}
			break;
		}
		if(a[p].val>val && a[p].val<a[ans].val) ans=p;
		p=val<a[p].val?a[p].l:a[p].r;
	}
	return a[ans].val;
}

void remove(int &p,int val)
{
	if(p==0) return;
	if(val==a[p].val)
	{
		if(a[p].cnt>1)
		{
			a[p].cnt--;update(p);
			return;
		}
		if(a[p].l || a[p].r)
		{
			if(a[p].r==0 || a[a[p].l].dat>a[a[p].r].dat) zig(p),remove(a[p].r,val);
			else zag(p),remove(a[p].l,val);
			update(p);
		}
		else p=0;
		return;
	}
	val<a[p].val?remove(a[p].l,val):remove(a[p].r,val);
	update(p);
}

int main()
{
	build();
	cin>>n;
	while(n--)
	{
		int op,x;
		scanf("%d%d",&op,&x);
		switch(op)
		{
			case 1:
				insert(root,x);
				break;
			case 2:
				remove(root,x);
				break;
			case 3:
				printf("%d\n",Kth(root,x)-1);
				break;
			case 4:
				printf("%d\n",getit(root,x+1));
				break;
			case 5:
				printf("%d\n",getpre(x));
				break;
			case 6:
				printf("%d\n",getnext(x));
				break;
		}
	}
	return 0;
}