splay模板复习

splay模板
记得加哨兵！！！

#include <bits/stdc++.h>

using namespace std;
//-----pre_def----
const double PI = acos(-1.0);
const int INF = 0x3f3f3f3f;
typedef long long LL;
typedef unsigned long long ULL;
typedef pair<int, int> PII;
typedef pair<double, double> PDD;
#define fir(i, a, b) for (int i = (a); i <= (b); i++)
#define rif(i, a, b) for (int i = (a); i >= (b); i--)
#define endl '\n'
#define init_h memset(h, -1, sizeof h), idx = 0;
#define lowbit(x) x &(-x)

//---------------
const int N = 1e5 + 10;

struct node
{
    int s[2], p, v; //s[0]==lson,s[1]==rson,p=pre,v=val（注意：splay中的val不作为排序依据，只在初始状态下有序）
    int size, cnt;  //size==包括自身在内的子树的节点数
    //int lz;//懒标记，可以记录翻转信息
    void init(int _v, int _p)
    {
        v = _v;
        p = _p;
        size = 1;
        cnt = 1;
    }
} tr[N];
int n, m, root, idx;

//功能函数
void pushup(int u);       //由子向父更新
void rotate(int x);       //核心函数1：将所有情况的左旋右旋写在一个函数里面
void splay(int x, int k); //核心函数2：将x节点旋转至k下面,如果k是0则旋转到根
void find(int v);         //查找v的位置，并将其旋转到根节点
void insert(int v);       //插入v
int find_pre(int v);      //查找v的前驱的节点编号
int find_ne(int v);       //查找v的后继的节点编号
void del(int v);          //删除值为v
int find_k(int k);        //查找排名为k的数
void del(int l, int r);   //删除值在[l~r]的所有点
//over
void pushup(int u)
{
    tr[u].size = tr[tr[u].s[0]].size + tr[tr[u].s[1]].size + tr[u].cnt;
}
void rotate(int x) //核心函数1：将所有情况的左旋右旋写在一个函数里面
{
    int y = tr[x].p, z = tr[y].p; //在这个链上：z是祖宗，y是爸爸，x是儿子。现在要把x移动到最上边
    int k = tr[y].s[1] == x;      // k=0表示x是y的左儿子；k=1表示x是y的右儿子
    tr[z].s[tr[z].s[1] == y] = x;
    tr[x].p = z;
    tr[y].s[k] = tr[x].s[k ^ 1];
    tr[tr[x].s[k ^ 1]].p = y;
    tr[x].s[k ^ 1] = y;
    tr[y].p = x;
    pushup(y), pushup(x); //顺序不能乱
}
void splay(int x, int k) //核心函数2：将x节点旋转至k下面,如果k是0则旋转到根
{
    while (tr[x].p != k) //但x的父节点不为k时
    {
        int y = tr[x].p, z = tr[y].p;
        if (z != k) //x的祖宗还不是k
        {
            if ((tr[y].s[1] == x) ^ (tr[z].s[1] == y)) //异或，当zyx不为一条直链的时候
            {
                rotate(x);
            }
            else
            {
                rotate(y);
            }
        }
        rotate(x);
    }
    if (!k) //如果k==0，等加于将x旋转至root
        root = x;
}
void find(int v) //查找v的位置，并将其旋转到根节点(此时左子树的size就是v的排名)
{
    int u = root;
    if (!u)
        return;                                  //树空
    while (tr[u].s[v > tr[u].v] && v != tr[u].v) //当存在儿子并且当前位置的值不等于x
        u = tr[u].s[v > tr[u].v];                //跳转到儿子，查找x的父节点
    splay(u, 0);                                 //把当前位置旋转到根节点
}
void insert(int v) //插入一个数
{
    int u = root, p = 0;
    while (u && v != tr[u].v) //找到应该要插入的位置
    {
        p = u, u = tr[u].s[v > tr[u].v];
    }
    if (u)
    {
        tr[u].cnt++;
    }
    else
    {
        u = ++idx;
        if (p)
            tr[p].s[v > tr[p].v] = u;
        tr[u].init(v, p);
    }
    splay(u, 0);
}

void del(int v) //删除值为v
{
    int last = find_pre(v); //查找x的前驱
    int next = find_ne(v);  //查找x的后继
    splay(last, 0);
    splay(next, last);
    //将前驱旋转到根节点，后继旋转到根节点下面
    //很明显，此时后继是前驱的右儿子，x是后继的左儿子，并且x是叶子节点
    int del = tr[next].s[0]; //后继的左儿子
    if (tr[del].cnt > 1)     //如果超过一个
    {
        tr[del].cnt--; //直接减少一个
        splay(del, 0); //旋转
    }
    else
        tr[next].s[0] = 0; //这个节点直接丢掉（不存在了）
	pushup(next),pushup(last);
}
void del(int l,int r) //删除值在[l~r]的所有点
{
    int last = find_pre(l); //查找x的前驱
    int next = find_ne(r);  //查找x的后继
    splay(last, 0);
    splay(next, last);
    tr[next].s[0] = 0; //这个节点直接丢掉（不存在了）
    pushup(next),pushup(last);
}

int find_pre(int v) //查找v的前驱的节点编号
{
    find(v);
    int u = root; //根节点，此时x的父节点（存在的话）就是根节点
    if (tr[u].v < v)
        return u;   //如果当前节点的值小于x并且要查找的是前驱
    u = tr[u].s[0]; //查找后继的话在右儿子上找，前驱在左儿子上找
    while (tr[u].s[1])
        u = tr[u].s[1]; //要反着跳转，否则会越来越大（越来越小）
    return u;           //返回位置
}
int find_ne(int v) //查找v的后继的节点编号
{
    find(v);
    int u = root; //根节点，此时x的父节点（存在的话）就是根节点
    if (tr[u].v > v)
        return u;   //如果当前节点的值小于x并且要查找的是前驱
    u = tr[u].s[1]; //查找后继的话在右儿子上找，前驱在左儿子上找
    while (tr[u].s[0])
        u = tr[u].s[0]; //要反着跳转，否则会越来越大（越来越小）
    return u;           //返回位置
}
int find_k(int k) //查找排名为k的数
{
    int u = root;       //当前根节点
    if (tr[u].size < k) //如果当前树上没有这么多数
        return 0;       //不存在
    while (1)
    {
        int y = tr[u].s[0]; //左儿子
        if (k > tr[y].size + tr[u].cnt)
        //如果排名比左儿子的大小和当前节点的数量要大
        {
            k -= tr[y].size + tr[u].cnt; //数量减少
            u = tr[u].s[1];              //那么当前排名的数一定在右儿子上找
        }
        else                     //否则的话在当前节点或者左儿子上查找
            if (tr[y].size >= k) //左儿子的节点数足够
            u = y;               //在左儿子上继续找
        else                     //否则就是在当前根节点上
            return tr[u].v;
    }
}
int main()
{
#ifndef ONLINE_JUDGE
    freopen("in.txt", "r", stdin);
    freopen("out.txt", "w", stdout);
    int StartTime = clock();
#endif
    int T = 1, op, x;
    insert(INF);
    insert(-INF);
    scanf("%d", &T);
    while (T--)
    {
        scanf("%d%d", &op, &x);
        if (op == 1)
        {
            insert(x);
        }
        else if (op == 2)
        {
            del(x);
        }
        else if (op == 3)
        {
            find(x);
            printf("%d\n", tr[tr[root].s[0]].size);
        }
        else if (op == 4)
        {
            printf("%d\n", find_k(x + 1));
        }
        else if (op == 5)
        {

            printf("%d\n", tr[find_pre(x)].v);
        }
        else if (op == 6)
        {
            printf("%d\n", tr[find_ne(x)].v);
        }else
        {
            int r;
            scanf("%d",&r);
            del(x,r);
        }
    }
#ifndef ONLINE_JUDGE
    printf("Run_Time = %d ms\n", clock() - StartTime);
#endif
    return 0;
}