splay树模板

//splay树

#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5+10;
struct splay_tree{
    int fa,cnt,ch[2],val,size;
}t[maxn];
int root,tot;
void update(int x){t[x].size = t[t[x].ch[0]].size + t[t[x].ch[1]].size + t[x].cnt;}
void rotate(int x){
    int y = t[x].fa, z = t[y].fa, k = (t[y].ch[1] == x);//y：父亲 z：祖父 k：0是左儿子1是右儿子
    t[z].ch[(t[z].ch[1] == y)] = x;//Z原来Y的位置变成X
    t[x].fa = z;//X的父亲变为Z
    t[y].ch[k] = t[x].ch[k^1];
    t[t[x].ch[k ^ 1]].fa = y;//更新父节点
    t[x].ch[k ^ 1] = y;//X的 与X原来相对位置的儿子变成 Y
    t[y].fa = x;//更新父节点
    update(y),update(x);
}
void splay(int x,int goal){
    while(t[x].fa!=goal)//一直旋转到x成为goal的儿子
    {
        int y = t[x].fa, z = t[y].fa;//父节点祖父节点
        if (z != goal)//如果Y不是根节点，则分为上面两类来旋转
            (t[z].ch[0] == y) ^ (t[y].ch[0] == x) ? rotate(x) : rotate(y);//判断共线还是不共线
        //这就是之前对于x和y是哪个儿子的讨论
        rotate(x);//无论怎么样最后的一个操作都是旋转x
    }
    if(goal==0)root=x;//如果goal是0，则将根节点更新为x
}
inline void find(int x)//查找x的位置，并将其旋转到根节点
{
    int u = root;
    if (!u)return;//树空
    while(t[u].ch[x > t[u].val] && x != t[u].val)//当存在儿子并且当前位置的值不等于x
        u = t[u].ch[x > t[u].val];//跳转到儿子，查找x的父节点
    splay(u,0);//把当前位置旋转到根节点
}
inline void insert(int x)//插入x
{
    int u = root,fa = 0;//当前位置u，u的父节点ff
    while(u && t[u].val != x){//当u存在并且没有移动到当前的值
        fa = u;//向下u的儿子，父节点变为u
        u = t[u].ch[x>t[u].val];//大于当前位置则向右找，否则向左找
    }
    if(u)//存在这个值的位置
        t[u].cnt++;//增加一个数
    else{//不存在这个数字，要新建一个节点来存放
        u = ++tot;//新节点的位置
        if(fa)//如果父节点非根
            t[fa].ch[x > t[fa].val] = u;
        t[u].ch[0] = t[u].ch[1] = 0;//不存在儿子
        t[tot].fa = fa;//父节点
        t[tot].val = x;//值
        t[tot].cnt = 1;//数量
        t[tot].size = 1;//大小
    }
    splay(u,0);//把当前位置移到根，保证结构的平衡
}
inline int Next(int x,int f)//查找x的前驱(0)或者后继(1)
{
    find(x);
    int u = root;//根节点，此时x的父节点（存在的话）就是根节点
    if(t[u].val > x && f) return u;//如果当前节点的值大于x并且要查找的是后继
    if(t[u].val < x && !f) return u;//如果当前节点的值小于x并且要查找的是前驱
    u = t[u].ch[f];//查找后继的话在右儿子上找，前驱在左儿子上找
    while(t[u].ch[f ^ 1]) u = t[u].ch[f ^ 1];//要反着跳转，否则会越来越大（越来越小）
    return u;//返回位置
}
inline void Delete(int x)//删除x
{
    int last=Next(x,0);//查找x的前驱
    int next=Next(x,1);//查找x的后继
    splay(last,0), splay(next,last);
    //将前驱旋转到根节点，后继旋转到根节点下面
    //很明显，此时后继是前驱的右儿子，x是后继的左儿子，并且x是叶子节点
    int del = t[next].ch[0];//后继的左儿子
    if(t[del].cnt > 1){//如果超过一个
        t[del].cnt--;//直接减少一个
        splay(del,0);//旋转
    }
    else t[next].ch[0]=0;//这个节点直接丢掉（不存在了）
}
inline int kth(int x)//查找排名为x的数
{
    int u = root;//当前根节点
    if(t[u].size < x)//如果当前树上没有这么多数
        return 0;//不存在
    while(1){
        int y = t[u].ch[0];//左儿子
        if(x > t[y].size + t[u].cnt){
            //如果排名比左儿子的大小和当前节点的数量要大
            x -= t[y].size + t[u].cnt;//数量减少
            u = t[u].ch[1];//那么当前排名的数一定在右儿子上找
        }
        else//否则的话在当前节点或者左儿子上查找
        if(t[y].size >= x)//左儿子的节点数足够
            u = y;//在左儿子上继续找
        else//否则就是在当前根节点上
            return t[u].val;
    }
}
int main()
{
    int n;
    scanf("%d",&n);
    insert(1e9);
    insert(-1e9);
    while(n--){
        int opt,x;
        scanf("%d%d",&opt,&x);
        if (opt==1)
            insert(x);
        if (opt==2)
            Delete(x);
        if (opt==3){
            find(x);
            printf("%d\n",t[t[root].ch[0]].size);
        }
        if (opt==4)
            printf("%d\n",kth(x+1));
        if (opt==5)
            printf("%d\n",t[Next(x,0)].val);
        if (opt==6)
            printf("%d\n",t[Next(x,1)].val);
    }
    return 0;
}
/*
插入数值x。
删除数值x(若有多个相同的数，应只删除一个)。
查询数值x的排名(若有多个相同的数，应输出最小的排名)。
查询排名为x的数值。
求数值x的前驱(前驱定义为小于x的最大的数)。
求数值x的后继(后继定义为大于x的最小的数)。
*/