前置芝士
熟练掌握二叉查找（排序）树的插入、删除、求排名、求某一排名的数、求前驱、求后继等操作。
引言
二叉查找树看似可以在 \(O(logn)\) 中完成任意上述操作。但若该二叉查找树退化为如下形态：
此时，在此图上操作的时间复杂度仍为 \(O(n)\)。
观察可知：二叉查找树的最优形态是平衡树，故需要一种能维持树的平衡形态的二叉查找树。
正文
Treap又名树堆，是一种利用随机性来维持二叉查找树的平衡形态的树（相较于Splay，方便且暴力许多）。
学习Treap，首先需要了解Treap的特色旋转操作（与Splay的旋转有一定差别）。旋转操作在Treap中主要用于在不破坏二叉查找树的性质（左子树比根小，右子树比根大）的情况下，对元素的位置进行挪动。根据所需旋转的节点属于其父亲节点的左子树和右子树，可分为左旋和右旋。
旋转
如图，假设我们要将B点挪到现A点的位置，一种很自然的思路是将图整体像右移动：C点移至原B点位置、B点移至原A点位置、A点移至原E点位置、E点移至原E点右儿子位置。
但此时会出现一个问题，如图：
B点有两个右儿子：A、D，故需要将一个右儿子移至他处。发现A点没有左儿子，所以可将D点改为A点的左儿子。
操作完成后可发现，子树的二叉查找性并没有受到破坏，所以旋转可以随意在二叉查找树中使用。
因为该操作的过程类似旋转，并且方向为顺时针，故称其为右旋。
左旋与右旋类似，故在此不赘述。
GIF来自https://www.cnblogs.com/lazy-people/p/9326556.html
这两张动图可以更方便读者理解“旋转”操作的过程。
代码
void rotate (int &x, int d) {
int t = sons[x][d ^ 1];
sons[x][d ^ 1] = sons[t][d];
sons[t][d] = x;
pushup (x);
pushup (t);
x = t;
return ;
}
插入节点
Treap的插入操作与普通的二叉查找树如出一辙，但是为了保持平衡，每个节点会有一个随机值来保证图的形态的随机性。
操作步骤
1、从根节点开始递归；
2、如果当前节点的值等于需插入的值，则将该节点的数值数量和该节点的子树的节点数+1；
3、如果当前节点的值大于需插入的值，则在当前节点的左儿子中继续2、3两步；如果当前节点的值小于需插入的值，则在当前节点的右儿子中继续2、3两步。操作完成后，若子节点的随机值大于当前节点的随机值，则将当前节点向下旋转；
4、如果当前节点为空节点，则在当前节点中建立新的节点，并赋予新节点一个随机值；
代码
void ins (int &p, int x) {
if (!p) {
p = ++ cnt;
siz[p] = num[p] = 1;
val[p] = x;
rd[p] = rand ();
return ;
}
if (val[p] == x) {
num[p] ++;
siz[p] ++;
return ;
}
int d = (x > val[p]);
ins (sons[p][d], x);
if (rd[p] < rd[sons[p][d]])
rotate (p, d ^ 1);
pushup (p);
return ;
}
删除节点
删除操作和插入节点的区别在于，需要分类讨论需删除的节点的状态（左儿子存在与否、右儿子存在与否）。
情况一：左儿子右儿子都不存在
因为叶子节点的存在不会影响整树的平衡，所以此时可以直接删除该节点；
情况二：左儿子存在、右儿子不存在
若直接删除节点，有可能影响树的平衡性，所以将当前节点向左儿子旋转；
情况三：左儿子不存在，右儿子存在
与情况二大同小异，差别是要将当前节点向右儿子旋转；
情况四：左儿子存在，右儿子存在
此时需要选择旋转左旋还是右旋。显然，若进行左/右旋，则左/右儿子会更替当前节点的位置。故为了维持树的随机性，需要将左儿子和右儿子中随机值大的点向上旋转；
点的遍历操作与插入节点的遍历如出一辙，此处不再赘述。
代码
void del (int &p, int x) {
if (!p)
return ;
if (x < val[p])
del (sons[p][0], x);
else if (x > val[p])
del (sons[p][1], x);
else {
if (!sons[p][0] && !sons[p][1]) {
num[p] --;
siz[p] --;
if (num[p] == 0)
p = 0;
}
else if (sons[p][0] && !sons[p][1]) {
rotate (p, 1);
del (sons[p][1], x);
}
else if (!sons[p][0] && sons[p][1]) {
rotate (p, 0);
del (sons[p][0], x);
}
else if (sons[p][0] && sons[p][1]) {
int d = (rd[sons[p][0]] > rd[sons[p][1]]);
rotate (p, d);
del (sons[p][d], x);
}
}
pushup (p);
return ;
}
查找某个数的排名
仍然可以使用正常的二叉排序树的一般遍历方式。
遍历操作
情况一：若当前节点的值等于查找的树，则返回当前节点的左子树的数量+1；
情况二：若当前节点的值小于需查找的值，则返回 需查找的值在右子树的排名+当前节点的左子树的节点数+当前节点的数量；
情况三：若当前节点的值大于需查找的值，则返回 需查找的值在左子树的排名；
代码
int ranks (int p, int x) {
if (!p)
return 0;
if (x == val[p])
return siz[sons[p][0]] + 1;
if (val[p] < x)
return siz[sons[p][0]] + num[p] + ranks (sons[p][1], x);
if (val[p] > x)
return ranks (sons[p][0], x);
}
查找某排名的数
本质就是逆向操作“查找某个数的排名”。
代码
int find (int p, int x) {
if (!p)
return 0;
if (x <= siz[sons[p][0]])
return find (sons[p][0], x);
else if (x > siz[sons[p][0]] + num[p])
return find (sons[p][1], x - siz[sons[p][0]] - num[p]);
else
return val[p];
}
求先驱、后继
过程并不复杂：在遍历过程中不断向需求先驱的数靠近，同时用当前节点的值更新答案。
代码
int pre (int p, int x) {
if (!p)
return -inf;
if (val[p] >= x)
return pre (sons[p][0], x);
else
return max (val[p], pre (sons[p][1], x));
}
int suc (int p, int x) {
if (!p)
return inf;
if (val[p] <= x)
return suc (sons[p][1], x);
else
return min (val[p], suc (sons[p][0], x));
}
完整版代码：
#include
using namespace std;
const int N = 1e5 + 500, inf = 2000000005;
int n, rt, val[N], siz[N], rd[N], cnt, sons[N][2], num[N];
void pushup (int x) {
siz[x] = siz[sons[x][0]] + siz[sons[x][1]] + num[x];
return ;
}
void rotate (int &x, int d) {
int t = sons[x][d ^ 1];
sons[x][d ^ 1] = sons[t][d];
sons[t][d] = x;
pushup (x);
pushup (t);
x = t;
return ;
}
void del (int &p, int x) {
if (!p)
return ;
if (x < val[p])
del (sons[p][0], x);
else if (x > val[p])
del (sons[p][1], x);
else {
if (!sons[p][0] && !sons[p][1]) {
num[p] --;
siz[p] --;
if (num[p] == 0)
p = 0;
}
else if (sons[p][0] && !sons[p][1]) {
rotate (p, 1);
del (sons[p][1], x);
}
else if (!sons[p][0] && sons[p][1]) {
rotate (p, 0);
del (sons[p][0], x);
}
else if (sons[p][0] && sons[p][1]) {
int d = (rd[sons[p][0]] > rd[sons[p][1]]);
rotate (p, d);
del (sons[p][d], x);
}
}
pushup (p);
return ;
}
void ins (int &p, int x) {
if (!p) {
p = ++ cnt;
siz[p] = num[p] = 1;
val[p] = x;
rd[p] = rand ();
return ;
}
if (val[p] == x) {
num[p] ++;
siz[p] ++;
return ;
}
int d = (x > val[p]);
ins (sons[p][d], x);
if (rd[p] < rd[sons[p][d]])
rotate (p, d ^ 1);
pushup (p);
return ;
}
int ranks (int p, int x) {
if (!p)
return 0;
if (x == val[p])
return siz[sons[p][0]] + 1;
if (val[p] < x)
return siz[sons[p][0]] + num[p] + ranks (sons[p][1], x);
if (val[p] > x)
return ranks (sons[p][0], x);
}
int find (int p, int x) {
if (!p)
return 0;
if (x <= siz[sons[p][0]])
return find (sons[p][0], x);
else if (x > siz[sons[p][0]] + num[p])
return find (sons[p][1], x - siz[sons[p][0]] - num[p]);
else
return val[p];
}
int pre (int p, int x) {
if (!p)
return -inf;
if (val[p] >= x)
return pre (sons[p][0], x);
else
return max (val[p], pre (sons[p][1], x));
}
int suc (int p, int x) {
if (!p)
return inf;
if (val[p] <= x)
return suc (sons[p][1], x);
else
return min (val[p], suc (sons[p][0], x));
}
int main () {
scanf ("%d", &n);
for (int i = 1; i <= n; i ++) {
int op, x;
scanf ("%d%d", &op, &x);
if (op == 1)
ins (rt, x);
else if (op == 2)
del (rt, x);
else if (op == 3)
printf ("%d\n", ranks (rt, x));
else if (op == 4)
printf ("%d\n", find (rt, x));
else if (op == 5)
printf ("%d\n", pre (rt, x));
else if (op == 6)
printf ("%d\n", suc (rt, x));
}
return 0;
}
例题推荐：LOJ #104 普通平衡树