简析平衡树（二）——Treap
前言
学完了替罪羊树，我决定再去学一学 T r e a p Treap Treap。一直听说 T r e a p Treap Treap很难，我也花了挺久才学会。
简介
T r e a p Treap Treap这个名字真的挺有内涵：
T r e e \color{red}{Tree} Tree+ H e a p \color{blue}{Heap} Heap= T r e \color{red}{Tre} Tre+ e a p \color{blue}{eap} eap= T r e a p \color{red}{Tr}\color{purple}{e}\color{blue}{ap} Treap
这很形象地告诉了我们： T r e a p Treap Treap是 T r e e Tree Tree（二叉搜索树）与 H e a p Heap Heap（堆）的结合体，这也是 T r e a p Treap Treap能够平衡的关键。
T r e a p Treap Treap平衡的方法
T r e a p Treap Treap为什么能够平衡？它与普通的 B S T BST BST有什么区别？
主要就在于，它比 B S T BST BST多了一个优先级的设定。
首先， T r e a p Treap Treap的节点是满足 B S T BST BST性质的。其次， T r e a p Treap Treap的每一个节点还有一个优先级，而这些优先级又是满足堆性质的。这就能让 T r e a p Treap Treap的节点保持一种随机的状态，而不会被数据卡成链（当然，脸黑也没办法）。
至于如何让它同时满足 B S T BST BST性质和堆性质，这放在后面再讲。
那么，该怎么确定优先级呢？
很简单，随机即可。
不过，直接用 C + + C++ C++自带的 r a n d ( ) rand() rand()又慢又容易被卡，所以推荐手写 r a n d ( ) rand() rand()，下面的代码仅供参考：
inline int Rand()
{
static ull r=2333;//static不能少，r的初值可以自己定
return (r*=233333)%=2147483647;//每次r乘上的数也可以自己定
}
T r e a p Treap Treap的基础操作
-
旋转
旋转应该是 T r e a p Treap Treap最重要也是最核心的操作了。
T r e a p Treap Treap的旋转分为两种：左旋和右旋。
我们以左旋为例：
如图，是一棵需要左旋的 T r e a p Treap Treap（圆圈中是节点编号而不是节点权值）。
首先，我们把根节点的右儿子改为根节点的右儿子的左儿子（右旋恰好相反）。
然后，再将根节点的右儿子的左儿子改为根节点，然后再将根节点改为原根节点的右儿子即可（右旋刚好相反）。
以上就是 T r e a p Treap Treap的旋转操作了，但是在代码中的操作要略麻烦一点：
inline void Rotate(int &x,int d)//由于左旋和右旋的操作恰好相反，且为了避免写两段代码，我们用d=0表示左旋，d=1表示右旋
{
int k=node[x].Son[d^1];//由于左旋时用根节点的右儿子，右旋时用根节点的左儿子，所以用k存储的要与旋转方向相反
node[x].Son[d^1]=node[k].Son[d],node[k].Son[d]=x,x=k,PushUp(node[x].Son[d]),PushUp(x);//将根的与旋转方向反向的儿子改为k的与旋转方向同向的儿子，然后将k的与旋转方向同向的儿子改为根节点，并将根节点改为k，最后要记得更新节点信息
}
-
插入
T r e a p Treap Treap的插入操作与一般的 B S T BST BST有点像，只不过每次插入后都要比较当前节点与其儿子的优先级，从而决定是否要旋转。
代码如下：
inline void Insert(int &x,int val)//插入操作
{
if(!x) {x=Build(val);return;}//如果当前节点为空，就将元素插入这个节点
++node[x].Size;//将当前元素所在的子树大小加1
if(node[x].Val==val) ++node[x].Cnt;//如果当前元素等于插入元素，就将当前元素的个数加1
else if(node[x].Val>val)//否则如果当前元素大于插入元素
{
Insert(node[x].Son[0],val);//将插入元素插入当前元素的左子树
if(node[x].Data<node[node[x].Son[0]].Data) Rotate(x,1);//如果当前元素左儿子的优先级大于当前节点的优先级，那么就右旋（将左儿子旋到当前节点之上）
}
else//与上面类似
{
Insert(node[x].Son[1],val);
if(node[x].Data<node[node[x].Son[1]].Data) Rotate(x,0);
}
PushUp(x);//最后记得更新当前元素的信息
}
-
删除
删除 T r e a p Treap Treap上的一个元素，我们要分几种情况讨论：
- 若删除元素原本存在多个，则只需将其存在个数减 1 1 1即可。
- 否则，若删除元素没有子节点，则直接将这个元素赋值为 0 0 0即可。
- 否则，若删除元素没有右子节点，或左子节点的优先级高于右子节点，就将以删除元素为根的子树右旋，我们可以发现，此时：原先的左子节点 − − > --> −−>新的根节点，原先的根节点 − − > --> −−>新的右子节点，因此，我们只要继续删除新的右子节点即可。
- 否则，就将以删除元素为根的子树左旋，继续删除新的左子节点即可（与上面类似）。
代码如下：
inline void Delete(int &x,int val)//删除值为val的数
{
if(!x) return;//如果当前节点为空节点，就退出函数
if(node[x].Val==val)//如果当前节点为要删除的节点，那就进行删除操作
{
if(node[x].Cnt>1) {--node[x].Cnt,PushUp(x);return;}//如果删除元素存在多个，就将其个数减1
if(node[x].Son[0]||node[x].Son[1])//如果当前元素有子节点
{
if(!node[x].Son[1]||node[node[x].Son[0]].Data>node[node[x].Son[1]].Data) Rotate(x,1),Delete(node[x].Son[1],val);//若删除元素没有右子节点，或左子节点的优先级高于右子节点，就将以删除元素为根的子树右旋，继续删除新的右子节点
else Rotate(x,0),Delete(node[x].Son[0],val);//否则，就将以删除元素为根的子树左旋，继续删除新的左子节点
}
else x=0;//如果当前元素没有子节点，直接将这个元素赋值为0
}
else if(node[x].Val>val) Delete(node[x].Son[0],val);//如果当前元素大于删除元素，说明删除元素在当前元素的左子树
else Delete(node[x].Son[1],val);//否则说明删除元素在当前元素的右子树
PushUp(x);//最后要记得更新当前节点的信息
}
-
询问
T r e a p Treap Treap的询问操作和普通 B S T BST BST没什么太大的区别，直接贴代码了：
inline int get_rank(int val)//询问值为val的数的排名
{
int x=rt,rk=0;
while(x)//只要当前节点不为空
{
if(node[x].Val==val) return node[node[x].Son[0]].Size+rk+1;//如果当前元素等于val，就可以直接返回答案了
else if(node[x].Val>val) x=node[x].Son[0];//如果当前元素大于v，则说明当前元素的排名大于val，所以访问当前元素的左子树
else rk+=node[node[x].Son[0]].Size+node[x].Cnt,x=node[x].Son[1];//否则，将计数器加上当前元素的排名（不要忘记加上当前元素的存在个数），并访问当前元素的右子树
}
return rk;
}
inline int get_val(int rk)//询问排名为rk的数的值
{
int x=rt;
while(x)//只要当前节点不为空
{
if(node[node[x].Son[0]].Size>=rk) x=node[x].Son[0];//如果当前元素的排名等于rk，则返回该节点的值
else if(node[node[x].Son[0]].Size+node[x].Cnt>=rk) return node[x].Val;//否则，如果当前元素的排名大于rk，访问当前元素的左子树
else rk-=node[node[x].Son[0]].Size+node[x].Cnt,x=node[x].Son[1];//不然，就将rk减去当前元素的排名，访问当前元素的右子树
}
}
inline int get_pre(int val)//询问值为val的数的前驱，也可以用get_val(get_rank(x)-1)，只不过常数大一些
{
int x=rt,pre=0;
while(x)//只要当前节点不为空
{
if(node[x].Val<val) pre=node[x].Val,x=node[x].Son[1];//如果当前元素小于val，就将前驱改为当前元素，并访问当前元素的右子树
else x=node[x].Son[0];//否则，访问当前元素的左子树
}
return pre;
}
inline int get_nxt(int val)//询问值为val的数的后继，也可以用get_val(get_rank(x+1))，只不过常数大一些
{
int x=rt,nxt=0;
while(x)//只要当前节点不为空
{
if(node[x].Val>val) nxt=node[x].Val,x=node[x].Son[0];//如果当前元素大于val，就将后继改为当前元素，并访问当前元素的左子树
else x=node[x].Son[1];//否则，访问当前元素的右子树
}
return nxt;
}
- 最后，还有一个细节：
初始化时要现在平衡树中加入一个极大值和一个极小值，防止越界。
完整代码
讲了这么多，最后来一个模板：（还是以【洛谷3369】【模板】普通平衡树为例吧）
#include