Treap（平衡树）

Treap

前置芝士

二叉搜索树(BST)，见 BST。
平衡二叉树(AVL)。
先来介绍一下平衡二叉树。

背景

BST 出现以后，人们很快发现一个问题，当其维护一个有序序列时，很可能会退化成链。如图：

这样的话，原来 \(O(\log{n})\) 的复杂度就退化为 \(O(n)\)，这是我们无法接受的，于是平衡二叉树横空出世。

定义

平衡二叉树:左右子树的高度相差不超过 1 的 BST（可以为空树）。平衡，顾名思义，就是要求左右子树的高度相近。
下面给出一些图，请判断是否为平衡二叉树：



显然，只有第二棵树是平衡二叉树，第一棵树节点 5 左右子树不平衡，第三棵树不是 BST。

基础知识

treap，就是“树堆”，由树和堆组成，是一种入门级的平衡二叉树，操作较多，码量较大，但比较基础，好理解。

\[Treap=tree+heap \]

二叉搜索树(BST)对于一个序列来说不唯一，也就是说，在满足“BST性质”的前提下，中序遍历为相同序列的 BST 不唯一。因此，在 BST 的基础上加上二叉堆，来保证平衡性。用来维护 BST 的值为“关键码”，维护堆的值为权值，权值是随机产生的，避免退化。维护堆性质的操作为“旋转”。Treap 是一种通过适当的旋转，在维持节点关键码满足 BST 性质的同时，还使每个节点上随机生成的权值满足二叉堆的性质的平衡二叉树。 各个操作时间复杂度为 \(O(\log{n})\)。
基本操作有：

1. 插入一个数 \(x\)。
2. 删除一个数 \(x\)（若有多个相同的数，应只删除一个）。
3. 定义排名为比当前数小的数的个数 \(+1\)。查询 \(x\) 的排名。
4. 查询数据结构中排名为 \(x\) 的数。
5. 求 \(x\) 的前驱（前驱定义为小于 \(x\)，且最大的数）。
6. 求 \(x\) 的后继（后继定义为大于 \(x\)，且最小的数）。

操作

建树

与 BST 相同，建立一棵空树，不过我们需要储存更多的信息，size 为以该节点为根的子树大小，cnt 表示序列中该关键字的个数，pushup 和线段树的一样，更新父亲的信息。

const int N=1e5+5,inf=1<<30;

struct treap
{
    int l,r;
    int key,dat;//关键字，附加权值
    int size,cnt;//子树大小，副本数
}a[N];
int tot,root,n,m;

int New(int k)
{
    a[++tot].key=v;
    a[tot].dat=rand();
    a[tot].cnt=a[tot].size=1;
    return tot;
}
void pushup(int u)
{
    a[u].size=a[a[u].l].size+a[a[u].r].size+a[u].cnt;
}
void build()
{
    New(-inf),New(inf);
    root=1,a[root].r=2;
}

旋转

旋转是 Treap 的基本操作，分为左旋和右旋。如图：

• 右旋：把父亲变为左儿子的右儿子。
• 左旋：把父亲变为右儿子的左儿子。

如图，对于黑色节点来说，左边右旋后，该节点的左子树节点数减一，右子树加一，右边左旋后，该节点的左子树节点树加一，右子树减一。也就是说对于一个节点右旋，会增加右子树的节点数，左旋会增加左子树的节点数，利用左旋和右旋我们就可以维护二叉平衡树。

以右旋为例，将 \(y\) 变为 \(x\) 的右儿子，对于 \(x\) 左儿子不变，右儿子变为 \(y\)，这样 \(y\) 的左儿子就空出来了，刚好可以把 \(x\) 的右子树 \(B\) 接上去。具体：\(y\) 的左子树变为 \(B\)，\(x\) 的右儿子变为 \(y\)，\(x\) 代替 \(y\) 原来的位置。

左旋同理：

void zig(int &u)//右旋
{
    int q=a[u].l;
    a[u].l=a[q].r,a[q].r=u,u=q;
    pushup(a[u].r),pushup(u);
}
void zag(int &u)//左旋
{
    int q=a[u].r;
    a[u].r=a[q].l,a[q].l=u,u=q;
    pushup(a[u].l),pushup(u);
}

当权值不满足大根堆（小也可）性质时，交换父亲和儿子，这样就能使 BST 更平衡。
注意要用 &，这样的话会一起更新它父亲的信息，可以认为，\(q\) 完全代替了 \(u\)。

插入

将 \(key\) 为 \(v\) 的数插入到平衡树中，若原本已经存在，则直接找到位置将 \(cnt\) 加上 1。若不存在，则需将这个数插入到叶子节点，一直向下走直到找到要插入的位置，插入后判断是否满足大根堆性质，进行旋转来维护。

void insert(int &u,int v)
{
    if(u==0) u=New(v);//u指向新的节点
    else if(a[u].key==v) a[u].cnt++;
    else if(a[u].key>v) 
    {
        insert(a[u].l,v);
        if(a[u].dat<a[a[u].l].dat) zig(u);//不满足大根堆，交换左儿子和父亲
    }
    else 
    {
        insert(a[u].r,v);
        if(a[u].dat<a[a[u].r].dat) zag(u);//不满足大根堆，交换右儿子和父亲
    }
    pushup(u);
}

删除

将 \(key\) 为 \(v\) 的数从平衡树中删除，与插入类似，先要找到该节点。若该节点的 \(cnt\) 大于 1，直接减去 1 即可。若小于 1，考虑如何删除，如果该点是叶子节点那就好办了，直接用 0 代替，但如果不是，我们也不能直接删，要通过不断地旋转把它变成叶子节点，具体看代码，自己手推一遍就理解了。

void remove(int &u,int v)
{
    if(u==0) return;//没有这个数
    if(a[u].key==v) 
    {
        if(a[u].cnt>1) a[u].cnt--;
        else if(a[u].l&&a[u].r)//非叶子节点 
        {
            //保证旋转过后能满足大根堆的性质，哪个大就把哪个作为父亲
            if(a[u].r==0||a[a[u].l].dat>a[a[u].r].dat) zig(u),remove(a[u].r,v);//右旋后父亲变为右儿子
            else zag(u),remove(a[u].l,v)
        }
        else u=0;
    }
    else a[u].key>v ? remove(a[u].l,v) : remove(a[u].r,v);//一直往下走
    pushup(u);
}

查排名

\(v\) 的排名为小于它的个数 \(+1\)。考虑 BST 中，比当前节点小的点应该全部位于左子树，因此排名就是左子树的大小 \(+1\)。所以先找到该值，再算个数。考虑如何从根节点往下走：

• \(key==v\)，说明已找到，直接返回左子树的大小加 1。
• \(key>v\)，则需往左子树走。
• \(key<v\)，则需往右子树走，同时加上左子树大小和该节点副本数。
• \(u==0\)，说明树中不存在 \(v\) 的节点，直接加 1。

需要在递归出口加上 1。

int get_rank(int u,int v)
{
    if(u==0) return 1;
    if(a[u].key==v) return a[a[u].l].size+1;
    if(a[u].key>v) return get_rank(a[u].l,v);
    return get_rank(a[u].r,v)+a[a[u].l].size+a[u].cnt;
}

查值

已知排名为 \(k\)，查询具体的值。大同小异：

• 若左子树大小大于等于 \(k\)，说明 \(k\) 在左子树，往左子树走。
• 若 \(k\) 大于左子树大小且小于左子树大小加副本数，说明该节点就是答案。
• 若 \(k\) 大于左子树大小加副本数，说明在右子树，往右子树继续找。

int get_val(int u,int k)
{
    if(a[a[u].l].size>=k) return get_val(a[u].l,k);
    if(a[a[u].l].size+a[u].cnt>=k) return a[u].key;
    return get_val(a[u].r,k-a[a[u].l].size-a[u].cnt);//减去比k小的值的个数
}

查前驱/后继

前驱定义为小于 \(x\)，且最大的数，后继定义为大于 \(x\)，且最小的数。
以前驱为例，一直往下走，不满足 \(key<x\) 则往左子树走，否则开始找最大值。

int get_pre(int u,int v)
{
    if(u==0) return -inf;
    if(a[u].key>=v) return get_pre(a[u].l,v);
    return max(a[u].key,get_pre(a[u].r,v));
}
int get_ne(int u,int v)
{
    if(u==0) return inf;
    if(a[u].key<=v) return get_ne(a[u].r,v);
    return min(a[u].key,get_ne(a[u].l,v));
}

P3369 【模板】普通平衡树

分析

将以上讲的所有操作结合在一起就好了，注意细节。

code

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define lc a[u].l
#define rc a[u].r
#define val a[u].key
const int N=1e5+5,inf=1<<30;

struct treap
{
    int l,r;
    int key,dat;
    int size,cnt;
}a[N];
int tot,root,n,m;

int New(int v)
{
    a[++tot].key=v;
    a[tot].dat=rand();
    a[tot].cnt=a[tot].size=1;
    return tot;
}
void pushup(int u)
{
    a[u].size=a[lc].size+a[rc].size+a[u].cnt;
}
void build()
{
    New(-inf),New(inf);
    root=1,a[root].r=2;
}
void zig(int &u)//右旋
{
    int q=lc;
    lc=a[q].r,a[q].r=u,u=q;
    pushup(rc),pushup(u);
}
void zag(int &u)//左旋
{
    int q=rc;
    rc=a[q].l,a[q].l=u,u=q;
    pushup(lc),pushup(u);
}
void insert(int &u,int v)
{
    if(u==0) u=New(v);
    else if(val==v) a[u].cnt++;
    else if(val>v)
    {
        insert(lc,v);
        if(a[lc].dat>a[u].dat) zig(u);//不满足大根堆，交换左儿子和父亲
    }
    else 
    {
        insert(rc,v);
        if(a[rc].dat>a[u].dat) zag(u);//交换右儿子
    }
    pushup(u);
}
void remove(int &u,int v)
{
    if(u==0) return ;
    if(val==v)
    {
        if(a[u].cnt>1) a[u].cnt--;
        else if(lc||rc) //有叶子节点
        {
            //保证旋转过后能满足大根堆的性质，哪个大就把哪个作为父亲
            if(rc==0||a[lc].dat>a[rc].dat) zig(u),remove(rc,v);//右旋后父亲变为右儿子
            else zag(u),remove(lc,v);
            pushup(u);
        }
        else u=0;
    }
    else val>v ? remove(lc,v) : remove(rc,v);
    pushup(u);
}
int get_rank(int u,int v)
{
    if(u==0) return 1;
    if(val==v) return a[lc].size+1;
    if(val>v) return get_rank(lc,v);
    return get_rank(rc,v)+a[lc].size+a[u].cnt;
}
int get_val(int u,int k)
{
    if(a[lc].size>=k) return get_val(lc,k);
    if(a[lc].size+a[u].cnt>=k) return val;
    return get_val(rc,k-a[lc].size-a[u].cnt);
}
int get_pre(int u,int v)
{
    if(u==0) return -inf;
    if(val>=v) return get_pre(lc,v);
    return max(val,get_pre(rc,v));
}
int get_ne(int u,int v)
{
    if(u==0) return inf;
    if(val<=v) return get_ne(rc,v);
    return min(val,get_ne(lc,v));
}
int main ()
{
    cin>>m;
    build();
    for(int op,x;m--;)
    {
        cin>>op>>x;
        if(op==1) insert(root,x);
        else if(op==2) remove(root,x);
        else if(op==3) cout<<get_rank(root,x)-1<<"\n";//减去-inf的点
        else if(op==4) cout<<get_val(root,x+1)<<"\n";//存在-inf
        else if(op==5) cout<<get_pre(root,x)<<"\n";
        else cout<<get_ne(root,x)<<"\n";
    }
    return 0;
}

结语

有了 Treap，时间复杂度不会退化了，但是——这代码也太长了。而 FHQ_Treap 和 Splay 就会更好 QAQ。