Treap
前置芝士
二叉搜索树(BST),见 BST。
平衡二叉树(AVL)。
先来介绍一下平衡二叉树。
背景
BST 出现以后,人们很快发现一个问题,当其维护一个有序序列时,很可能会退化成链。如图:
这样的话,原来 \(O(\log{n})\) 的复杂度就退化为 \(O(n)\),这是我们无法接受的,于是平衡二叉树横空出世。
定义
平衡二叉树:左右子树的高度相差不超过 1 的 BST(可以为空树)。平衡,顾名思义,就是要求左右子树的高度相近。
下面给出一些图,请判断是否为平衡二叉树:
显然,只有第二棵树是平衡二叉树,第一棵树节点 5 左右子树不平衡,第三棵树不是 BST。
基础知识
treap,就是"树堆",由树和堆组成,是一种入门级的平衡二叉树,操作较多,码量较大,但比较基础,好理解。
\[Treap=tree+heap \]
二叉搜索树(BST)对于一个序列来说不唯一,也就是说,在满足"BST性质"的前提下,中序遍历为相同序列的 BST 不唯一。因此,在 BST 的基础上加上二叉堆,来保证平衡性。用来维护 BST 的值为"关键码",维护堆的值为权值,权值是随机产生的,避免退化。维护堆性质的操作为"旋转"。Treap 是一种通过适当的旋转,在维持节点关键码满足 BST 性质的同时,还使每个节点上随机生成的权值满足二叉堆的性质的平衡二叉树。 各个操作时间复杂度为 \(O(\log{n})\)。
基本操作有:
- 插入一个数 \(x\)。
- 删除一个数 \(x\)(若有多个相同的数,应只删除一个)。
- 定义排名 为比当前数小的数的个数 \(+1\)。查询 \(x\) 的排名。
- 查询数据结构中排名为 \(x\) 的数。
- 求 \(x\) 的前驱(前驱定义为小于 \(x\),且最大的数)。
- 求 \(x\) 的后继(后继定义为大于 \(x\),且最小的数)。
操作
建树
与 BST 相同,建立一棵空树,不过我们需要储存更多的信息,size 为以该节点为根的子树大小,cnt 表示序列中该关键字的个数,pushup 和线段树的一样,更新父亲的信息。
cpp
const int N=1e5+5,inf=1<<30;
struct treap
{
int l,r;
int key,dat;//关键字,附加权值
int size,cnt;//子树大小,副本数
}a[N];
int tot,root,n,m;
int New(int k)
{
a[++tot].key=v;
a[tot].dat=rand();
a[tot].cnt=a[tot].size=1;
return tot;
}
void pushup(int u)
{
a[u].size=a[a[u].l].size+a[a[u].r].size+a[u].cnt;
}
void build()
{
New(-inf),New(inf);
root=1,a[root].r=2;
}
旋转
旋转是 Treap 的基本操作,分为左旋和右旋。如图:
- 右旋:把父亲变为左儿子的右儿子。
- 左旋:把父亲变为右儿子的左儿子。
如图,对于黑色节点来说,左边右旋后,该节点的左子树节点数减一,右子树加一,右边左旋后,该节点的左子树节点树加一,右子树减一。也就是说对于一个节点右旋,会增加右子树的节点数,左旋会增加左子树的节点数,利用左旋和右旋我们就可以维护二叉平衡树。
以右旋为例,将 \(y\) 变为 \(x\) 的右儿子,对于 \(x\) 左儿子不变,右儿子变为 \(y\),这样 \(y\) 的左儿子就空出来了,刚好可以把 \(x\) 的右子树 \(B\) 接上去。具体:\(y\) 的左子树变为 \(B\),\(x\) 的右儿子变为 \(y\),\(x\) 代替 \(y\) 原来的位置。
左旋同理:
cpp
void zig(int &u)//右旋
{
int q=a[u].l;
a[u].l=a[q].r,a[q].r=u,u=q;
pushup(a[u].r),pushup(u);
}
void zag(int &u)//左旋
{
int q=a[u].r;
a[u].r=a[q].l,a[q].l=u,u=q;
pushup(a[u].l),pushup(u);
}
当权值不满足大根堆(小也可)性质时,交换父亲和儿子,这样就能使 BST 更平衡。
注意要用 &
,这样的话会一起更新它父亲的信息,可以认为,\(q\) 完全代替了 \(u\)。
插入
将 \(key\) 为 \(v\) 的数插入到平衡树中,若原本已经存在,则直接找到位置将 \(cnt\) 加上 1。若不存在,则需将这个数插入到叶子节点,一直向下走直到找到要插入的位置,插入后判断是否满足大根堆性质,进行旋转来维护。
cpp
void insert(int &u,int v)
{
if(u==0) u=New(v);//u指向新的节点
else if(a[u].key==v) a[u].cnt++;
else if(a[u].key>v)
{
insert(a[u].l,v);
if(a[u].dat<a[a[u].l].dat) zig(u);//不满足大根堆,交换左儿子和父亲
}
else
{
insert(a[u].r,v);
if(a[u].dat<a[a[u].r].dat) zag(u);//不满足大根堆,交换右儿子和父亲
}
pushup(u);
}
删除
将 \(key\) 为 \(v\) 的数从平衡树中删除,与插入类似,先要找到该节点。若该节点的 \(cnt\) 大于 1,直接减去 1 即可。若小于 1,考虑如何删除,如果该点是叶子节点那就好办了,直接用 0 代替,但如果不是,我们也不能直接删,要通过不断地旋转把它变成叶子节点,具体看代码,自己手推一遍就理解了。
cpp
void remove(int &u,int v)
{
if(u==0) return;//没有这个数
if(a[u].key==v)
{
if(a[u].cnt>1) a[u].cnt--;
else if(a[u].l&&a[u].r)//非叶子节点
{
//保证旋转过后能满足大根堆的性质,哪个大就把哪个作为父亲
if(a[u].r==0||a[a[u].l].dat>a[a[u].r].dat) zig(u),remove(a[u].r,v);//右旋后父亲变为右儿子
else zag(u),remove(a[u].l,v)
}
else u=0;
}
else a[u].key>v ? remove(a[u].l,v) : remove(a[u].r,v);//一直往下走
pushup(u);
}
查排名
\(v\) 的排名为小于它的个数 \(+1\)。考虑 BST 中,比当前节点小的点应该全部位于左子树,因此排名就是左子树的大小 \(+1\)。所以先找到该值,再算个数。考虑如何从根节点往下走:
- \(key==v\),说明已找到,直接返回左子树的大小加 1。
- \(key>v\),则需往左子树走。
- \(key<v\),则需往右子树走,同时加上左子树大小和该节点副本数。
- \(u==0\),说明树中不存在 \(v\) 的节点,直接加 1。
需要在递归出口加上 1。
cpp
int get_rank(int u,int v)
{
if(u==0) return 1;
if(a[u].key==v) return a[a[u].l].size+1;
if(a[u].key>v) return get_rank(a[u].l,v);
return get_rank(a[u].r,v)+a[a[u].l].size+a[u].cnt;
}
查值
已知排名为 \(k\),查询具体的值。大同小异:
- 若左子树大小大于等于 \(k\),说明 \(k\) 在左子树,往左子树走。
- 若 \(k\) 大于左子树大小且小于左子树大小加副本数,说明该节点就是答案。
- 若 \(k\) 大于左子树大小加副本数,说明在右子树,往右子树继续找。
cpp
int get_val(int u,int k)
{
if(a[a[u].l].size>=k) return get_val(a[u].l,k);
if(a[a[u].l].size+a[u].cnt>=k) return a[u].key;
return get_val(a[u].r,k-a[a[u].l].size-a[u].cnt);//减去比k小的值的个数
}
查前驱/后继
前驱定义为小于 \(x\),且最大的数,后继定义为大于 \(x\),且最小的数。
以前驱为例,一直往下走,不满足 \(key<x\) 则往左子树走,否则开始找最大值。
cpp
int get_pre(int u,int v)
{
if(u==0) return -inf;
if(a[u].key>=v) return get_pre(a[u].l,v);
return max(a[u].key,get_pre(a[u].r,v));
}
int get_ne(int u,int v)
{
if(u==0) return inf;
if(a[u].key<=v) return get_ne(a[u].r,v);
return min(a[u].key,get_ne(a[u].l,v));
}
P3369 【模板】普通平衡树
分析
将以上讲的所有操作结合在一起就好了,注意细节。
code
cpp
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define lc a[u].l
#define rc a[u].r
#define val a[u].key
const int N=1e5+5,inf=1<<30;
struct treap
{
int l,r;
int key,dat;
int size,cnt;
}a[N];
int tot,root,n,m;
int New(int v)
{
a[++tot].key=v;
a[tot].dat=rand();
a[tot].cnt=a[tot].size=1;
return tot;
}
void pushup(int u)
{
a[u].size=a[lc].size+a[rc].size+a[u].cnt;
}
void build()
{
New(-inf),New(inf);
root=1,a[root].r=2;
}
void zig(int &u)//右旋
{
int q=lc;
lc=a[q].r,a[q].r=u,u=q;
pushup(rc),pushup(u);
}
void zag(int &u)//左旋
{
int q=rc;
rc=a[q].l,a[q].l=u,u=q;
pushup(lc),pushup(u);
}
void insert(int &u,int v)
{
if(u==0) u=New(v);
else if(val==v) a[u].cnt++;
else if(val>v)
{
insert(lc,v);
if(a[lc].dat>a[u].dat) zig(u);//不满足大根堆,交换左儿子和父亲
}
else
{
insert(rc,v);
if(a[rc].dat>a[u].dat) zag(u);//交换右儿子
}
pushup(u);
}
void remove(int &u,int v)
{
if(u==0) return ;
if(val==v)
{
if(a[u].cnt>1) a[u].cnt--;
else if(lc||rc) //有叶子节点
{
//保证旋转过后能满足大根堆的性质,哪个大就把哪个作为父亲
if(rc==0||a[lc].dat>a[rc].dat) zig(u),remove(rc,v);//右旋后父亲变为右儿子
else zag(u),remove(lc,v);
pushup(u);
}
else u=0;
}
else val>v ? remove(lc,v) : remove(rc,v);
pushup(u);
}
int get_rank(int u,int v)
{
if(u==0) return 1;
if(val==v) return a[lc].size+1;
if(val>v) return get_rank(lc,v);
return get_rank(rc,v)+a[lc].size+a[u].cnt;
}
int get_val(int u,int k)
{
if(a[lc].size>=k) return get_val(lc,k);
if(a[lc].size+a[u].cnt>=k) return val;
return get_val(rc,k-a[lc].size-a[u].cnt);
}
int get_pre(int u,int v)
{
if(u==0) return -inf;
if(val>=v) return get_pre(lc,v);
return max(val,get_pre(rc,v));
}
int get_ne(int u,int v)
{
if(u==0) return inf;
if(val<=v) return get_ne(rc,v);
return min(val,get_ne(lc,v));
}
int main ()
{
cin>>m;
build();
for(int op,x;m--;)
{
cin>>op>>x;
if(op==1) insert(root,x);
else if(op==2) remove(root,x);
else if(op==3) cout<<get_rank(root,x)-1<<"\n";//减去-inf的点
else if(op==4) cout<<get_val(root,x+1)<<"\n";//存在-inf
else if(op==5) cout<<get_pre(root,x)<<"\n";
else cout<<get_ne(root,x)<<"\n";
}
return 0;
}
结语
有了 Treap,时间复杂度不会退化了,但是------这代码也太长了。而 FHQ_Treap 和 Splay 就会更好 QAQ。