平衡树详解（fhq Treap）

Wu_while

已于 2022-07-30 11:34:02 修改

阅读量1.3k

点赞数 4

分类专栏：数据结构文章标签：数据结构

于 2022-01-25 10:45:17 首次发布

本文链接：https://blog.youkuaiyun.com/Wu_while/article/details/122678485

版权

数据结构专栏收录该内容

10 篇文章

订阅专栏

前言

你并不需要先学习Treap！

引入

例题：（洛谷 P3369 【模板】普通平衡树）

您需要写一种数据结构，来维护一些数，其中需要提供以下操作：
1.插入 $x$ 数
2.删除 $x$ 数(若有多个相同的数，因只删除一个)
3.查询 $x$ 数的排名(排名定义为比当前数小的数的个数 $+ 1$ )
4.查询排名为 $x$ 的数
5.求 $x$ 的前驱(前驱定义为小于 $x$ ，且最大的数)
6.求 $x$ 的后继(后继定义为大于 $x$ ，且最小的数)

一般的平衡树都会有烦人的旋转操作，不好写也不好调。那么，有没有什么不需要旋转的平衡树呢？

那就是无旋Treap，因为是fhq发明的，所以又叫fhq Treap。

它有什么好处呢？

一、不用旋转
二、代码简短，好写好调
三、效率较高
四、支持可持久化
Update 2022.1.27：实测fhq Treap比Splay效率高

fhq Treap

相比于有旋Treap和Splay等平衡树，它的操作十分简洁，核心的操作只有两个： $s pl i t$ （分裂）和 $m er g e$ （合并）。

节点

对于每一个节点，我们要储存以下信息：

int ch[2];//左右儿子
int val;//值
int pri;//随机优先级
int size;//子树大小

别的都好理解，这个随机优先级又是什么呢？这个疑惑先留一下，继续往下看……

基操

void maintain(int x)//维护节点信息
{
	t[x].size=t[t[x].ch[0]].size+t[t[x].ch[1]].size+1;//需要注意的是，和Splay不同，fhq Treap的每个节点只储存一个值，所以只需+1
}//也就是说，可能有多个节点储存的值相同
int new_node(int x)//新建节点，为了方便，这里包装成了一个独立的函数
{
	t[++tot].size=1;
	t[tot].val=x;
	t[tot].pri=rand();//随机优先级
	return tot;
}

原来随机优先级就真的是随机的啊！请继续往下看……

分裂

对于一颗树（子树），我们要把它根据 $k$ 分裂，意思是说要把值小于等于 $k$ 的节点分到一个树里，值大于 $k$ 的分到另一棵树里。为了方便，我们将第一棵树称为A树，第二棵树称为B树。

当我们根据 $k$ 分裂一棵树（子树）时，有以下几种情况：

根的值小于等于 $k$ ，这时左子树全部小于等于 $k$ ，右子树不一定。所以左子树和根一定属于A树，右子树可能有一部分属于A树，一部分属于B树。这时我们将当前树的根作为A树的根，然后根据 $k$ 分裂右子树。
根的值大于 $k$ ，同理，将当前树的根作为B树的根，然后根据 $k$ 分裂左子树。

void split(int cur,int k,int &x,int &y)//x和y是传址调用，x表示A树根，y表示B树根
{
	if(!cur)//分裂到头了
		x=y=0;
	else
	{
		if(t[cur].val<=k)
		{
			x=cur;
			split(t[cur].ch[1],k,t[cur].ch[1],y);
		}
		else
		{
			y=cur;
			split(t[cur].ch[0],k,x,t[cur].ch[0]);
		}
		maintain(cur);//顺便维护一下
	}
}

合并

就是把两棵树合成一棵，而仍然满足平衡树的性质。

我们仍然将小的一棵称为A树，将大的一棵称为B树。我们可以肯定，A树上的值都小于B树上的值，那么，我们就有了两种选择。要么将A树合并到B树的左子树，要么将B树合并到A树的右子树。我们该如何决定呢？

另外，我们还需要注意，我们不仅要维护BST的性质，我们还要维护平衡树特有的性质：平衡。

想好了么？答案是……

随机决定！

既然要维护平衡，也就是让整棵树趋向于随机，那么随机合并自然是最好的选择QωQ。

那就要用到我们的随机优先级了。见代码：

int merge(int x,int y)//返回值是合并后树的根
{
	if(!x||!y)//如果其中一个为空就直接返回另一个
		return x+y;
	if(t[x].pri<t[y].pri)//随机优先级决定合并方式
	{
		t[x].ch[1]=merge(t[x].ch[1],y);//B树合并到A树的右子树
		maintain(x);
		return x;
	}
	else
	{
		t[y].ch[0]=merge(x,t[y].ch[0]);//A树合并到B树的左子树
		maintain(y);
		return y;
	}
}

这样，最核心的两个操作我们就已经完成了。现在我们要使用它们了！

插入

和旋转平衡树不同，只要掌握了分裂和合并的操作，剩下的就无比简单了。

请问插入一个数 $k$ 需要几步？只要三步：

第一步：把树扯开。

第二步：把 $k$ 放进去。

第三步：把树合并。

void insert(int k)
{
	int x,y;//用来存储分裂后的两个根
	split(root,k,x,y);//根据k分裂
	root=merge(merge(x,new_node(k)),y);//将A树与k合并，再将合并后的树与B树合并
}

删除

这个稍微麻烦一点——多了一步：

第一步：把小于等于 $k$ 的树扯出来

第二步：从小于等于 $k$ 的树里把小于 $k$ 的扯出去

第三步：把等于 $k$ 的树的根挤出去

第四步：把小于 $k$ 的、等于 $k$ 的、大于 $k$ 的全部粘回去

有点难理解？打个比喻，你现在有一个纸条：
在这里插入图片描述
上边有两个红点：

你想把一个红点截掉，你应该怎么做？

先把红点右边截下来：
在这里插入图片描述

再把左边截下来：

在这里插入图片描述

把红点截去一个：
在这里插入图片描述
把左右粘起来：

在这里插入图片描述

好像很智障的样子……

void del(int k)
{
	int x,y,z;//x存小于k的，y存等于k的，z存大于k的
	split(root,k,x,z);//根据k分裂，x就是小于等于k的，z就是大于k的
	split(x,k-1,x,y);//把x根据k-1分裂，x就是小于k的，y就是等于k的
	y=merge(t[y].ch[0],t[y].ch[1]);//将y的左右子树合并，把根挤出去
	root=merge(merge(x,y),z);//合起来
}

查询排名

这个简单，根据 $k - 1$ 分裂，A树的 $s i ze$ 就是小于 $k$ 的数的个数，排名就是 $s i ze + 1$ 。

int rnk(int k)
{
	int x,y,ans;
	split(root,k-1,x,y);//根据k-1分裂
	ans=t[x].size+1;
	root=merge(x,y);
	return ans;
}

查询数值

很抱歉，fhq Treap对于这个并没有什么特殊的方法，所以这个操作与其他平衡树一样。

int kth(int cur,int k)
{
	while(1)
	{
		if(k<=t[t[cur].ch[0]].size)
			cur=t[cur].ch[0];
		else
		{
			k-=t[t[cur].ch[0]].size+1;
			if(k<=0)
				return cur;
			cur=t[cur].ch[1];
		}
	}
}

前驱和后继

查询前驱只需根据 $k - 1$ 分裂，然后找A树内的最大值（即在A树内查询排名为 $s i ze$ 的数值）。

int pre(int k)
{
	int x,y,ans;
	split(root,k-1,x,y);
	ans=t[kth(x,t[x].size)].val;
	root=merge(x,y);
	return ans;
}

查询后继同理，根据 $k$ 分裂，然后找B树内的最小值（即在B树内查询排名为 $1$ 的数值）。

int nxt(int k)
{
	int x,y,ans;
	split(root,k,x,y);
	ans=t[kth(y,1)].val;
	root=merge(x,y);
	return ans;
}

总结

其实只要掌握了分裂和合并，其他的就很暴力了……

注意事项：

分裂和合并注意维护节点信息
分裂时别写嗨了忘了合并回去
写挂了优先找分裂和合并的锅

代码

#include<iostream>
#include<cstdio>
#include<ctime>
#include<cstdlib>
#define MAXN 100010
using namespace std;
struct fhq_Treap
{
	int ch[2];
	int val;
	int pri;
	int size;
}
t[MAXN];
int tot,root;
int new_node(int x)
{
	t[++tot].size=1;
	t[tot].val=x;
	t[tot].pri=rand();
	return tot;
}
void maintain(int x)
{
	t[x].size=t[t[x].ch[0]].size+t[t[x].ch[1]].size+1;
}
void split(int cur,int k,int &x,int &y)
{
	if(!cur)
		x=y=0;
	else
	{
		if(t[cur].val<=k)
		{
			x=cur;
			split(t[cur].ch[1],k,t[cur].ch[1],y);
		}
		else
		{
			y=cur;
			split(t[cur].ch[0],k,x,t[cur].ch[0]);
		}
		maintain(cur);
	}
}
int merge(int x,int y)
{
	if(!x||!y)
		return x+y;
	if(t[x].pri<t[y].pri)
	{
		t[x].ch[1]=merge(t[x].ch[1],y);
		maintain(x);
		return x;
	}
	else
	{
		t[y].ch[0]=merge(x,t[y].ch[0]);
		maintain(y);
		return y;
	}
}
void insert(int k)
{
	int x,y;
	split(root,k,x,y);
	root=merge(merge(x,new_node(k)),y);
}
void del(int k)
{
	int x,y,z;
	split(root,k,x,z);
	split(x,k-1,x,y);
	y=merge(t[y].ch[0],t[y].ch[1]);
	root=merge(merge(x,y),z);
}
int rnk(int k)
{
	int x,y,ans;
	split(root,k-1,x,y);
	ans=t[x].size+1;
	root=merge(x,y);
	return ans;
}
int kth(int cur,int k)
{
	while(1)
	{
		if(k<=t[t[cur].ch[0]].size)
			cur=t[cur].ch[0];
		else
		{
			k-=t[t[cur].ch[0]].size+1;
			if(k<=0)
				return cur;
			cur=t[cur].ch[1];
		}
	}
}
int pre(int k)
{
	int x,y,ans;
	split(root,k-1,x,y);
	ans=t[kth(x,t[x].size)].val;
	root=merge(x,y);
	return ans;
}
int nxt(int k)
{
	int x,y,ans;
	split(root,k,x,y);
	ans=t[kth(y,1)].val;
	root=merge(x,y);
	return ans;
}
int n,op,x;
int main()
{
	srand(time(0));
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
	{
		scanf("%d%d",&op,&x);
		if(op==1)
			insert(x);
		else if(op==2)
			del(x);
		else if(op==3)
			printf("%d\n",rnk(x));
		else if(op==4)
			printf("%d\n",t[kth(root,x)].val);
		else if(op==5)
			printf("%d\n",pre(x));
		else
			printf("%d\n",nxt(x));
	}
	return 0;
}