旋转/非旋转treap的简单操作

treap（树堆）

是在二叉搜索树的基础上，通过维护随机附加域，使其满足堆性质，从而使树相对平衡的二叉树；

为什么可以这样呢？

因为在维护堆的时候可以同时保证搜索树的性质；

（比如当一棵树的一个域满足堆的性质时，只要不断的互换左右，她的另一个域总会满足搜索树的性质）

（当一棵树的一个域满足搜索树的性质时，只要不断的上下旋转，她的另一个域总会满足二叉堆的性质）

于是树堆有两种实现：

旋转treap:

她的操作基于旋转；

注意：当存在相同val时，对于旋转treap，是存在一个节点中的；

roll（旋转操作）

交换点x与她的x.ch(i)：

fa(x).ch(i)=x.ch(i);

x.ch(i)=x.ch(i).ch(i^1);

x.ch(i).ch(i^1)=x;

以上操作是一个改变上下位置却不影响搜索树性质的方法，与splay类似；

 void roll(int &now){
     int wh=data[data[now].ch[]].key<data[data[now].ch[]].key?:;
     int son=data[now].ch[wh];
     data[now].ch[wh]=data[son].ch[wh^];
     data[son].ch[wh^]=now;
     up(now);
     now=son;
 }

insert（插入操作）

普通的搜索树的插入操作，是插入一个叶子；

普通的堆也是插入一个叶子，然后再把她旋转到相应的位置上；

这样的话，只要按搜索树的法则插入一个节点，然后再以不影响搜索树性质的方式把她旋转到符合堆性质的位置即可；

 void insert(int &now){
     if(now==){
         now=make_data(x);
         return;
     }
     if(data[now].value==x){
         data[now].cnt++;
         data[now].size++;
     }
     else{
         int wh=x < data[now].value ?  : ;
         insert(data[now].ch[wh]);
         if(data[now].key>=data[data[now].ch[wh]].key)
             roll(now);
     }
     up(now);
 }

del(删除操作)

与堆类似的；

把她通过旋转操作下沉到叶子节点，然后再断开即可；

 void del(int &now){
     if(data[now].value==x){
         if(data[now].cnt==){
             if(data[now].ch[]*data[now].ch[]==){
                 now=data[now].ch[]+data[now].ch[];
                 return ;
             }
             roll(now);
             int wh=data[data[now].ch[]].value==x?:;
             del(data[now].ch[wh]);
         }
         else{
             data[now].size--;    data[now].cnt--;
         }
     }
     else{
         int wh=data[now].value>x?:;
         del(data[now].ch[wh]);
     }
     up(now);
 }

这两个操作是与堆流程类似的操作（虽然作为c++党我不写堆）；

还有寻找Kth number，寻找rank,寻找last、next等等与平衡树相关的操作，不在此处赘述；

局限性：不能完成区间操作；

有关代码：

洛谷P3369 【模板】普通平衡树

 #include<cstdio>
 #include<cstdlib>
 using namespace std;
 #define INF 2147483647
 int n;
 struct poo
 {
     int size,value,key,cnt;
     int ch[];
 }data[];
 int tot,root,x;
 int  make_data(int );
 void insert(int&);
 void roll(int&);
 int  find(    );
 int  rank(    );
 void del(int&);
 int  las(int );
 int  nex(int );
 void up(int );
 int main()
 {
     int i,j;
     data[].value=INF;data[].key=INF;
     scanf("%d",&n);
     for(i=;i<=n;i++){
         scanf("%d%d",&j,&x);
         switch(j){
             case :insert(root);break;
             case :   del(root);break;
             case :  printf("%d\n",rank(    ));break;
             case :  printf("%d\n",find(    ));break;
             case :  printf("%d\n", las(root));break;
             case :  printf("%d\n", nex(root));break;
         }
     }
     return ;
 }
 int make_data(int value){
     tot++;
     data[tot].cnt++;
     data[tot].key=(rand()/+rand()/);
     data[tot].size=;
     data[tot].value=value;
     return tot;
 }
 void insert(int &now){
     if(now==){
         now=make_data(x);
         return;
     }
     if(data[now].value==x){
         data[now].cnt++;
         data[now].size++;
     }
     else{
         int wh=x < data[now].value ?  : ;
         insert(data[now].ch[wh]);
         if(data[now].key>=data[data[now].ch[wh]].key)
             roll(now);
     }
     up(now);
 }
 void roll(int &now){
     int wh=data[data[now].ch[]].key<data[data[now].ch[]].key?:;
     int son=data[now].ch[wh];
     data[now].ch[wh]=data[son].ch[wh^];
     data[son].ch[wh^]=now;
     up(now);
     now=son;
 }
 int find(){
     int now=root;
     int ls,rs;
     ls=data[now].ch[];rs=data[now].ch[];
     while(x<=data[ls].size||x>data[now].size-data[rs].size){
         if(data[ls].size>=x)
             now=ls;
         else{
             x=x+data[rs].size-data[now].size;
             now=rs;
         }
         ls=data[now].ch[];rs=data[now].ch[];
     }
     return data[now].value;
 }
 int rank(){
     int now=root,ans=;
     int ls=data[now].ch[],rs=data[now].ch[];
     while(x!=data[now].value&&x!=)
     {
         if(x<data[now].value)
             now=ls;
         else{
             ans+=data[now].size-data[rs].size;
             now=rs;
         }
         ls=data[now].ch[];rs=data[now].ch[];
     }
     return ans+data[ls].size+;
 }
 void del(int &now){
     if(data[now].value==x){
         if(data[now].cnt==){
             if(data[now].ch[]*data[now].ch[]==){
                 now=data[now].ch[]+data[now].ch[];
                 return ;
             }
             roll(now);
             int wh=data[data[now].ch[]].value==x?:;
             del(data[now].ch[wh]);
         }
         else{
             data[now].size--;    data[now].cnt--;
         }
     }
     else{
         int wh=data[now].value>x?:;
         del(data[now].ch[wh]);
     }
     up(now);
 }
 int las(int now){
     int ans=,an=;
     if(!now)return ;
     if(data[now].value<x){
         ans=data[now].value;
         an=las(data[now].ch[]);
         ans=an!=?an:ans;
     }
     else{
         ans=las(data[now].ch[]);
     }
     return ans;
 }
 int nex(int now){
     int ans=,an=;
     if(!now)return ;
     if(data[now].value>x){
         ans=data[now].value;
         an=nex(data[now].ch[]);
         ans=an!=?an:ans;
     }
     else{
         ans=nex(data[now].ch[]);
     }
     return ans;
 }
 void up(int now){
     data[now].size=data[data[now].ch[]].size+data[data[now].ch[]].size+data[now].cnt;
 }
 //treap on the 2017.1.21
 //10
 //1 5
 //4 1
 //1 6
 //1 7
 //1 10
 //1 3
 //1 4
 //6 2
 //1 8
 //5 9
 //
 //14
 //1 5
 //1 6
 //1 7
 //1 10
 //1 3
 //1 4
 //1 8
 //3 3
 //3 4
 //3 5
 //3 6
 //4 5
 //4 6
 //4 7

非旋转treap

同样是树堆，旋转treap通过与堆类似的旋转操作维护，但非旋转treap，通过与平衡树类似的拆分|合并操作完成；

注意：当存在相同val时，对于非旋转treap，是存在不同节点中的；

split(拆分操作)

这里介绍按value拆分（还有按排名拆分不讲）

首先预留两个变量名作为两棵树的树根名；

然后从原树根开始，按查找value为k的点的方法往下走，对于每一个走到的点，她大于value则属于右树，否则属于左树，

因为是从上往下走的，所以后进入树的点是先入者的子节点（符合堆性质）

因为当x.val>value时下一步走x.ls，之后的点全比x小,所以把x接到右树后，下一个接入右树的点——不管是谁——应当变成x的左儿子；

对x.val≤value，也是相似的；

 void split(int now,int&ltr,int&rtr,int value){
     if(!now){
         ltr=rtr=;
         return;
     }
     if(data[now].val<=value)
         ltr=now,split(data[now].ch[],data[ltr].ch[],rtr,value);
     else
         rtr=now,split(data[now].ch[],ltr,data[rtr].ch[],value);
     up(now);
 }

merge(合并操作)

这里介绍当treapA的所有节点val小于treapB时的操作（即通常使用的操作）

可以看出只要把A的右链和B的左链，拆开，按符合堆上下顺序排好，再连上符合搜索树的父子关系即可；

因为AB分别满足堆性质，所以所谓的“按符合堆上下顺序排好”，只要互相参差插入即可，不改变A，B各自的相对上下顺序；

连父子关系时，属于A树的点需要连一个rs(因为排在她下方的点都比她大)属于B树的点需要连一个ls(因为排在她下方的点都比她小)

实现是递归的

merge( &now , a , b )-->( a.key < b.key ? ( now=a.rs , merge( &now.rs , a.rs , b ) ) : ( now=b.ls , merge( &now.ls , a , b.ls ) ) );

 void merge(int&now,int s,int b){
     if(!s||!b){
         now=s+b;return;
     }
     if(data[s].key<data[b].key)
         now=s,merge(data[now].ch[],data[s].ch[],b);
     else
         now=b,merge(data[now].ch[],s,data[b].ch[]);
     up(now);
 }

insert(value)：把树split成A树≤value,B树>value，然后建一个value的点x,然后merge(root,A,x),merge(root,root,B);

del(value):把树拆成三部分，中间是等于value的点——把这部分的点减少一个，然后再合并树的三部分；

非旋转treap是一种非常好的平衡树，她有treap的优良性质——常数比Splay小，而且还支持区间操作和可持久化，

重点是代码短

唯一的缺点的是不好理解

有关代码：

洛谷P3369 【模板】普通平衡树

 #include<cstdio>
 #include<cstdlib>
 using namespace std;
 const int INF=;
 struct Treap{
     int val,key,size;
     int ch[];
 }data[];
 int root,tot;
 void make_data(int&,int );
 void up(int );
 void merge(int&,int,int);
 void split(int ,int&,int&,int );
 void insert(int );
 void del(int );
 void rank(int );
 void find(int ,int );
 int  las(int );
 int  nex(int );
 int main()
 {
     srand(2.17);
     int i,j,k,m;
     root=;data[].key=INF;data[].val=INF;data[].size=;
     scanf("%d",&m);
     for(i=;i<=m;i++){
         scanf("%d%d",&j,&k);
         if(j==)insert(k);
         if(j==)del(k);
         if(j==)rank(k);
         if(j==)find(root,k);
         if(j==)las(k);
         if(j==)nex(k);
     }
     return ;
 }
 void make_data(int&now,int value){
     data[++tot].val=value;data[tot].key=rand();
     data[tot].size=;
     data[tot].ch[]=data[tot].ch[]=;
     now=tot;
 }
 void up(int now){
     data[now].size=data[data[now].ch[]].size+data[data[now].ch[]].size+;
 }
 void merge(int&now,int s,int b){
     if(!s||!b){
         now=s+b;return;
     }
     if(data[s].key<data[b].key)
         now=s,merge(data[now].ch[],data[s].ch[],b);
     else
         now=b,merge(data[now].ch[],s,data[b].ch[]);
     up(now);
 }
 void split(int now,int&ltr,int&rtr,int value){
     if(!now){
         ltr=rtr=;
         return;
     }
     if(data[now].val<=value)
         ltr=now,split(data[now].ch[],data[ltr].ch[],rtr,value);
     else
         rtr=now,split(data[now].ch[],ltr,data[rtr].ch[],value);
     up(now);
 }
 void insert(int value){
     int x=,y=,z=;
     make_data(z,value);
     split(root,x,y,value);
     merge(x,x,z);
     merge(root,x,y);
 }
 void del(int value){
     int x=,y=,z=;
     split(root,x,y,value);
     split(x,x,z,value-);
     merge(z,data[z].ch[],data[z].ch[]);
     merge(x,x,z);merge(root,x,y);
 }
 void rank(int value){
     int x=,y=;
     split(root,x,y,value-);
     printf("%d\n",data[x].size+);
     merge(root,x,y);
 }
 void find(int now,int x){
     while(data[data[now].ch[]].size+!=x){
         if(data[data[now].ch[]].size>=x)
             now=data[now].ch[];
         else
             x-=(data[data[now].ch[]].size+),now=data[now].ch[];
     }
     printf("%d\n",data[now].val);
 }
 int  las(int value){
     int x=,y=;
     split(root,x,y,value-);
     find(x,data[x].size);
     merge(root,x,y);
 }
 int  nex(int value){
     int x=,y=;
     split(root,x,y,value);
     find(y,);
     merge(root,x,y);
 }