先将要删除的节点的heap_key值调整为正无穷，然后通过单旋维护heap_kep的二叉堆性质，此时要删除的节点将是叶子节点，直接删除即可。

和普通二叉排序树操作一样。

在涉及到区间整体操作时操作如下：

1. 先将区间左端点的前驱的heap_key值赋值为负无穷，维护heap_key的二叉堆性质。
2. 再将区间右端点的后继的heap_key值赋值为负无穷＋1，维护heap_key的二叉堆性质。
3. 此时，树根的右孩子的左孩子即为所要操作的区间，直接操作。
4. 将树根的右孩子的heap_key值赋为新的随机值，维护heap_key的二叉堆性质。
5. 将树根的heap_key值赋为新的随机值，维护heap_key的二叉堆性质。

6.以noi2005维护数列为例实现treaplay

维护数列[4]

【问题描述】

请写一个程序，要求维护一个数列，支持以下 6 种操作：（请注意，格式栏 中的下划线‘ _ ’表示实际输入文件中的空格）

【输入格式】

输入文件的第 1 行包含两个数 N 和 M，N 表示初始时数列中数的个数，M
表示要进行的操作数目。
第 2 行包含 N 个数字，描述初始时的数列。
以下 M 行，每行一条命令，格式参见问题描述中的表格。

【输出格式】< 20000 /h4>

对于输入数据中的 GET-SUM 和 MAX-SUM 操作，向输出文件依次打印结 果，每个答案（数字）占一行。

【输入样例】

9 8
2 -6 3 5 1 -5 -3 6 3
GET-SUM 5 4
MAX-SUM INSERT 8 3 -5 7 2
DELETE 12 1MAKE-SAME 3 3 2
REVERSE 3 6
GET-SUM 5 4
MAX-SUM

【输出样例】

-1
10
1
10

【数据规模和约定】

你可以认为在任何时刻，数列中至少有 1 个数。 输入数据一定是正确的，即指定位置的数在数列中一定存在。

50%的数据中，任何时刻数列中最多含有 30 000 个数；
100%的数据中，任何时刻数列中最多含有 500 000 个数。

100%的数据中，任何时刻数列中任何一个数字均在[-1 000, 1 000]内。
100%的数据中，M ≤20 000，插入的数字总数不超过 4 000 000 个，输入文件
大小不超过 20MBytes。

treaplay代码：

#include <cstdio>
#include <iostream>
#include <stdlib.h>
#include <time.h>

using namespace std;
const int maxsize=500000;

int heap_key[maxsize+3],size[maxsize+3],parent[maxsize+3],
left_child[maxsize+3],right_child[maxsize+3];
int maxque[maxsize+3],sum[maxsize+3],number[maxsize+3],maxnum[maxsize+3],leftmax[maxsize+3],rightmax[maxsize+3];
int tagchange[maxsize+3],tagreverse[maxsize+3];

int trash[maxsize+3];

int a[maxsize+3];

const int maxn = 2147483647;
const int minn = -100;
const int null = maxsize+2;
const int bigroot = 0;

int top = null-1;

int max(int a,int b) {
if (a>b) {
return a;
} else {
return b;
}
}

void Initialize() {
parent[bigroot] = bigroot;
left_child[bigroot] = right_child[bigroot] = null;
heap_key[bigroot] =-maxn;
size[bigroot] = 1;
tagchange[bigroot] = maxn;
tagreverse[bigroot] = 0;
sum[bigroot] = number[bigroot] = maxnum[bigroot] = -maxn / 8;
maxque[bigroot] = leftmax[bigroot] = rightmax [bigroot] = 0;

parent[null] = bigroot;
left_child[null] = right_child[null] = null;
heap_key[null] = maxn;
size[null] = 0;
tagchange[null] = maxn;
tagreverse[null] = 0;
maxque[null] = leftmax[null] = rightmax[null] = sum[null] = number[null] =0;
maxnum[null] = -maxn / 8;

top=null-1;
for (int i=1;i<null;++i) trash[i]=i;
srand((int)time(0));
}

void Reverse(int t) {
if (t == null) return;
int tt = left_child[t];
left_child[t] = right_child[t];
right_child[t] = tt;

tt = leftmax[t];
leftmax[t] = rightmax[t];
rightmax[t] = tt;

tagreverse[t] = tagreverse[t] ^ 1;
}

void Change(int t,int tt) {
if (t == null) return;
sum[t] = size[t] * tt;
maxnum[t] = tagchange[t] = number[t] = tt;

if (tt > 0) {
leftmax[t] = rightmax[t] = maxque[t] = size[t] * tt;
} else {
leftmax[t] = rightmax[t] = maxque[t] = 0;
}
}

void downtag(int t) {
int lc = left_child[t];
int rc = right_child[t];

int tt = tagchange[t];
if (maxn != tt) {
Change(lc, tt);
Change(rc, tt);
tagchange[t] = maxn;
}

if (tagreverse[t]) {
Reverse(lc);
Reverse(rc);
tagreverse[t] = 0;
}
}

void update(int t) {
int lc = left_child[t];
int rc = right_child[t];
int num = number[t];
size[t] = size[lc] + size[rc] + 1;
maxque[t] = max( max(maxque[lc],maxque[rc]),rightmax[lc] + num + leftmax[rc]);
sum[t] = sum[lc] + sum[rc] + num;
maxnum[t] = max( max(maxnum[lc],maxnum[rc]),num);
leftmax[t] = max(leftmax[lc],sum[lc] + num + leftmax[rc]);
rightmax[t] = max(rightmax[rc],sum[rc] + num + rightmax[lc]);
}

void left_draft(int &t) {
downtag(t);
int tt = left_child[t];
downtag(tt);
int ttt = right_child[tt];
left_child[t] = ttt;
parent[ttt] = t;
parent[tt] = parent[t];
parent[t] = tt;
right_child[tt]=t;
update(t);
update(tt);
t=tt;
}

void right_draft(int &t) {
downtag(t);
int tt = right_child[t];
downtag(tt);
int ttt = left_child[tt];
right_child[t] = ttt;
parent[ttt] = t;
parent[tt] = parent[t];
parent[t] = tt;
left_child[tt]=t;
update(t);
update(tt);
t=tt;
}

void maintain(int t) {//维护heap_key的二叉堆性质
int tt = parent[t];
int ttt = parent[tt];
while (heap_key[t] < heap_key[tt]) {

if (right_child[ttt] == tt) {
if (right_child[tt] == t) {
right_draft(right_child[ttt]);
} else {
left_draft(right_child[ttt]);
}
} else {
if (right_child[tt] == t) {
right_draft(left_child[ttt]);
} else {
left_draft(left_child[ttt]);
}
}

tt = parent[t];
ttt = parent[tt];
}

downtag(t);
int tl = heap_key[left_child[t]],tr = heap_key[right_child[t]];
tt = parent[t];
while ((tl < heap_key[t]) || (tr < heap_key[t])) {
if (right_child[tt] == t) {
if (tl < tr) {
left_draft(right_child[tt]);
} else {
right_draft(right_child[tt]);
}
} else {
if (tl < tr) {
left_draft(left_child[tt]);
} else {
right_draft(left_child[tt]);
}
}
tl = heap_key[left_child[t]];tr = heap_key[right_child[t]];
tt = parent[t];
}
}

int Find(int s){
int t = bigroot;

while (t != null) {
if (s == size[left_child[t]] + 1) break;
downtag(t);
if (s > size[left_child[t]] + 1) {s -= size[left_child[t]] + 1; t = right_child[t];}
else t = left_child[t];
}

return t;
}

void Delete(int t) {
if (t == null) return;
trash[++top] = t;
Delete(left_child[t]);
Delete(right_child[t]);
}

int getans(int a,int b) {
if (b == 0) return a; else return b;
}

void Build(int l,int r,int &t,int deep) {
if (l == r+1) {t = null;return;}
int k = trash[top--];
t = k;
int mid = (l + r) / 2;
heap_key[k] = (rand() % (10 << deep)) + (10 << deep);
number[k] = a[mid];
tagchange[k] = maxn;
tagreverse[k] = 0;
Build(l, mid-1, left_child[k], deep+1);
Build(mid+1, r, right_child[k], deep+1);
parent[left_child[k]] = k;
parent[right_child[k]] = k;
update(k);

}

int root,b;

int main() {
freopen("sequence.in", "r" , stdin);
freopen("sequence.out", "w", stdout);

Initialize();
int n,m,pos,tot,cc;
scanf("%d %d\n",&n,&m);
for (int i=0;i<n;++i) scanf("%d",&a[i]);
Build(0, n-1, right_child[bigroot], 0);
int k = bigroot;
parent[right_child[k]] = k;
update(k);

char c[20];
while (m--) {//printall(bigroot);
scanf("%s",c);

switch (c[0]) {
case 'I':{
scanf("%d %d ",&pos,&tot);
pos++;
int t = Find(pos);
heap_key[t] = minn+1;
maintain(t);
int tt = Find(pos+1);
if (tt == null) {
for (int i=0;i<tot;++i) scanf("%d",&a[i]);
Build(0, tot-1, right_child[t], 0);
int k = t;
parent[right_child[k]] = k;
update(k);
} else {
heap_key[tt] = minn+2;
maintain(tt);
for (int i=0;i<tot;++i) scanf("%d",&a[i]);
Build(0, tot-1, left_child[tt], 0);
int k = tt;
parent[left_child[k]] = k;
update(k);
heap_key[tt] = rand() % 2000000000;
maintain(tt);
update(t);
}
heap_key[t] = rand() % 2000000000;
heap_key[bigroot] = -maxn;
maintain(t);
break;
}
case 'D':{
scanf("%d %d",&pos,&tot);
tot++;
int t = Find(pos);
heap_key[t] = minn+1;
maintain(t);
int tt = Find(pos+tot);
if (tt == null) {
Delete(right_child[t]);
right_child[t] = null;
} else {
heap_key[tt] = minn+2;
maintain(tt);
Delete(left_child[tt]);
left_child[tt] = null;
update(tt);
heap_key[tt] = rand() % 2000000000;
maintain(tt);
}
update(t);
heap_key[t] = rand() % 2000000000;
heap_key[bigroot] = -maxn;
maintain(t);
break;
}
case 'R':{
scanf("%d %d",&pos,&tot);
tot++;
int t = Find(pos);
heap_key[t] = minn+1;
maintain(t);
int tt = Find(pos+tot);
if (tt == null) {
Reverse(right_child[t]);
} else {
heap_key[tt] = minn+2;
maintain(tt);
Reverse(left_child[tt]);
update(tt);
heap_key[tt] = rand() % 2000000000;
maintain(tt);
}
update(t);
heap_key[t] = rand() % 2000000000;
heap_key[bigroot] = -maxn;
maintain(t);
break;
}
case 'G':{
scanf("%d %d",&pos,&tot);
tot++;
int t = Find(pos);
heap_key[t] = minn+1;
maintain(t);
int tt = Find(pos+tot);
if (tt == null) {
printf("%d\n",sum[right_child[t]]);
} else {
heap_key[tt] = minn+2;
maintain(tt);
printf("%d\n",sum[left_child[tt]]);
heap_key[tt] = rand() % 2000000000;
maintain(tt);
}
heap_key[t] = rand() % 2000000000;
heap_key[bigroot] = -maxn;
maintain(t);
break;
}
default:{
if (c[2] == 'X') {
printf("%d\n",getans(maxnum[right_child[bigroot]],maxque[right_child[bigroot]]));
} else {
scanf("%d %d %d",&pos,&tot,&cc);
tot++;
int t = Find(pos);
heap_key[t] = minn+1;
maintain(t);
int tt = Find(pos+tot);
if (tt == null) {
Change(right_child[t],cc);
} else {
heap_key[tt] = minn+2;
maintain(tt);
Change(left_child[tt],cc);
update(tt);
heap_key[tt] = rand() % 2000000000;
maintain(tt);
}
update(t);
heap_key[t] = rand() % 2000000000;
heap_key[bigroot] = -maxn;
maintain(t);
}
break;
}
}
}
return 0;
}

测试机器：2.7 GHz Intel Core i5
测试系统：OS X EI Capitan 10.11.1
测试结果：

比较结果：treaplay略慢于splay，但是并不差太多，而且不同操作效率有差别，整体上来说效率相当。

7.treap、splay、treaplay的比较（相对于treaplay的大致比较结果）

8.结论

相比而言，treaplay的效率在普通平衡树操作时与treap相当，快于splay，区间整体操作与splay相当，略慢一些，编程复杂度与treap一样，小于splay。整体上来说，treaplay不论从效率还是难度上来讲，都非常出色，可以完成到目前为止所有平衡树与splay的题目，有很强的适应性与实用性，值得推广学习。

参考资料

[1]《treap的加权形式及复杂性的严格证明》 Cecilia R.Aragon Computer Science Division University of California Berkeley Berkeley CA 94720
[2]《伸展树的原理及应用》 常州市第一中学 林厚从
[3]《SBT》陈启峰
[4]第二十二届全国信息学奥林匹克竞赛 NOI 2005 第一试 维护数列
[5]此程序引用自http://www.cnblogs.com/kuangbin/archive/2013/08/28/3287822.html