指针实现 Treap

前置知识：二叉排序树，堆。

应用场景：平衡树。

---

〇、导入

1. 二叉排序树

我们都知道，二叉排序树就是满足“\(lch<now<rch\)”（左儿子小于根节点，右儿子大于根节点）的二叉树，一般情况下插入、删除和搜索的时间复杂度都为 \(\Theta(\log n)\) ，非常快。但在特殊情况下，二叉排序树可能会退化成链，时间复杂度也会变为 \(\Theta(n)\) 。只有当二叉排序树平衡时速度最优。

2. 堆

堆也很简单，就是根节点大于子节点的完全二叉树。

3. 平衡树

当二叉排序树退化成链时速度会大打折扣，因此很多毒瘤出题者都喜欢卡它。但是既然能有这种题目，那么肯定就有能解决的方法，当然也不排除出题者自己都没有做出来。二叉排序树平衡时时间复杂度为 \(\Theta(\log n)\) 。所以，若要保证二叉排序树的最大时间复杂度为 \(\Theta(\log n)\) ，就要保证该二叉排序树平衡。这就是是平衡树。

平衡树有很多种，本文就不再赘述，仅讨论 Treap。

4. Treap

二叉排序树和堆都是二叉树。既然堆就是完全二叉树，何不利用它这个性质来保证二叉排序树平衡呢？

于是 Tree(二叉排序树)+Heap(堆)=Treap ，Treap 横空出世！

一、操作&实现

1. 存储

这里我定义了一个结构体 Treap 来封装，然后再 Treap 内又定义了结构体 node ，表示节点。

struct Treap
{
    struct node
    {
        int val,size,times;
        unsigned rd;
        node *ch[2];
    }e[100005],*root,*cnt;
};

解读：

• Treap：表示 Treap。
  • node：表示节点。
    • val：表示该节点所储存的数值。
    • size：表示以该节点为根的子树的大小（节点总数）。
    • times：表示该节点的数值的存在数量。
    • rd：随机优先值。
    • ch：指向子节点的指针。
      • ch[0]：指向左儿子的指针。
      • ch[1]：指向右儿子的指针。
  • e：储存所有节点。
  • root：指向根节点的指针。
  • cnt：指向最后一个插入的节点的指针。

如果没能看懂各变量的作用也没有关系，在后面的操作中会为您一一解答。

2. 操作

2-0 node 的操作

2-0-1 构造函数

node(){}
// 插入节点时用
node(const int &x){val=x,size=times=1,rd=rand(),ch[0]=ch[1]=NULL;}

优化

C++ 自带的 rand 函数速度较慢，我们可以自己写一个 mrand 函数来取代：

inline unsigned mrand()
{
    static unsigned long long tr=431322;
    return unsigned(tr=(tr*76717)%0x100000000);
}

大家可能 static 用得较少，这里就不阐述原理了，感兴趣的可以自行百度。

然后构造函数如下：

node(){}
// 插入节点时用
node(const int &x){val=x,size=times=1,rd=mrand(),ch[0]=ch[1]=NULL;}

2-0-2 更新节点信息

不解释：

inline void pushup()
{
    size=times;
    if(ch[0])   size+=ch[0]->size;
    if(ch[1])   size+=ch[1]->size;
}

现在 node 实现如下：

struct node
{
    int val,size,times;
    unsigned rd;
    node *ch[2];
    node(){}
    node(const int &x){val=x,size=times=1,rd=mrand(),ch[0]=ch[1]=NULL;}
    inline void pushup()
    {
        size=times;
        if(ch[0])   size+=ch[0]->size;
        if(ch[1])   size+=ch[1]->size;
    }
};

下面实现操作的函数均为 Treap 的成员函数。

附：调试函数，输出当前树的详细信息：

// now 表示所操作子树的根节点指针引用，indent 表示当前缩进长度
void output(node *&now,const int &indent)
{
    putchar('>'),putchar(' ');
    for(int i=0;i<indent;++i)   putchar('|'),putchar(' ');
    if(!now)
    {
        puts("NULL");
        return;
    }
    // 输出当前节点的详细信息，可以更改
    printf("%ld:%d %d,%d %u\n",now-e,now->val,now->size,now->times,now->rd);
    output(now->ch[0],indent+1);
    output(now->ch[1],indent+1);
}
// 初始函数（方便调用）
inline void output(){output(root,0);}

2-1 旋转

旋转是很多平衡树常见的操作，分为左旋和右旋。

左旋的操作如下：

右旋的操作与此类似，仅方向不同。事实上，右图中的树右旋后即可得到左图。

实现的代码也很简单：

// now 表示所操作子树的根节点指针引用，d 表示旋转方向（0 表示右旋，1 表示左旋）
// 这里 now 为引用类型，便于更改。
inline void rotate(node *&now,const bool &d)
{
    node *tmp=now->ch[d];           // tmp 指向将成为新的根节点的节点
    now->ch[d]=tmp->ch[!d];
    tmp->ch[!d]=now;
    tmp->pushup(),now->pushup();    // 更新节点信息
    now=tmp;                        // tmp 指向的节点成为新的根节点
}

那么为什么要旋转呢？因为每个节点都会有一个随机优先值，而 Treap 的每个节点的优先值都比其子节点的大，利用堆的思想，使得 Treap 相对平衡。

2-2 插入值为 \(x\) 的节点

Treap 的插入其实就是在二叉排序树的插入的基础上通过旋转保证 Treap 堆的性质。

// now 表示指向当前节点的指针的引用，x 表示要插入的值
// 这里 now 为引用类型，便于更改。
void insert(node *&now,const int &x)
{
    // 如果为空指针
    if(!now)
    {
        *(now=++cnt)=x;     // 插入新节点
        return;
    }
    ++(now->size);          // 因为新节点在以 now 指向的节点为根节点的子树内，所以当前子树的节点数+1
    // 如果当前节点的数值不等于 x
    if(now->val!=x)
    {
        bool d=now->val<x;  // d 为插入的方向（0 为左，1 为右）
        insert(now->ch[d],x);
        // 如果当前节点的子节点的优先值大于当前节点的优先值（即不符合堆的性质）
        if(now->ch[d]->rd>now->rd)  rotate(now,d);  // 旋转以维护堆的性质
    }
    // 否则说明当前节点的数值等于 x
    else    ++(now->times); // 当前节点的数值的存在数量+1
    now->pushup();          // 更新当前节点（之前我没有加上，导致我调了好久的 BUG）
}
// 初始函数（方便调用）
inline void insert(const int &x){insert(root,x);}

2-3 删除值为 \(x\) 的节点

首先找到要删除的节点，然后通过旋转将其下移，直到其没有子节点时之间再将其直接删除。

// now 表示指向当前节点的指针的引用，x 表示要删除的值
// 这里 now 为引用类型，便于更改。
void remove(node *&now,const int &x)
{
    // 如果当前节点不为要删除的节点
    if(now->val!=x) remove(now->ch[now->val<x],x);  // 继续向下寻找
    // 否则说明要删除当前节点
    // 如果当前节点有左儿子并且左儿子的优先值大于右儿子的优先值
    // 则右旋使左儿子代替被删除的节点的位置
    else if(now->ch[0] && (!now->ch[1] || now->ch[0]->rd>now->ch[1]->rd))   rotate(now,0),remove(now->ch[1],x);
    // 否则如果当前节点有右儿子
    // 则左旋使右儿子代替被删除的节点的位置
    else if(now->ch[1]) rotate(now,1),remove(now->ch[0],x);
    // 否则说明当前节点没有子节点
    else
    {
        --(now->size);
        // 如果该节点的存在数量清零了
        if(!--(now->times)) now=NULL;   // 直接删除
        return;
    }
    now->pushup();// 更新当前节点
}
// 初始函数（方便调用）
inline void remove(const int &x){remove(root,x);}

2-4 查询数值为 \(x\) 的节点的排名

这个与二叉排序树的操作一样。

// now 表示指向当前节点的指针的引用，x 表示要查询的值
int getrank(node *&now,const int &x)
{
    // 如果为空指针，说明改数不存在于树中
    if(!now)    return 0;                           // 直接返回 0
    // 如果当前节点的值大于 x
    if(now->val>x)  return getrank(now->ch[0],x);   // 继续搜索左子树
    // 如果当前节点的值小于 x
    // 继续搜索右子树，返回值增加左子树节点数+当前节点存在数量
    if(now->val<x)  return getrank(now->ch[1],x)+(now->ch[0]?now->ch[0]->size:0)+now->times;
    // 否则说明当前节点的值等于 x
    return (now->ch[0]?now->ch[0]->size:0)+1;       // 返回左子树节点数+1
}
// 初始函数（方便调用）
inline int getrank(const int &x){return getrank(root,x);}

2-5 查询排名为 \(x\) 的节点的数值

// now 表示指向当前节点的指针的引用，x 表示要查询的排名
int getval(node *&now,const int x)
{
    static int tmp; // 临时变量，用于储存左子树的节点数+当前节点存在数量，为了节省空间就使用静态变量了
    // 如果当前节点有左儿子且左子树的节点数不小于 x
    // 继续搜索左子树
    if(now->ch[0] && now->ch[0]->size>=x)   return getval(now->ch[0],x);
    // 否则如果当前节点有右儿子且左子树的节点数+当前节点存在数量小于 x
    // 继续搜索右子树中排名为 x-tmp 的节点
    if(now->ch[1] && ((tmp=(now->ch[0]?now->ch[0]->size:0)+now->times)<x))  return getval(now->ch[1],x-tmp);
    // 否则说明当前节点即要查询的节点
    return now->val;// 返回当前节点的数值
}
// 初始函数（方便调用）
inline int getval(const int &x){return getval(root,x);}

2-6 查询数值为 \(x\) 的节点的前驱

// now 表示指向当前节点的指针的引用，x 表示要查询的数值
int getprev(node *&now,const int &x)
{
    // 如果为空指针
    if(!now)    return -0x80000000;                     // 返回负无穷
    // 如果当前节点的数值不小于 x
    // 说明前驱在左子树内
    if(now->val>=x) return getprev(now->ch[0],x);       // 搜索左子树
    // 否则说明前驱为当前节点或在右子树内
    else    return max(now->val,getprev(now->ch[1],x)); // 搜索右子树
}
// 初始函数（方便调用）
inline int getprev(const int &x){return getprev(root,x);}

2-7 查询数值为 \(x\) 的节点的后继

与查询前驱思路相同。

// now 表示指向当前节点的指针的引用，x 表示要查询的数值
int getnext(node *&now,const int &x)
{
    // 如果为空指针
    if(!now)    return 0x7fffffff;                      // 返回负无穷
    // 如果当前节点的数值不大于 x
    // 说明后继在左子树内
    if(now->val<=x) return getnext(now->ch[1],x);       // 搜索左子树
    // 否则说明后继为当前节点或在右子树内
    else    return min(now->val,getnext(now->ch[0],x)); // 搜索右子树
}
// 初始函数（方便调用）
inline int getnext(const int &x){return getnext(root,x);}

二、例题

1. 洛谷 P3369 【模板】普通平衡树

题目链接：https://www.luogu.com.cn/problem/P3369 。

这是一道模板题，没什么好说的，直接上代码：