[中级数据结构学习笔记]一、Treap

一、什么是Treap?

顾名思义，Treap=Tree+Heap(平衡二叉树+堆)。Treap是一种在键值上满足平衡二叉树性质、在优先级上满足堆性质的数据结构。

二、为什么要用Treap?

我们都知道平衡二叉树(以下简称BST)，在一棵BST中，一个结点的左子树中的元素键值均小于该结点的键值，右子树中的元素键值均大于该结点的键值，图(1)就是一棵BST。通过BST，我们可以用类似于二分查找的方法快速地在树中进行查找操作。

但是BST也有缺点。最好情况下，一棵有n个结点的BST的深度为logn，但是实际上BST的深度还取决于其根结点的键值，根结点的键值如果过大或者过小，BST的深度就会增大很多，甚至于出现退化成链表的情况，如图(2)，这时BST的查找复杂度为O(n)。

为了避免这种情况的发生，让树的深度尽量小，我们需要在保证维护这棵树具备BST的性质的前提下，对其根结点进行调整，于是Treap出现了。Treap就是在BST的基础上引入了一个类似于Heap中的优先级，Treap在具备BST平衡的前提下，还具备一个Heap的性质，即一个结点的优先级比其子树中的结点的优先级都要大，在改变一棵Treap的同时，需要对结点位置进行调整，维护Treap的性质，而每个结点的优先级都是随机数，这样就保证了Treap的深度尽量小，Treap是一种随机树。如图(3)就是一棵Treap。

三、数组版Treap的实现

在竞赛中，为了方便调试，减少错误的发生概率，推荐使用数组版Treap。以下是一棵数组版的Treap树的实现，适用于大多数的题目，对于不同的题目需要根据实际情况，对模板进行适当调整。

1、Treap结点的定义

一个Treap的结点包含下列信息：

1、左右儿子结点指针 l,r

2、结点键值 v (为了扩大模板的适用范围，键值用结构体info代替，info需要进行'<'、'>'、'=='的运算符重载)

3、结点优先级 rnd

4、该结点和其子树中的结点个数 s

5、该结点对应的相同键值元素个数 cnt

另外，还要维护一个数字nCount表示已经占用结构体数组的大小，和一个当前根节点指针root。

代码：

struct node
{
    int s; //该点下的结点个数(包含该点)
    int cnt; //该点的数字个数
    info v; //结点键值
    int l,r; //左右子树
    int rnd; //结点的随机权值
}tree[MAXN];
 
int nCount=0;
int ans;
int root=0;

2、Treap的结点插入操作

如图(4)，我们要在键值为10的根节点x下插入键值为13的结点a，操作为insert(x,a)。插入操作时需要维护treap的平衡性质，如果x是个空指针，那么a就充当x，如果a的键值比x大，向x的右子树插入，如果a的键值比x小，插入x的左子树，否则标记本结点的元素个数+1。

代码：

void insert(int &o,info x) //在根节点为o的树中插入键值为x的结点，若存在键值为x的结点，那么增加该结点对应数字个数
{
    if(o==0) //空树,建立新的根结点
    {
        o=++nCount;
        tree[o].s=tree[o].cnt=1;
        tree[o].rnd=rand()*rand();
        tree[o].v=x;
        return;
    }
    tree[o].s++;
    if(x<tree[o].v) //x比根结点键值小，往左子树插
    {
        insert(LC,x);
        if(tree[o].rnd>tree[LC].rnd) //注意维护堆的性质
            rotateR(o);
    }
    else if(x>tree[o].v) //x比根结点键值大，往右子树插，下面操作类似上面
    {
        insert(RC,x);
        if(tree[o].rnd>tree[RC].rnd)
            rotateL(o);
    }
    else //x和根节点键值一样，那么增加根节点对数字个数
        tree[o].cnt++;
}

3、旋转操作

如图(5)是一棵treap树的旋转操作，从左到右是右旋结点b(rotateR(b))，从右到左是左旋结点b(rotatL(b))。一般的，插入结点或删除结点后，为了维护Treap的堆性质，需要进行旋转操作，旋转操作需要同时保证Treap的平衡性质。

void rotateR(int &o) //右旋结点o
{
    int t=LC;
    LC=tree[t].r;
    tree[t].r=o;
    tree[t].s=tree[o].s;
    update(o);
    o=t;
}
 
void rotateL(int &o) //左旋结点o
{
    int t=RC;
    RC=tree[t].l;
    tree[t].l=o;
    tree[t].s=tree[o].s;
    update(o);
    o=t;
}

4、删除操作

删除一个结点时，同样需要维护Treap的平衡树和堆的性质。若该结点只有一个儿子，那么删除该结点后，让它的儿子变动到该结点的位置即可。但如果该结点有两个儿子，则需要分类讨论：1、右儿子优先值比左儿子大，则需要先右旋结点o，再删除结点o。2、右儿子优先值比左儿子小，则需要先左旋结点o，再删除结点o。

代码(LC代表o的左儿子，RC代表o的右儿子，LC和RC在代码的宏定义部分中)：

void del(int &o,info x) //在根节点为o的树中删除<一个>键值为x的点
{
    if(o==0) return; //找不到可以删除的结点，退出
    if(tree[o].v==x)
    {
        if(tree[o].cnt>1) tree[o].s--,tree[o].cnt--; //该点对应数字不止1个，不能删除这个结点
        else if(LC==0||RC==0) o=LC+RC; //该点下只含一个儿子，删完这个点用它儿子来代替
        else if(tree[LC].rnd<tree[RC].rnd) rotateR(o),del(o,x); //该点的左儿子权值比右儿子小，要维护堆的性质，右旋根结点o
        else rotateL(o),del(o,x);
        return;
    }
    tree[o].s--;
    if(tree[o].v<x) del(RC,x);
    else del(LC,x);
}

5、已知键值查询结点排名

已知键值x，求x在树o中的排名。在一棵平衡二叉树中，根结点的排名就是其左子树大小+1。若树的根节点o的键值恰好等于x，则x的排名就是左子树大小+1。若x大于根结点键值，则x的排名=x在右子树中的排名+左子树大小+根结点的元素个数。若x小于根节点键值，就递归到左子树进行查询。

代码：

int getrank(int o,info x) //求键值为x的结点在树o中的排名
{
    if(o==0) return 0;
    if(tree[o].v==x) return tree[LC].s+1;
    else if(tree[o].v<x) return tree[LC].s+tree[o].cnt+getrank(RC,x);
    else getrank(LC,x);
}
 

6、已知排名查询键值

已知排名x，求树o中排名为x的结点键值。类似于5，若树的根节点o的左子树大小+1等于x，根节点的键值就是答案。若树的根节点o的左子树大小小于等于x，则递归到左子树查询。若树的根节点o的左子树大小大于x，则递归到右子树查询排名为x-左子树大小-根节点对应元素个数的键值。

代码：

info getnum(int o,int x) //求树o中第x小的数
{
    info xx;
    if(o==0) return xx;
    if(x<=tree[LC].s) return getnum(LC,x);
    else if(x>tree[LC].s+tree[o].cnt) return getnum(RC,x-tree[LC].s-tree[o].cnt);
    else return tree[o].v;
}

7、维护结点信息

维护结点信息很简单，只需要更新结点的s值即可。树的结构发生变化时需要维护结点信息。

void update(int o) //维护结点o
{
    tree[o].s=tree[LC].s+tree[RC].s+tree[o].cnt;
}

四、例题(BZOJ 1056)

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <algorithm>
#include <ctime>
#include <climits>
#include <map>
 
#define MAXN 250010
#define LC (tree[o].l)
#define RC (tree[o].r)
 
using namespace std;
 
map<string,int>hash;
map<string,int>fenshu;
map<int,string>name;
 
int tot=0; //已经加入玩家个数
 
struct info
{
    int num,time;
    bool operator<(const info &b)const
    {
        if(num!=b.num) return num>b.num;
        else return time<b.time;
    }
    bool operator>(const info &b)const
    {
        if(num!=b.num) return num<b.num;
        else return time>b.time;
    }
    bool operator==(const info &b)const
    {
        return num==b.num&&time==b.time;
    }
};
 
struct node
{
    int s; //该点下的结点个数(包含该点)
    int cnt; //该点的数字个数
    info v; //结点键值
    int l,r; //左右子树
    int rnd; //结点的随机权值
}tree[MAXN];
 
int nCount=0;
int ans;
int root=0;
 
void update(int o) //维护结点o
{
    tree[o].s=tree[LC].s+tree[RC].s+tree[o].cnt;
}
 
void rotateR(int &o) //右旋结点o
{
    int t=LC;
    LC=tree[t].r;
    tree[t].r=o;
    tree[t].s=tree[o].s;
    update(o);
    o=t;
}
 
void rotateL(int &o) //左旋结点o
{
    int t=RC;
    RC=tree[t].l;
    tree[t].l=o;
    tree[t].s=tree[o].s;
    update(o);
    o=t;
}
 
void insert(int &o,info x) //在根节点为o的树中插入键值为x的结点，若存在键值为x的结点，那么增加该结点对应数字个数
{
    if(o==0) //空树,建立新的根结点
    {
        o=++nCount;
        tree[o].s=tree[o].cnt=1;
        tree[o].rnd=rand()*rand();
        tree[o].v=x;
        return;
    }
    tree[o].s++;
    if(x<tree[o].v) //x比根结点键值小，往左子树插
    {
        insert(LC,x);
        if(tree[o].rnd>tree[LC].rnd) //注意维护堆的性质
            rotateR(o);
    }
    else if(x>tree[o].v) //x比根结点键值大，往右子树插，下面操作类似上面
    {
        insert(RC,x);
        if(tree[o].rnd>tree[RC].rnd)
            rotateL(o);
    }
    else //x和根节点键值一样，那么增加根节点对数字个数
        tree[o].cnt++;
}
 
void del(int &o,info x) //在根节点为o的树中删除<一个>键值为x的点
{
    if(o==0) return; //找不到可以删除的结点，退出
    if(tree[o].v==x)
    {
        if(tree[o].cnt>1) tree[o].s--,tree[o].cnt--; //该点对应数字不止1个，不能删除这个结点
        else if(LC==0||RC==0) o=LC+RC; //该点下只含一个儿子，删完这个点用它儿子来代替
        else if(tree[LC].rnd<tree[RC].rnd) rotateR(o),del(o,x); //该点的左儿子权值比右儿子小，要维护堆的性质，右旋根结点o
        else rotateL(o),del(o,x);
        return;
    }
    tree[o].s--;
    if(tree[o].v<x) del(RC,x);
    else del(LC,x);
}
 
int getrank(int o,info x) //求键值为x的结点在树o中的排名
{
    if(o==0) return 0;
    if(tree[o].v==x) return tree[LC].s+1;
    else if(tree[o].v<x) return tree[LC].s+tree[o].cnt+getrank(RC,x);
    else getrank(LC,x);
}
 
info getnum(int o,int x) //求树o中第x小的数
{
    info xx;
    if(o==0) return xx;
    if(x<=tree[LC].s) return getnum(LC,x);
    else if(x>tree[LC].s+tree[o].cnt) return getnum(RC,x-tree[LC].s-tree[o].cnt);
    else return tree[o].v;
}
 
int main()
{
    int n;
    int time=0;
    root=0;
    char in[20];
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
    {
        scanf("%s",in);
        string str(in+1);
        if(in[0]=='+')
        {
            int score;
            scanf("%d",&score);
            if(!hash[str])
            {
                tot++;
                info x;
                x.num=score;
                x.time=++time;
                hash[str]=x.time;
                fenshu[str]=x.num;
                name[x.time]=str;
                insert(root,x);
            }
            else
            {
                info x;
                x.num=fenshu[str];
                x.time=hash[str];
                name[x.time]="0";
                del(root,x);
                x.num=score;
                fenshu[str]=score;
                x.time=++time;
                hash[str]=time;
                name[x.time]=str;
                insert(root,x);
            }
        }
        else
        {
            int ranker=0;
            if(in[1]>='0'&&in[1]<='9')
            {
                int len=strlen(in+1);
                for(int i=1;i<=len;i++)
                {
                    ranker*=10;
                    ranker+=in[i]-'0';
                }
                for(int i=ranker;i<=tot&&i<=ranker+9;i++)
                {
                    if(i!=ranker) cout<<' ';
                    cout<<name[getnum(root,i).time];
                }
                printf("\n");
            }
            else
            {
                info x;
                x.time=hash[str];
                x.num=fenshu[str];
                printf("%d\n",getrank(root,x));
            }
        }
    }
    return 0;
}