首先，我么要知道：Treap=Tree+Heap。
这里：
- Tree指的是二叉排序树；
- Heap指的是堆。
所以在阅读这篇文章之前需要大家对 二叉查找树 和 堆（Heap） 有一定的认识。
Treap支持如下操作：
- 插入x数
- 删除x数（若有多个相同的数，应只删除一个）
- 查询x数的排名（排名定义为比当前数小的数的个数+1。若有多个相同的数，应输出最小的排名）
- 查询排名为x的数
- 求x的前驱（前驱定义为小于x，且最大的数）
- 求x的后继（后继定义为大于x，且最小的数）
二叉排序树是这样的一棵树：
- 它是一棵二叉树；
- 任意节点的左儿子（如果有）的权值都小于该节点的权值；
- 任意节点的右儿子（如果有）的权值都大于该节点的权值。
二叉排序树可以实现上述6个功能，但是最坏情况下每一步操作的时间复杂度都会达到 \(O(n)\) 。
所以我们需要在二叉查找树的基础上引入堆的性质，形成一个 \(\Rightarrow\) Treap。
Treap的基本内容
首先，我们需要开一些数组来保存信息：
size[i]：以i为根节点的子树的节点总数；v[i]：i节点的权值；num[i]：由于可能有多个节点具有相同的权值，所以，我们将权值一样的存在同一个节点里面，num[i]存放的是i节点存的数的个数（即：num[i]表示有多少个数的权值为v[i]）；
sum[i][2]：用于存储i节点的儿子编号，其中：son[i][0]表示i节点的左儿子，son[i][1]表示i节点的右儿子；rd[i]：i节点的随机值。
那么，rd[i]的左右是什么呢？
每次创建一个新节点i的时候，都会为i节点分配一个随机值 rd[i]。
堆就是在这里派上用场的——我们要让全部节点按照这个随机值排成一个堆。
这就引出了平衡树中最重要的一个概念——旋转。
rotate操作——旋转
旋转分两种：左旋和右旋，它们的共同特点是不改变Treap的二叉查找树的性质，同时让Treap更加平衡。
旋转可以维护Treap堆的性质，然后巧妙地防止Treap退化成链，使得操作的时间复杂度趋于 \(O(\log n)\) 。
Treap的基本操作
void pushup(int p) {
sz[p] = sz[ son[p][0] ] + sz[ son[p][1] ] + num[p];
}
用于重新统计以p为根节点的子树中元素个数。
void rot(int &p, int d) {
int k = son[p][d^1];
son[p][d^1] = son[k][d];
son[k][d] = p;
pushup(p);
pushup(k);
p = k;
}
旋转操作，d0：左旋；d1：右旋。
1. 插入一个数x
void ins(int &p, int x) {
if (!p) {
p = ++sum;
sz[p] = num[p] = 1;
v[p] = x;
rd[p] = rand();
return;
}
if (v[p] == x) {
num[p] ++;
sz[p] ++;
return;
}
int d = (x > v[p]);
ins(son[p][d], x);
if (rd[p] < rd[ son[p][d] ]) rot(p, d^1);
pushup(p);
}
如果 p==0 （即 !p），那么就说明当前节点是一个空节点，此时我们开辟一个新节点；
如果 v[p]==x，那么就说明当前要插入的位置p上面刚好存了一个x，直接放到这个点上面就OK了；
否则，我们需要递归的进一个子树进行插入，当 x<v[p] 时， d=0，进左子树；当 x>v[p] 时，d=1，进右子树递归地插入。
如果进左儿子插入x后，p节点的rd值小于它左儿子的rd值（即：\(rd[p] \lt rd[son[p][0]]\)），则右旋；
如果进右儿子插入x后，p节点的rd值小于它右儿子的rd值（即：\(rd[p] \lt rd[son[p][1]]\)），则左旋。
（ 重点，想一想，为什么这样转不破坏堆的性质 ）（我暂时还没有想明白~）
2. 删除一个数x
void del(int &p, int x) {
if (!p) return;
if (x < v[p]) del(son[p][0], x);
else if (x > v[p]) del(son[p][1], x);
else {
if (!son[p][0] && !son[p][1]) {
num[p] --; sz[p] --;
if (!num[p]) p = 0;
}
else if (!son[p][1]) {
rot(p, 1);
del(son[p][1], x);
}
else if (!son[p][0]) {
rot(p, 0);
del(son[p][0], x);
}
else {
int d = (rd[ son[p][0] > rd[ son[p][1] ] ]);
rot(p, d);
del(son[p][d], x);
}
}
pushup(p);
}
如果是空节点，则直接返回；
如果 x 和 p[x] 不相等，直接去相应子树递归删除；
如果 x==v[p]，则：
- 如果x是叶子结点，直接扣掉个数，如果个数变为0则删掉节点；
- 如果x只有一个子节点，直接把子节点旋转上来，然后去相应子树解决；
- 如果有两个子节点，把大的那个转上来，然后去另一个子树解决。
3. 查询x数的排名
int get_rank(int p, int x) {
if (!p) return 0;
if (v[p] == x) return sz[ son[p][0] ] + 1;
if (v[p] < x) return sz[ son[p][0] ] + num[p] + get_rank(son[p][1], x);
if (v[p] > x) return get_rank(son[p][0], x);
}
如果不存在这个节点（到达了一个空节点），直接返回0；
如果x==v[p]，那么左子树的全部节点都必定小于x，直接返回左子树节点数+1；
如果x>v[p]，则x位于右子树，答案就是左子树元素个数+该节点元素个数+右子树中x的排名；
如果x<v[p]，则x位于左子树，答案就是x在左子树的排名。
4. 查询排名为x的数
int func_find(int p, int x) {
if (!p) return 0;
if (sz[ son[p][0] ] >= x) return func_find(son[p][0], x);
else if (sz[ son[p][0] ] + num[p] < x)
return func_find(son[p][1], x-num[p]-sz[ son[p][0] ]);
else return v[p];
}
空节点没有排名，直接返回0；
如果左子树中节点个数大于x，则进左子树找；
否则，如果左子树加根节点的个数大于等于x，直接返回根节点的值v[p]；
否则，说明左子树加根节点的个数小于x，进右子树找第 \(x-最节点和根节点元素个数\) 个元素。
5. 求x的前驱
int pre(int p, int x) {
if (!p) return -INF;
if (v[p] >= x) return pre(son[p][0], x);
else return max(v[p], pre(son[p][1], x));
}
如果是空节点，则没有前驱；
如果x是根或在右子树，去左子树找；
否则要么是根要么右子树，取一个max就可以了（前驱定义为小于x，且最大的数）。
6. 求x的后缀
int suc(int p, int x) {
if (!p) return INF;
if (v[p] <= x) return suc(son[p][1], x);
else return min(v[p], suc(son[p][0], x));
}
如果是空节点，则没有后缀；
如果在根或者左子树，去右子树找；
否则要么根要么左子树，取min就可以了(后继定义为大于x，且最小的数)。
洛谷上面有一道题是专门用于练习左偏树的题目：洛谷 P3369
实现代码如下：
#include <bits/stdc++.h>
using namespace std;
#define INF INT_MAX
const int maxn = 100010;
int sum = 0, R = 0;
int sz[maxn], v[maxn], num[maxn], rd[maxn], son[maxn][2];
// 用于重新统计以p为根节点的子树中元素个数
void pushup(int p) {
sz[p] = sz[ son[p][0] ] + sz[ son[p][1] ] + num[p];
}
// 左旋（d==0时），右旋（d==1时）
void rot(int &p, int d) {
int k = son[p][d^1];
son[p][d^1] = son[k][d];
son[k][d] = p;
pushup(p);
pushup(k);
p = k;
}
// 插入一个数x
void ins(int &p, int x) {
if (!p) {
p = ++sum;
sz[p] = num[p] = 1;
v[p] = x;
rd[p] = rand();
return;
}
if (v[p] == x) {
num[p] ++;
sz[p] ++;
return;
}
int d = (x > v[p]);
ins(son[p][d], x);
if (rd[p] < rd[ son[p][d] ]) rot(p, d^1);
pushup(p);
}
// 删除一个数x
void del(int &p, int x) {
if (!p) return;
if (x < v[p]) del(son[p][0], x);
else if (x > v[p]) del(son[p][1], x);
else {
if (!son[p][0] && !son[p][1]) {
num[p] --; sz[p] --;
if (!num[p]) p = 0;
}
else if (!son[p][1]) {
rot(p, 1);
del(son[p][1], x);
}
else if (!son[p][0]) {
rot(p, 0);
del(son[p][0], x);
}
else {
int d = (rd[ son[p][0] > rd[ son[p][1] ] ]);
rot(p, d);
del(son[p][d], x);
}
}
pushup(p);
}
// 查询x数的排名
int get_rank(int p, int x) {
if (!p) return 0;
if (v[p] == x) return sz[ son[p][0] ] + 1;
if (v[p] < x) return sz[ son[p][0] ] + num[p] + get_rank(son[p][1], x);
if (v[p] > x) return get_rank(son[p][0], x);
}
// 查询排名为x的数
int func_find(int p, int x) {
if (!p) return 0;
if (sz[ son[p][0] ] >= x) return func_find(son[p][0], x);
else if (sz[ son[p][0] ] + num[p] < x)
return func_find(son[p][1], x-num[p]-sz[ son[p][0] ]);
else return v[p];
}
// 求x的前驱
int pre(int p, int x) {
if (!p) return -INF;
if (v[p] >= x) return pre(son[p][0], x);
else return max(v[p], pre(son[p][1], x));
}
// 求x的后缀
int suc(int p, int x) {
if (!p) return INF;
if (v[p] <= x) return suc(son[p][1], x);
else return min(v[p], suc(son[p][0], x));
}
int T, op, x;
int main() {
cin >> T;
while (T --) {
cin >> op >> x;
if (op == 1) ins(R, x);
else if (op == 2) del(R, x);
else if (op == 3) cout << get_rank(R, x) << endl;
else if (op == 4) cout << func_find(R, x) << endl;
else if (op == 5) cout << pre(R, x) << endl;
else if (op == 6) cout << suc(R, x) << endl;
}
return 0;
}
然后我又用类封装了一下，C++类封装的代码如下：
#include <bits/stdc++.h>
using namespace std;
#define INF INT_MAX
const int maxn = 100010;
class Treap {
private:
int sum, R, sz[maxn], v[maxn], num[maxn], rd[maxn], son[maxn][2];
void pushup(int p) {
sz[p] = sz[ son[p][0] ] + sz[ son[p][1] ] + num[p];
}
void rot(int &p, int d) {
int k = son[p][d^1];
son[p][d^1] = son[k][d];
son[k][d] = p;
pushup(p);
pushup(k);
p = k;
}
void ins(int &p, int x) {
if (!p) {
p = ++sum;
sz[p] = num[p] = 1;
v[p] = x;
rd[p] = rand();
}
else if (v[p] == x) {
num[p] ++;
sz[p] ++;
}
else {
int d = (x > v[p]);
ins(son[p][d], x);
if (rd[p] < rd[ son[p][d] ]) rot(p, d^1);
pushup(p);
}
}
void del(int &p, int x) {
if (!p) return;
if (x < v[p]) del(son[p][0], x);
else if (x > v[p]) del(son[p][1], x);
else {
if (!son[p][0] && !son[p][1]) {
num[p] --; sz[p] --;
if (!num[p]) p = 0;
}
else if (!son[p][1]) {
rot(p, 1);
del(son[p][1], x);
}
else if (!son[p][0]) {
rot(p, 0);
del(son[p][0], x);
}
else {
int d = (rd[ son[p][0] > rd[ son[p][1] ] ]);
rot(p, d);
del(son[p][d], x);
}
}
pushup(p);
}
int get_rank(int p, int x) {
if (!p) return 0;
if (v[p] == x) return sz[ son[p][0] ] + 1;
if (v[p] < x) return sz[ son[p][0] ] + num[p] + get_rank(son[p][1], x);
if (v[p] > x) return get_rank(son[p][0], x);
}
int func_find(int p, int x) {
if (!p) return 0;
if (sz[ son[p][0] ] >= x) return func_find(son[p][0], x);
else if (sz[ son[p][0] ] + num[p] < x)
return func_find(son[p][1], x-num[p]-sz[ son[p][0] ]);
else return v[p];
}
int pre(int p, int x) {
if (!p) return -INF;
if (v[p] >= x) return pre(son[p][0], x);
else return max(v[p], pre(son[p][1], x));
}
int suc(int p, int x) {
if (!p) return INF;
if (v[p] <= x) return suc(son[p][1], x);
else return min(v[p], suc(son[p][0], x));
}
public:
Treap() {}
void Init() {
sum = R = 0;
memset(sz, 0, sizeof(sz));
memset(v, 0, sizeof(v));
memset(num, 0, sizeof(num));
memset(rd, 0, sizeof(rd));
memset(son, 0, sizeof(son));
}
void Insert(int x) { ins(R, x); }
void Delete(int x) { del(R, x); }
int GetRank(int x) { return get_rank(R, x); }
int Find(int x) { return func_find(R, x); }
int Pre(int x) { return pre(R, x); }
int Suc(int x) { return suc(R, x); }
} treap;
int main() {
treap.Init();
int T, op, x;
cin >> T;
while (T --) {
cin >> op >> x;
switch (op) {
case 1: treap.Insert(x); break;
case 2: treap.Delete(x); break;
case 3: cout << treap.GetRank(x) << endl; break;
case 4: cout << treap.Find(x) << endl; break;
case 5: cout << treap.Pre(x) << endl; break;
case 6: cout << treap.Suc(x) << endl; break;
default: break;
}
}
return 0;
}