普通平衡树（指针splay）

最早的板子，学自Ez大佬：

 #include<cstdio>
 #include<cstdlib>
 using namespace std;

 class Splay{
 public:
     Splay(){
         root=NULL;
         for(top;top<siez;top++)
             stk[top]=tree+top;
     }
     inline void insert(int val){
         if(find(val)!=NULL)
             ++root->cnt,update(root);
         else    if(root==NULL)
             root=newnode(val,NULL);
         else    splay(insert(root,val),NULL);
     }
     inline void erase(int val){
         if(find(val)!=NULL) erase(root,);
     }
     inline int rnk(int val){
         if(find(val)!=NULL) return size(root->son[])+;
         else    return ;
     }
     inline int qry(int kth){
         if(size(root)<kth)  return ;
         for(node *t=root;t;){
             if(kth>size(t->son[])){
                 kth-=size(t->son[]);
                 if(kth<=t->cnt)
                     return t->v;
                 else    kth-=t->cnt,t=t->son[];
             }
             else    t=t->son[];
         }
     }
     inline int prv(int val){
         int ret=-0x7fffffff;
         for(node *t=root;t;){
             if(t->v<val){
                 if(ret<t->v)
                     ret=t->v;
             }
             t=t->son[val>t->v];
         }
         return ret;
     }
     inline int nxt(int val){
         int ret=0x7fffffff;
         for(node *t=root;t;){
             if(t->v>val){
                 if(ret>t->v)
                     ret=t->v;
             }
             t=t->son[val>=t->v];
         }
         return ret;
     }
 private:
     struct node{
         int v,cnt,siz;
         node *son[],*f;
         node(){son[]=son[]=f=NULL;v=cnt=siz=;}
     }*root;
     const static int siez=;
     node *stk[siez],tree[siez];int top;
     inline node * newnode(int v,node *f){
         node *t=stk[--top];
         t->siz=t->cnt=;t->v=v;
         t->son[]=t->son[]=NULL;
         t->f=f;
         return t;
     }
     inline void freenode(node *t){
         stk[top++]=t;
     }
     inline int size(node* t){
         return t==NULL?:t->siz;
     }
     inline void update(node *t){
         if(t!=NULL)
             t->siz=t->cnt+size(t->son[])+size(t->son[]);
     }

     inline bool son(node* f,node* s){
         if(f==NULL) return ;
         return f->son[]==s;
     }
     inline void connect(node *f,node *s,bool k){
         if(f!=NULL) f->son[k]=s;
         else    root=s;
         if(s!=NULL) s->f=f;
     }
     inline void rotate(node* t){
         node *f=t->f,*g=f->f;
         bool a=son(f,t),b=!a;
         connect(f,t->son[b],a);
         connect(g,t,son(g,f));
         connect(t,f,b);
         update(f);
         update(t);
     }
     inline  void splay(node *t,node *p){
         if(t){
             while(t->f!=p){
                 node *f =t->f,*g=f->f;
                 if(g==p)    rotate(t);
                 else{
                     if(son(g,f)^son(f,t))
                         rotate(t),rotate(t);
                     else
                         rotate(f),rotate(t);
                 }
             }
         }
     }
     inline node *find(int val){
         node *t=root;
         while(t!=NULL &&t->v!=val){
             t=t->son[val>=t->v];
         }
         return splay(t,NULL ),t;
     }
     node *insert(node *t,int val){
         node *ret=t->son[val>=t->v];
         if(ret==NULL)
             ret=t->son[val>=t->v]=newnode(val,t);
         else ret=insert(ret,val);
         return update(t),ret;
     }
     inline void erase(node *t){
         if(t->son[]==NULL)
             connect(NULL ,t->son[],),update(root);
         else    if(t->son[]==NULL){
             connect(NULL,t->son[],),update(root);
         }
         else{
             node *p=t->son[];
             while(p->son[]!=NULL)  p=p->son[];
             splay(p,t);
             connect(NULL,p,);
             connect(p,t->son[],);
             update(root);
         }
         freenode(t);
     }
     inline void erase(node *t ,int k){
         t->cnt-=k;
         if(t->cnt<=)   erase(t);
         else    update(t);
     }
 }s;
 int main(){
     freopen("phs.in","r",stdin);
     freopen("phs.out","w",stdout);
     int n,op,x;
     scanf("%d",&n);
     while(n--){
         scanf("%d%d",&op,&x);
         switch(op){
             case : s.insert(x);
             break;
             case  :s.erase(x);
             break;
             case : printf("%d\n",s.rnk(x));
             break;
             case :printf("%d\n",s.qry(x));
             break;
             case :printf("%d\n",s.prv(x));
             break;
             default:printf("%d\n",s.nxt(x));
             break;
         }
     }
 }

The old

自己修改的板子（其实没变化）：

 #define Troy

 #include "bits/stdc++.h"

 #define inf 0x7fffffff

 using namespace std;

 inline int read(){
     int s=,k=;char ch=getchar();
     while(ch<''|ch>'')    ch=='-'?k=-:,ch=getchar();
     while(ch>&ch<='')    s=s*+(ch^),ch=getchar();
     return s*k;
 }

 const int N=2e5+;

 #define size(t) (t?t->size:0)
 #define son(f,s)    (f?f->son[1]==s:0)
 #define update(t)    (t?t->size=t->cnt+size(t->son[0])+size(t->son[1]):0)

 class Splay{
 public:
     Splay(){for(root=NULL;top<N;++top)   stk[top]=tree+top;}

     inline void insert(int val){
         if(find(val)) ++root->cnt,update(root);
         else    if(root)    splay(insert(root,val),NULL);
         else    root=newnode(val,NULL);
     }

     inline void erase(int val){if(find(val))   erase(root,);}

     inline int rnk(int val){
         if(find(val))   return size(root->son[])+;
         else    return ;
     }

     inline int qry(int kth){
         if(size(root)<kth)  return ;
         for(node *t=root;t;)
             if(kth>size(t->son[])){
                 kth-=size(t->son[])+t->cnt;
                 if(kth<=)  return t->val;
                 else    t=t->son[];
             }else t=t->son[];
     }   

     inline int prv(int val){
         int ret=-inf;
         for(node *t=root;t;t=t->son[val>t->val])
             if(t->val<val&&ret<t->val)  ret=t->val;
         return ret;
     }

     inline int nxt(int val){
         int ret=inf;
         for(node *t=root;t;t=t->son[val>=t->val])
             if(t->val>val&&ret>t->val)  ret=t->val;
         return ret;
     }
 private:
     struct node{
         node *f,*son[];
         int val,cnt,size;
     }tree[N],*root,*stk[N];int top;

     inline node* newnode(int val,node *f){
         node *t=stk[--top];*t=(node){f,NULL,NULL,val,,};
         return t;
     }

     inline void freenode(node *t){stk[top++]=t;}

     inline void connect(node *f,node *s,int k){
         if(f)   f->son[k]=s;else root=s;
         if(s)   s->f=f;
     }

     inline void rotate(node *t){
         node *f=t->f,*g=f->f;int a=son(f,t),b=!a;
         connect(f,t->son[b],a);
         connect(g,t,son(g,f));
         connect(t,f,b);
         update(f),update(t);
     }

     inline void splay(node *t,node *p){
         if(t)for(;t->f!=p;rotate(t))
             if(t->f->f!=p)  rotate(son(t->f,t)==son(t->f->f,t->f)?t->f:t);
     }

     inline node *find(int val){
         node *t=root;
         for(;t&&t->val!=val;t=t->son[val>=t->val]);
         return splay(t,NULL),t;
     }

     inline node *insert(node *t,int val){
         node *ret=t->son[val>=t->val];
         if(ret) ret=insert(ret,val);else    ret=t->son[val>=t->val]=newnode(val,t);
         return update(t),ret;
     }

     inline void erase(node *t){
         if(t->son[]==NULL) connect(NULL,t->son[],);
         else    if(t->son[]==NULL) connect(NULL,t->son[],);
         else    {node *p=t->son[];
             while(p->son[])    p=p->son[];
             splay(p,t);
             connect(NULL,p,),connect(p,t->son[],);
         }update(root),freenode(t);
     }

     inline void erase(node *t,int k){
         t->cnt-=k;
         if(t->cnt<=)   erase(t);else   update(t);
     }
 }s;
 int main(){
     freopen("phs.in","r",stdin);
     freopen("phs.out","w",stdout);
     int n,op,x;
     n=read();
     while(n--){
         op=read(),x=read();
         switch(op){
             case : s.insert(x);
             break;
             case  :s.erase(x);
             break;
             case :printf("%d\n",s.rnk(x));
             break;
             case :printf("%d\n",s.qry(x));
             break;
             case :printf("%d\n",s.prv(x));
             break;
             default:printf("%d\n",s.nxt(x));
             break;
         }
     }
 }