前言
你并不需要先学习Treap!
引入
例题:(洛谷 P3369 【模板】普通平衡树)
您需要写一种数据结构,来维护一些数,其中需要提供以下操作:
1.插入 x x x 数
2.删除 x x x 数(若有多个相同的数,因只删除一个)
3.查询 x x x 数的排名(排名定义为比当前数小的数的个数 + 1 +1 +1 )
4.查询排名为 x x x 的数
5.求 x x x 的前驱(前驱定义为小于 x x x,且最大的数)
6.求 x x x 的后继(后继定义为大于 x x x,且最小的数)
一般的平衡树都会有烦人的旋转操作,不好写也不好调。那么,有没有什么不需要旋转的平衡树呢?
那就是无旋Treap,因为是fhq发明的,所以又叫fhq Treap。
它有什么好处呢?
一、不用旋转
二、代码简短,好写好调
三、效率较高
四、支持可持久化
Update 2022.1.27:实测fhq Treap比Splay效率高
fhq Treap
相比于有旋Treap和Splay等平衡树,它的操作十分简洁,核心的操作只有两个: s p l i t split split(分裂)和 m e r g e merge merge(合并)。
节点
对于每一个节点,我们要储存以下信息:
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 分裂,意思是说要把值小于等于 k k k 的节点分到一个树里,值大于 k k k 的分到另一棵树里。为了方便,我们将第一棵树称为A树,第二棵树称为B树。
当我们根据 k k k 分裂一棵树(子树)时,有以下几种情况:
- 根的值小于等于 k k k,这时左子树全部小于等于 k k k,右子树不一定。所以左子树和根一定属于A树,右子树可能有一部分属于A树,一部分属于B树。这时我们将当前树的根作为A树的根,然后根据 k k k 分裂右子树。
- 根的值大于 k k k,同理,将当前树的根作为B树的根,然后根据 k k 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 k 需要几步?只要三步:
第一步:把树扯开。
第二步:把 k 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 k k 的扯出去
第三步:把等于 k k k 的树的根挤出去
第四步:把小于 k k 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 k-1 k−1 分裂,A树的 s i z e size size 就是小于 k k k 的数的个数,排名就是 s i z e + 1 size+1 size+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 k-1 k−1 分裂,然后找A树内的最大值(即在A树内查询排名为 s i z e size size 的数值)。
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 k k 分裂,然后找B树内的最小值(即在B树内查询排名为 1 1 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;
}