Template -「平衡树」

Fhq-Treap.

// Fhq-Treap

const int MAXN = 1e5 + 5;

struct Fhq_Treap {
#define Lson Tr[p].l
#define Rson Tr[p].r

    struct Fhq_Node {
        int l, r, Val, Key, Size;
        Fhq_Node () {}
        Fhq_Node (int L, int R, int V, int K, int S) {
            l = L, r = R, Val = V, Key = K, Size = S;
        }
    } Tr[MAXN];
    int Tot, Root;

    Fhq_Treap () { Tot = 0, Root = 0; }

    int Get(int Val) {
        Tr[++Tot] = Fhq_Node (0, 0, Val, rand(), 1);
        return Tot;
    }

    void Pull (int p) { Tr[p].Size = Tr[Lson].Size + Tr[Rson].Size + 1; }

    void Split (int p, int Val, int &x, int &y) {
        if (!p) {
            x = 0, y = 0;
            return;
        }
        if (Tr[p].Val <= Val) 
            x = p, Split (Rson, Val, Rson, y);
        else 
            y = p, Split (Lson, Val, x, Lson);
        Pull (p);
    }

    int Merge (int x, int y) {
        if (!x || !y)
            return x + y;
        if (Tr[x].Key <= Tr[y].Key) {
            Tr[x].r = Merge (Tr[x].r, y), Pull (x);
            return x;
        } 
        else {
            Tr[y].l = Merge (x, Tr[y].l), Pull (y);
            return y;
        }
    }

    void Insert (int Val) {
        int x, y;
        Split (Root, Val, x, y), Root = Merge (Merge (x, Get(Val)), y);
    }

    void Delete (int Val) {
        int x, y, z;
        Split (Root, Val, x, z), Split (x, Val - 1, x, y);
        y = Merge (Tr[y].l, Tr[y].r), Root = Merge (Merge (x, y), z);
    }

    int Get_Rank (int Val) {
        int x, y, Ret;
        Split (Root, Val - 1, x, y);
        Ret = Tr[x].Size + 1, Root = Merge (x, y);
        return Ret;
    }

    int Get_Val (int Rank) {
        int p = Root;
        while (p) {
            if (Tr[Lson].Size + 1 == Rank)
                return Tr[p].Val;
            else if (Rank <= Tr[Lson].Size)
                p = Lson;
            else 
                Rank -= (Tr[Lson].Size + 1), p = Rson;
        }
        return 0;
    }

    int Get_Pre (int Val) {
        int x, y, p;
        Split (Root, Val - 1, x, y), p = x;
        while (Rson) 
            p = Rson;
        int ret = Tr[p].Val;
        Root = Merge (x, y);
        return ret;
    }

    int Get_Next (int Val) {
        int x, y, p;
        Split (Root, Val, x, y), p = y;
        while (Lson) 
            p = Lson;
        int ret = Tr[p].Val;
        Root = Merge (x, y);
        return ret;
    }
    
#undef Lson
#undef Rson
} Tree;

---

Splay.

struct Splay_Tree {
#define Lson Tr[p].Son[0]
#define Rson Tr[p].Son[1]
#define Inf 0x3f3f3f3f

    struct Splay_Node {
        int Son[2], Val, Cnt, Size, Fa;
        Splay_Node () {}
        Splay_Node (int V, int C, int S, int F) {
            Val = V, Cnt = C, Size = S, Fa = F;
        }
    } Tr[MAXN];

    int Tot, Root;

    bool Ident (int p) { return Tr[Tr[p].Fa].Son[1] == p; }

    int Get (int Val, int Fa) {
        Tr[++Tot].Fa = Fa, Tr[Tot].Cnt = Tr[Tot].Size = 1, Tr[Tot].Val = Val;
        return Tot;
    }

    void Pull (int p) { Tr[p].Size = Tr[Lson].Size + Tr[Rson].Size + Tr[p].Cnt; }

    void Build () {
        Root = Get (-Inf, 0);
        Tr[Root].Son[1] = Get (Inf, Root), Pull (Root);
    }

    void Connect (int p, int Fa, int flag) { Tr[Fa].Son[flag] = p, Tr[p].Fa = Fa; }

    void Rotate (int p) {
        int Fa = Tr[p].Fa, Grand = Tr[Fa].Fa;
        int Flag1 = Ident (p), Flag2 = Ident (Fa);
        Connect (p, Grand, Flag2), Connect (Tr[p].Son[Flag1 ^ 1], Fa, Flag1);
        Connect (Fa, p, Flag1 ^ 1), Pull (Fa), Pull (p);
    }

    void Splay (int p, int To) {
        for (int Fa = Tr[p].Fa; Tr[p].Fa != To; Rotate (p), Fa = Tr[p].Fa)
            if (Tr[Fa].Fa != To)
                Ident (p) == Ident (Fa) ? Rotate (Fa) : Rotate (p);
        if (!To)
            Root = p;
    }

    int Find (int p, int Val) {
        if (!p)
            return 0;
        if (Val == Tr[p].Val)
            return p;
        else if (Val < Tr[p].Val)
            return Find (Lson, Val);
        return Find (Rson, Val);
    }

    void Insert (int &p, int Val, int Fa) {
        if (!p)
            Splay (p = Get (Val, Fa), 0);
        else if (Val == Tr[p].Val) 
            ++Tr[p].Cnt, Splay (p, 0);
        else if (Val < Tr[p].Val)
            Insert (Lson, Val, p);
        else
            Insert (Rson, Val, p);
    }

    void Delete(int Val) {
        int p = Find (Root, Val);
        if (!p)
            return;
        if (Tr[p].Cnt > 1) {
            --Tr[p].Cnt, Splay (p, 0), Pull (p);
            return;
        }
        Splay (p, 0);
        int l = Lson, r = Rson;
        while (Tr[l].Son[1]) 
            l = Tr[l].Son[1];
        while (Tr[r].Son[0]) 
            r = Tr[r].Son[0];
        Splay (l, 0), Splay (r, l);
        Tr[r].Son[0] = 0, Pull (r), Pull (l);
    }

    int Get_Rank (int p, int Val) {
        if (!p)
            return 0;
        if (Val == Tr[p].Val) {
            int Res = Tr[Lson].Size + 1; Splay(p, 0);
            return Res;
        } 
        else if (Val < Tr[p].Val)
            return Get_Rank (Lson, Val);
        int Res = Tr[Lson].Size + Tr[p].Cnt;
        return Get_Rank (Rson, Val) + Res;
    }

    int Get_Val (int p, int rank) {
        if (!p)
            return Inf;
        if (Tr[Lson].Size >= rank)
            return Get_Val (Lson, rank);
        else if (Tr[Lson].Size + Tr[p].Cnt >= rank) {
            Splay (p, 0);
            return Tr[p].Val;
        }
        return Get_Val (Rson, rank - Tr[Lson].Size - Tr[p].Cnt);
    }

    int Get_Pre(int Val) {
        int p = Root, Ret;
        while (p) {
            if (Tr[p].Val < Val) 
                Ret = Tr[p].Val, p = Rson;
            else
                p = Lson;
        }
        Splay (Root, 0);
        return Ret;
    }

    int Get_Next(int Val) {
        int p = Root, Ret;
        while (p) {
            if (Tr[p].Val > Val)
                Ret = Tr[p].Val, p = Lson;
            else
                p = Rson;
        }
        Splay (Root, 0);
        return Ret;
    }

#undef Lson
#undef Rson
#undef Inf 0x3f3f3f3f
} Tree;

---

Treap.

// Treap

const int MAXN = 1e5 + 5;

struct Treap_Tree {
#define INF 0x3f3f3f3f
#define mod 998244353
    struct Treap_Node {
        int son[2], val, dat, cnt, size;
#define lson tr[p].son[0]
#define rson tr[p].son[1]
        Treap_Node() {}
        Treap_Node(int Val, int Dat, int Cnt, int Size) {
            val = Val;
            dat = Dat;
            cnt = Cnt;
            size = Size;
        }
    } tr[MAXN];

    int tot, root;

    int Get(int val) {
        tr[++tot] = Treap_Node(val, rand() % mod, 1, 1);
        tr[tot].son[0] = 0;
        tr[tot].son[1] = 0;
        return tot;
    }

    void Update(int p) { tr[p].size = tr[p].cnt + tr[lson].size + tr[rson].size; }

    int Get_Rank(int p, int val) {
        if (!p)
            return 1;
        if (val == tr[p].val)
            return tr[lson].size + 1;
        if (val < tr[p].val)
            return Get_Rank(lson, val);
        return tr[lson].size + tr[p].cnt + Get_Rank(rson, val);
    }

    int Get_Val(int p, int r) {
        if (!p)
            return INF;
        if (tr[lson].size >= r)
            return Get_Val(lson, r);
        if (tr[lson].size + tr[p].cnt >= r)
            return tr[p].val;
        return Get_Val(rson, r - tr[lson].size - tr[p].cnt);
    }

    void Rotate(int &p, int t) {
        int q = tr[p].son[!t];
        tr[p].son[!t] = tr[q].son[t];
        tr[q].son[t] = p;
        p = q;
        Update(tr[p].son[t]);
        Update(p);
    }

    void Insert(int &p, int val) {
        if (!p) {
            p = Get(val);
            return;
        }
        if (val == tr[p].val) {
            tr[p].cnt++;
            Update(p);
            return;
        }
        if (val < tr[p].val) {
            Insert(lson, val);
            if (tr[p].dat < tr[lson].dat)
                Rotate(p, 1);
        } else {
            Insert(rson, val);
            if (tr[p].dat < tr[rson].dat)
                Rotate(p, 0);
        }
        Update(p);
    }

    int Get_Pre(int x) {
        int p = root, ret = -INF;
        while (p) {
            if (tr[p].val <= x) {
                ret = tr[p].val;
                p = rson;
            } else
                p = lson;
        }
        return ret;
    }

    int Get_Next(int x) {
        int p = root, ret = INF;
        while (p) {
            if (tr[p].val >= x) {
                ret = tr[p].val;
                p = lson;
            } else
                p = rson;
        }
        return ret;
    }

    void Delete(int &p, int val) {
        if (!p)
            return;
        if (val == tr[p].val) {
            if (tr[p].cnt > 1) {
                tr[p].cnt--;
                Update(p);
                return;
            }
            if (lson || rson) {
                if (rson == 0 || tr[lson].dat > tr[rson].dat) {
                    Rotate(p, 1);
                    Delete(rson, val);
                } else {
                    Rotate(p, 0);
                    Delete(lson, val);
                }
                Update(p);
            } else
                p = 0;
            return;
        }
        if (val < tr[p].val)
            Delete(lson, val);
        else
            Delete(rson, val);
        Update(p);
    }
#undef lson
#undef rson
} tree;