普通平衡树代码。。。Treap

应一些人之邀。。。发一篇代码

 #include <iostream>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>

 using namespace std;
 struct node
 {
     int data;
     int key;
     node* ls;
     node* rs;
     int size;

     node()
     {
         key=rand();
     }
 }no[];

 void update(node* now)
 {
     now->size=;
     if (now->ls) now->size+=now->ls->size;
     if (now->rs) now->size+=now->rs->size;
 }

 node* merge(node* a,node* b)
 {
     if (!a) {update(b);return b;}
     if (!b) {update(a);return a;}
     if (a->key<b->key)
     {
         a->rs=merge(a->rs,b);
         update(a);
         return a;
     }
     else
     {
         b->ls=merge(a,b->ls);
         update(b);
         return b;
     }
 }

 struct nodepair
 {
     node* l;
     node* r;

     nodepair(node* a,node* b)
     {
         l=a;
         r=b;
     }
 };

 nodepair split(node* a,int k)
 {
     if (!a) return nodepair(NULL,NULL);
     if (a->data<=k)
     {
         nodepair km=split(a->rs,k);
         a->rs=km.l;
         update(a);
         return nodepair(a,km.r);
     }
     else
     {
         nodepair km=split(a->ls,k);
         a->ls=km.r;
         update(a);
         return nodepair(km.l,a);
     }
 }

 nodepair splitTh(node* a,int k)
 {
     if (!a) return nodepair(NULL,NULL);
     if (!k) return nodepair(NULL,a);
     if (a->ls)
     {
         if (a->ls->size>=k)
         {
             nodepair km=splitTh(a->ls,k);
             a->ls=km.r;
             update(a);
             return nodepair(km.l,a);
         }
         else
         {
             nodepair km=splitTh(a->rs,k-a->ls->size-);
             a->rs=km.l;
             update(a);
             return nodepair(a,km.r);
         }
     }
     else
     {
         nodepair km=splitTh(a->rs,k-);
         a->rs=km.l;
         update(a);
         return nodepair(a,km.r);
     }
 }

 int cnt=-;
 node* insert(node* root,int newdata)
 {
     node* q=&no[++cnt];
     q->data=newdata;
     nodepair km=split(root,newdata);
     return merge(km.l,merge(q,km.r));
 }

 node* delate(node* root,int newdata)
 {
     nodepair km=split(root,newdata-);
     nodepair km2=splitTh(km.r,);
     return merge(km.l,km2.r);
 }

 int getKth(node* now,int k)
 {
     if (!now) return -;
     if (now->ls)
     {
         if (now->ls->size<k-)
             return getKth(now->rs,k-now->ls->size-);
         if (now->ls->size==k-)
             return now->data;
         if (now->ls->size>k-)
             return getKth(now->ls,k);
     }
     else
     {
         if (k==) return now->data;
         return getKth(now->rs,k-);
     }
 }

 node* Search(node* root,int k,int* ans)
 {
     nodepair km=split(root,k-);
     if (km.l)
         *ans=km.l->size+;
     else
         *ans=;
     return merge(km.l,km.r);
 }

 node* getQQ(node* root,int data,int* ans)
 {
     nodepair km=split(root,data-);
     nodepair km2=splitTh(km.l,km.l->size-);
     *ans=km2.r->data;
     return merge(km2.l,merge(km2.r,km.r));
 }

 node* getHJ(node* root,int data,int* ans)
 {
     nodepair km=split(root,data);
     nodepair km2=splitTh(km.r,);
     *ans=km2.l->data;
     return merge(km.l,merge(km2.l,km2.r));
 }

 int main()
 {
     node* root=NULL;
     int n,cmd,k;
     scanf("%d",&n);
     for (int i=;i<=n;++i)
     {
         scanf("%d%d",&cmd,&k);
         if (cmd==){root=insert(root,k);}
         if (cmd==){root=delate(root,k);}
         if (cmd==)
         {
             int ans=;
             root=Search(root,k,&ans);
             printf("%d\n",ans);
         }
         if (cmd==)
         {
             printf("%d\n",getKth(root,k));
         }
         if (cmd==)
         {
             int ans=;
             root=getQQ(root,k,&ans);
             printf("%d\n",ans);
         }
         if (cmd==)
         {
             int ans=;
             root=getHJ(root,k,&ans);
             printf("%d\n",ans);
         }
     }
     return ;
 }