splay的一些操作

秦同学的详细版本

splay就是一种将树上的一个节点经过旋转到节点的一种操作，来保持树的平衡

splay本质：二叉搜索树

特点：结点x的左子树权值都小于x的权值，右子树权值都大于x的权值

如果当前处于共线状态的话,那么先旋转y,再旋转x.这样可以强行让他们不处于共线状态,然后平衡这棵树.
如果当前不是共线状态的话,那么只要旋转x即可.

普通平衡树
基本上每个平台都有的模板题。

为什么要splay？仅仅是插入不是插进去就行吗？成不成为根节点有什么关系？

这是为了查找比x小/大的第一个数做铺垫，因为有可能x在树中没有出现过，所以先插入x，再找前驱/后继，这就可以直接从根节点找起）

splay的旋转操作

void pushup(int u)
{tr[u].size=tr[tr[u].s[1]].size+tr[tr[u].s[0]].size+tr[u].cnt;
}void rotate(int x)
{int y=tr[x].p,z=tr[y].p;int k=tr[y].s[1]==x;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;//第2条线pushup(y),pushup(x);
}

splay操作

void splay(int x,int goal)//将x旋转为goal的儿子，如果goal是0则旋转到根
{while(t[x].ff!=goal)//一直旋转到x成为goal的儿子{int y=t[x].ff,z=t[y].ff;//父节点祖父节点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
}

查找find操作

从根节点开始，左侧都比他小，右侧都比他大，
所以只需要相应的往左/右递归
如果当前位置的val已经是要查找的数
那么直接把他Splay到根节点，方便接下来的操作

void find(int x)//查找x的位置，并将其旋转到根节点
{int u=root;if(!u) return ;//树空while(tr[u].s[x>tr[u].v]&&x!=tr[u].v)//当存在儿子并且当前位置的值不等于xu=tr[u].s[x>tr[u].v];//跳转到儿子，查找x的父节点splay(u,0);//把当前位置旋转到根节点
}

Insert操作

往Splay中插入一个数
类似于Find操作，只是如果是已经存在的数，就可以直接在查找到的节点的进行计数
如果不存在，在递归的查找过程中，会找到他的父节点的位置，
然后就会发现底下没有啦。。。
所以这个时候新建一个节点就可以了

inline void insert(int x)//插入x
{int u=root,ff=0;//当前位置u，u的父节点ffwhile(u&&t[u].val!=x)//当u存在并且没有移动到当前的值{ff=u;//向下u的儿子，父节点变为uu=t[u].ch[x>t[u].val];//大于当前位置则向右找，否则向左找}if(u)//存在这个值的位置t[u].cnt++;//增加一个数else//不存在这个数字，要新建一个节点来存放{u=++tot;//新节点的位置if(ff)//如果父节点非根t[ff].ch[x>t[ff].val]=u;t[u].ch[0]=t[u].ch[1]=0;//不存在儿子t[tot].ff=ff;//父节点t[tot].val=x;//值t[tot].cnt=1;//数量t[tot].size=1;//大小}splay(u,0);//把当前位置移到根，保证结构的平衡
}

前驱/后继操作Next

首先就要执行Find操作
把要查找的数弄到根节点
然后，以前驱为例
先确定前驱比他小，所以在左子树上
然后他的前驱是左子树中最大的值
所以一直跳右结点，直到没有为止
找后继反过来就行了

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;//返回位置
}

删除操作

现在就很简单啦
首先找到这个数的前驱，把他Splay到根节点
然后找到这个数后继，把他旋转到前驱的底下
比前驱大的数是后继，在右子树
比后继小的且比前驱大的有且仅有当前数
在后继的左子树上面，
因此直接把当前根节点的右儿子的左儿子删掉就可以啦

void dele(int x)
{int last=Next(x,0);//找到前驱int next=Next(x,1);//找的后继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;//这个节点直接丢掉（不存在了）
}

查找第K大

从当前根节点开始，检查左子树大小
因为所有比当前位置小的数都在左侧
如果左侧的数的个数多余K，则证明第K大在左子树中
否则，向右子树找，找K-左子树大小-当前位置的数的个数
记住特判K恰好在当前位置

int  kth(int x)//查找排名为x的数
{int u=root;if(tr[u].size<x)//如果当前树上没有这么多数return 0;//不纯在while(true){int y=tr[u].s[0];//左儿子if(x>tr[y].size+tr[u].cnt){//如果排名比左儿子的大小和当前节点的数量要大x-=tr[y].size+tr[u].cnt;u=tr[u].s[1];}else if(tr[y].size>=x)//否则的话在当前节点或者左儿子上查找u=y;else //否则就是在当前根节点上return tr[u].v;}
}

完整代码

#include<bits/stdc++.h>
using namespace std;
const int N=100010;
struct node
{int s[2];int p,v,cnt,size;
}tr[N*4];
int idx,n,m,root;void pushup(int u)
{tr[u].size=tr[tr[u].s[1]].size+tr[tr[u].s[0]].size+tr[u].cnt;
}void rotate(int x)
{int y=tr[x].p,z=tr[y].p;int k=tr[y].s[1]==x;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)
{while(tr[x].p!=k){int y=tr[x].p,z=tr[y].p;if(z!=k)if((tr[y].s[1]==x)^(tr[z].s[1]==y)) rotate(x);else rotate(y);rotate(x);}if(!k) root=x;
}void find(int x)
{int u=root;if(!u) return ;while(tr[u].s[x>tr[u].v]&&x!=tr[u].v)u=tr[u].s[x>tr[u].v];splay(u,0);
}void insert(int x)
{int u=root,p=0;while(u&&tr[u].v!=x)p=u,u=tr[u].s[x>tr[u].v];if(u) tr[u].cnt++;else{u=++idx;if(p) tr[p].s[x>tr[p].v]=u;tr[u].s[1]=tr[u].s[0]=0;tr[u].p=p;tr[u].size=1;tr[u].cnt=1;tr[u].v=x;}splay(u,0);
}int  kth(int x)//查找排名为x的数
{int u=root;if(tr[u].size<x)//如果当前树上没有这么多数return 0;//不纯在while(true){int y=tr[u].s[0];//左儿子if(x>tr[y].size+tr[u].cnt){//如果排名比左儿子的大小和当前节点的数量要大x-=tr[y].size+tr[u].cnt;u=tr[u].s[1];}else if(tr[y].size>=x)//否则的话在当前节点或者左儿子上查找u=y;else //否则就是在当前根节点上return tr[u].v;}
}int Next(int x,int f)
{find(x);int u=root;if(tr[u].v>x&&f) return u;if(tr[u].v<x&&!f) return u;u=tr[u].s[f];//查找后继的话在右儿子上找，前驱在左儿子上找while(tr[u].s[f^1])u=tr[u].s[f^1];//要反着跳转，否则会越来越大（越来越小）return u;
}void dele(int x)
{int last=Next(x,0);//找到前驱int next=Next(x,1);//找的后继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;//这个节点直接丢掉（不存在了）
}int main()
{cin>>n;insert(-1e9);insert(1e9);while(n--){int op,x;cin>>op>>x;if(op==1)insert(x);else if(op==2)dele(x);else if(op==3){find(x);printf("%d\n",tr[tr[root].s[0]].size);}else if(op==4){printf("%d\n",kth(x+1));}else  if (op==5)printf("%d\n",tr[Next(x,0)].v);if (op==6)printf("%d\n",tr[Next(x,1)].v);}return 0;
}