BST—平衡树

Treap尽心尽力

对于treap来说， 使用随机数的方式使数据被打乱， 利用平衡树的旋转达到简化访问的目的。（初步理解）

#include <cstdio>
#include <algorithm>
#include <iostream>
#define il inline
#define rg register int
#define ll long long
#define ls(x) ch[x][0]
#define rs(x) ch[x][1]

using namespace std;

il int read()
{
    int x = 0; char c; bool f = false;
    while (!isdigit(c = getchar()))if (c == '-')f = true;
    do
    {
        x = (x << 1) + (x << 3) + (c ^ 48);
    }while (isdigit(c = getchar()));
    return f ? -x : x;
}

const int N = 1e5 + 10;
const int inf  = 1e9;
int n, tot, root;
int ch[N][2], val[N], size[N], pro[N], cnt[N];

int neww (int x)
{
    val[++tot] = x;
    pro[tot] = rand();
    size[tot] = 1;
    cnt[tot] = 1;
    return tot;
}

void pushup (int x)
{
    size[x] = size[ls (x)] + size[rs (x)] + cnt[x];
    return ;
}

void build ()
{
    root = neww (-inf);
    rs (root) = neww (inf);
    pushup (root);
}

void rotate (int &x, int d)
{
    int son = ch[x][d ^ 1];
    ch[x][d ^ 1] = ch[son][d];
    ch[son][d] = x;
    pushup (x); pushup (x = son);
}

void insert (int &x , int vl)
{
    if (!x)
    {
        x = neww (vl);
        return;
    }
    if (vl == val[x]) ++ cnt[x];
    else
    {
        int d = val[x] < vl;
        insert (ch[x][d], vl);
        if (pro[x] < pro[ch[x][d]])rotate (x, d ^ 1);
    }
    pushup (x);
}

void del (int &x, int vl)
{
    if (!x)return;
    if (vl == val[x])
    {
        if (cnt[x] > 1)
        {
            --cnt[x];
            pushup (x);
            return;
        }
        if (ls (x) || rs (x))
        {
            if (!rs (x) || pro[ls (x)] > pro[rs (x)])
            {
                rotate (x, 1);
                del (rs (x), vl);
            }
            else
            {
                rotate (x, 0);
                del (ls (x), vl);
            }
            pushup (x);
        }
        else x = 0;
        return;
    }
    int d = vl < val[x];
    del (ch[x][d ^ 1], vl);
    pushup (x);
    return;
}

int rk (int x, int vl)
{
    if (!x)return 0;
    if (vl == val[x])return size[ls (x)] + 1;
    if (vl < val[x])return rk (ls (x), vl);
    return size[ls (x)] + cnt[x] + rk (rs (x), vl);
}

int vval (int x, int r)
{
    if (!x)return inf;
    if (r <= size[ls (x)])return vval (ls (x), r);
    if (r <= size[ls (x)] + cnt[x])return val[x];
    return vval (rs (x), r - size[ls (x)] - cnt[x]);
}

int pre (int vl)
{
    int x = root, ti;
    while (x)
    {
        if (val[x] < vl)ti = val[x], x = rs (x);
        else x = ls (x);
    }
    return ti;
}

int next (int vl)
{
    int x = root, ti;
    while (x)
    {
        if (val[x] > vl)ti = val[x], x = ls (x);
        else x = rs (x);
    }
    return ti;
}

int main()
{
    build();
    n = read();
    for (rg i = 1; i <= n; ++i)
    {
        int opt = read(), x = read();
        if (opt == 1)insert (root, x);
        else if (opt == 2)del (root, x);
        else if (opt == 3)printf ("%d\n", rk (root, x) - 1);
        else if (opt == 4)printf ("%d\n", vval (root, x + 1));
        else if (opt == 5)printf ("%d\n", pre (x));
        else printf ("%d\n", next (x));
    }
    return 0;
}

18:51:24

标签：return,rs,BST,vl,int,ls,平衡,define
来源： https://www.cnblogs.com/zyhLambons/p/16342504.html