无旋 treap 的操作方式使得它天生支持维护序列、可持久化等特性。
无旋 treap 又称分裂合并 treap。它仅有两种核心操作，即为 分裂 与 合并。通过这两种操作，在很多情况下可以比旋转 treap 更方便的实现别的操作。
变量与宏定义
#define ls ch[u][0]
#define rs ch[u][1]
int cnt, rt, top;
int ch[N][2], siz[N], val[N], pai[N], rub[N];
ls: 左孩子；
rs: 右孩子；
cnt: 计数器；
rt: 根；
top: “垃圾桶”的栈顶
ch: 左右孩子，0 为左孩子，1 为右孩子；
siz: 子树大小；
val: 键值；
pai：随机的值，用于堆排序；
rub: 垃圾桶。
操作
给定一个权值，小于等于该权值的分裂到左边，大于该权值的分裂到右边。
在分裂过程中也要维护二叉搜索树的性质，即当前节点左子树任意一个节点的 val 都小于等于当前节点的 val，右子树任意一个节点的 val 都大于当前节点的 val。
void split1(int u, int c, int &x, int &y) // 按照权值分裂
if (u == 0)
x = y = 0;
return ;
if (val[u] <= c)
x = u;
split1(rs, c, rs, y);
else
y = u;
split1(ls, c, x, ls);
pushup(u);
u: 当前节点；
c: 给定分裂的权值；
x: 要分裂成的左树；
y: 要分裂成的右树。
if (val[u] <= v)
x = u;
split1(rs, c, rs, y);
如果当前节点的 val 小于 \\(c\\)，那么久把当前节点连带它的左子树一起放到 x 上，接下来向右子树搜索，若还有要接到 x 上的节点，就接到 x 的右子树上，以此来维护二叉搜索树的性质。如下图（图片来自 \\(\\textOI wiki\\)）。
pushup(u); 为更新函数，后面会写。
将前 \\(k\\) 个节点分成一棵树，其他节点分成一棵树。
void split2(int u, int k, int &x, int &y) // 按照子树大小分裂
if (u == 0)
x = y = 0;
return ;
pushup(u);
if (siz[ls] + 1 <= k)
x = u;
split2(rs, k - siz[ls] - 1, rs, y);
else
y = u;
split2(ls, k, x, ls);
pushup(u);
if (siz[ls] + 1 <= k)
x = u;
split2(rs, k - siz[ls] - 1, rs, y);
siz[ls] + 1 是当前的节点和它的左子树的总 siz，siz 小于 \\(k\\)，放到左子树，x 变成 rs。
两棵树合并，如果一棵树为空，则直接合并，否则，根据 pai 的大小来判断谁是父节点。
小根堆 pai 小的为父节点，大根堆 pai 大的为父节点。
int merge(int x, int y)
if (!x || !y)
return x + y;
if (pai[x] < pai[y])
ch[x][1] = merge(ch[x][1], y);
pushup(x);
return x;
else
ch[y][0] = merge(x, ch[y][0]);
pushup(y);
return y;
注意，合并时 x 是左树，y 是右树，一定要保证左右顺序！
void pushup(int u)
siz[u] = siz[ls] + siz[rs] + 1;
return ;
这里是删除已知权值的点，若存在多个则只删一个，删除的点将放进“垃圾桶”，当有些节点要创建时先从“垃圾桶”里找可用的点，节省空间。
void del(int c)
int t1, t2, t3;
split1(rt, c, t1, t2);
split1(t1, c - 1, t1, t3);
rub[++ top] = t3;
t3 = merge(ch[t3][0], ch[t3][1]);
rt = merge(merge(t1, t3), t2);
t3 = merge(ch[t3][0], ch[t3][1]);
rt = merge(merge(t1, t3), t2);
由于相同权值的节点只删了一个，t3 可能不为空，所以还要再合并起来.
int New(int c)
int u;
if (!top)
u = ++ cnt;
else
u = rub[top];
top --;
val[u] = c;
siz[u] = 1;
pai[u] = rand();
ls = 0, rs = 0;
return u;
if (!top)
u = ++ cnt;
else
u = rub[top];
top --;
如果“垃圾桶”里还有点，那就将这些点回收利用，否则就开新节点。
先将树按照权值分裂，然后将新节点依次与左树和右树合并，merge 的顺序不要搞反了。
void insert(int c)
int t1, t2;
split1(rt, c, t1, t2);
rt = merge(merge(t1, New(c)), t2);
按照权值分裂，返回 siz[ls] + 1。
int ranking(int c)
int t1, t2, k;
split1(rt, c - 1, t1, t2);
k = siz[t1] + 1;
rt = merge(t1, t2);
return k;
按照子树大小分裂即可
int K_th(int k)
int t1, t2, t3, c;
split2(rt, k, t1, t2);
split2(t1, k - 1, t1, t3);
c = val[t3];
rt = merge(merge(t1, t3), t2);
return c;
int pre(int c)
int t1, t2, t3, k;
split1(rt, c - 1, t1, t2);
split2(t1, siz[t1] - 1, t1, t3);
k = val[t3];
rt = merge(merge(t1, t3), t2);
return k;
int nxt(int c)
int t1, t2, t3, k;
split1(rt, c, t1, t2);
split2(t2, 1, t2, t3);
k = val[t2];
rt = merge(t1, merge(t2, t3));
return k;
由于 FHQ 的核心操作是分裂与合并，所以，不同于 treap，它可以方便的进行区间操作。
模板
struct FHQ
int cnt, rt, top;
int ch[N][2], siz[N], val[N], pai[N], rub[N];
void pushup(int u)
siz[u] = siz[ls] + siz[rs] + 1;
return ;
int New(int c)
int u;
if (!top)
u = ++ cnt;
else
u = rub[top];
top --;
val[u] = c;
siz[u] = 1;
pai[u] = rand();
ls = 0, rs = 0;
return u;
void split1(int u, int c, int &x, int &y) // 按照权值分裂
if (u == 0)
x = y = 0;
return ;
if (val[u] <= c)
x = u;
split1(rs, c, rs, y);
else
y = u;
split1(ls, c, x, ls);
pushup(u);
void split2(int u, int k, int &x, int &y) // 按照子树大小分裂
if (u == 0)
x = y = 0;
return ;
pushup(u);
if (siz[ls] + 1 <= k)
x = u;
split2(rs, k - siz[ls] - 1, rs, y);
else
y = u;
split2(ls, k, x, ls);
pushup(u);
int merge(int x, int y)
if (!x || !y)
return x + y;
if (pai[x] < pai[y])
ch[x][1] = merge(ch[x][1], y);
pushup(x);
return x;
else
ch[y][0] = merge(x, ch[y][0]);
pushup(y);
return y;
void insert(int c)
int t1, t2;
split1(rt, c, t1, t2);
rt = merge(merge(t1, New(c)), t2);
void del(int c)
int t1, t2, t3;
split1(rt, c, t1, t2);
split1(t1, c - 1, t1, t3);
rub[++ top] = t3;
t3 = merge(ch[t3][0], ch[t3][1]);
rt = merge(merge(t1, t3), t2);
int ranking(int c)
int t1, t2, k;
split1(rt, c - 1, t1, t2);
k = siz[t1] + 1;
rt = merge(t1, t2);
return k;
int K_th(int k)
int t1, t2, t3, c;
split2(rt, k, t1, t2);
split2(t1, k - 1, t1, t3);
c = val[t3];
rt = merge(merge(t1, t3), t2);
return c;
int pre(int c)
int t1, t2, t3, k;
split1(rt, c - 1, t1, t2);
split2(t1, siz[t1] - 1, t1, t3);
k = val[t3];
rt = merge(merge(t1, t3), t2);
return k;
int nxt(int c)
int t1, t2, t3, k;
split1(rt, c, t1, t2);
split2(t2, 1, t2, t3);
k = val[t2];
rt = merge(t1, merge(t2, t3));
return k;
;
Treap——大名鼎鼎的随机二叉查找树，以优异的性能和简单的实现在OIer们中广泛流传。
这篇blog介绍一种不需要旋转操作来维护的Treap，即无旋Treap，也称Fhq-Treap。
它的巧妙之处在于只需要分离和合并两种基本操作，就能实现任意的平衡树常用修改操作。
而不需要旋转的特性也使编写代码时不需要考虑多种情况和复杂的父亲儿子关系的更新，同时降低了时间复杂度。
此外，它还可以方便地支持可持久化，实在是功能强大。
接下来系统性地介绍一下无旋Treap的原理和实现，最后讲解一下应用和例题。
一、Treap是啥？
Treap是一棵二叉查找树，满足中序遍历始终是有序的。
Treap的每个节点除了保存信息外，还要保存一个值\(pri\)。
这个\(pri\)存储的是这个节点的优先级。
它是干嘛用的呢？
实际上，Treap除了是一个二叉查找树之外，它在另一个意义下还是一个堆。
每个节点的子节点，一定要满足子节点的\(pri\)比父节点的\(pri\)小。\(pri\)越大的点越往上放。
这有什么意义呢？为什么要这样定义？
事实上，\(pri\)值是程序随机指派的，每个点的\(pri\)值是与这个点的权值无关的，是随机的。
这样随机化就可以保证Treap的深度是\(O(log\;n)\)，这就是随机化的力量。
而且可以保证这样建树一定不会出现矛盾，现在模拟一下建树的过程：
先把所有节点按照中序遍历排好，然后找到其中\(pri\)最大的，把它作为整个Treap的根，左边的节点形成左子树，右边的节点形成右子树。再对左右子树递归处理。
这样最终就能建好一棵Treap。
二、Treap的基本操作
讲完了Treap的定义，来看看Treap的两个基本操作：
分离（Split）和合并（Merge）。
分离：指的是将一棵Treap按照中序遍历的顺序，分割成左右两半，满足左右两半组成的Treap的所有值都不变。
合并：指的是将两棵Treap（一般是从原先的TreapSplit出来的）合并在一起，按照中序遍历的顺序，并且所有节点的值都不变。
Split操作比较简单，先讲讲如何实现：当然，Split之前要先指定一个值k，表示Split出这个Treap的中序遍历中的前k个数作为第一棵Split出的Treap。
从这个Treap的根开始，看它的左子树的大小是否大于等于k，如果是，那么说明右子树和根都在第二棵中，继续递归到左子树中。
如果不是，那么说明左子树和根都在第一棵Treao中，继续递归到右子树中，而且k要减去左子树的大小加一。
代码：
void Split(int rt,int k,int&rt1,int&rt2){
if(!rt) {rt1=rt2=0; return;}
if(k<=siz[ls[rt]]){
Split(ls[rt],k,rt1,rt2);
ls[rt]=rt2;
combine(rt);
rt2=rt;
}
else{
Split(rs[rt],k-siz[ls[rt]]-1,rt1,rt2);
rs[rt]=rt1;
combine(rt);
rt1=rt;
}
}
其中，rt是根，k是分出的第一棵子树的大小，rt1和rt2用来返回。
combine函数用来维护节点的大小。
接下来看Merge操作：
有两棵Treap，假设要把第二棵接到第一棵后面，那么应该怎么合并呢？
考虑两个根节点的\(pri\)值，因为第一棵在第二棵前面，所以要不然rt1(第一棵的根)在rt2(第二棵的根)的左子树，要不然rt2在rt1的右子树。
但是因为有了\(pri\)的影响，所以只能rt1和rt2中\(pri\)较大的那个作为根。
如果rt1为根，那么有rt1的右子树和rt2合并作为rt1的现在的右子树。
如果rt2为根，那么有rt2的左子树和rt1合并作为rt2的现在的左子树。
两种情况都递归进子树中即可。
代码如下：
int Merge(int rt1,int rt2){
if(!rt1) return rt2;
if(!rt2) return rt1;
if(pri[rt1]<pri[rt2]){
rs[rt1]=Merge(rs[rt1],rt2);
combine(rt1);
return rt1;
}
else{
ls[rt2]=Merge(rt1,ls[rt2]);
combine(rt2);
return rt2;
}
}
这就是两种Treap的基本操作，实现时要注意当树为空时，做特殊处理。
三、主要操作
看完了这两种操作，你肯定会问：这有个鬼用？
没法插入删除查询前驱后继排名位置的平衡树，只能分分合合的平衡树，我才不要！
但是，以上的所有操作，其实都能通过这两种基本操作实现：
查询小于等于val的数的个数：考察根节点的值和val，如果val小于根节点，递归进左子树，否则递归进右子树。
这个查询操作命名为Rank，代码：
int Rank(int rt,int v){
if(!rt) return 0;
if(v<val[rt]) return Rank(ls[rt],v);
else return siz[ls[rt]]+Rank(rs[rt],v)+1;
}
插入val：先查询Rank(val)，然后按照rank把整个TreapSplit成两个，把val做成一个新节点，Merge到里面即可。
void Insert(int v){
val[++cnt]=v, pri[cnt]=ran(), siz[cnt]=1;
int rank=Rank(Root,v);
int rt1,rt2;
Split(Root,rank,rt1,rt2);
Root=Merge(Merge(rt1,cnt),rt2);
}
删除val：先查询Rank(val)，然后按照rank把整个TreapSplit成三个，删除需要的点，最后Merge剩下两个。
void Delete(int v){
int rank=Rank(Root,v);
int rt1,rt2,rt3,tmp;
Split(Root,rank,rt1,rt2);
Split(rt1,rank-1,rt3,tmp);
Root=Merge(rt3,rt2);
// Memory Recycle?
}
查询第K个值：把整个TreapSplit成三个，输出需要的值，最后合并起来。
int Kth(int k){
int rt1,rt2,rt3,c;
Split(Root,k,rt1,rt2);
Split(rt1,k-1,rt3,c);
Root=Merge(rt3,Merge(c,rt2));
return val[c];
}
前驱：Kth(Rank(val-1))。
后继：Kth(Rank(val)+1)。
还有很多很多操作，供大家脑补。
四、区间操作
无旋Treap和旋转Treap的更重要区别是，无旋Treap可以很方便地支持区间的操作。
如何支持？你已经看到了，Split操作分理出的就是一个个区间啊！把一整棵Treap分离出来一段区间，在上面尽情地修改吧。不过要记得像线段树写好区间pushdown哦！
比如区间翻转，就是左右子树调换，并且打上标记。区间加减乘除更不用说。
记得在Split，Merge和Rank三个函数内部加上pushdown！
五、实战应用
有很多平衡树的题目，都能用Treap解决。
推荐几道题：
Luogu P3369 测试你的Treap普通操作的熟练程度。
Luogu P3391 区间操作的应用。
Luoge P3165 区间操作和其他技巧。