Treap 版：

查詢操作是最簡單的，就是二叉搜索樹。左旋右旋畫一畫就好了。

最近代碼能力下降，碼一碼模板QAQ

  1 #include<ctime>
  2 #include<cstdio>
  3 #include<cstring>
  4 #include<cstdlib>
  5 #include<algorithm>
  6 using namespace std;
  7 struct pnt{
  8     int val;
  9     int l;
 10     int r;
 11     int rdm;
 
 12     int num;
 13     int    wgt;
 14 };
 15 struct treap{
 16     pnt tr[1000000];
 17     int siz;
 18     int root;
 19     int ans;
 20     void Tupdate(int spc)
 21     {
 22         tr[spc].wgt=tr[tr[spc].l].wgt+tr[tr[spc].r].wgt+tr[spc].num;
 23         return ;
 24     }
 25     void Trturn(int &spc)
 
 26     {
 27         int tmp=tr[spc].r;
 28         tr[spc].r=tr[tmp].l;
 29         tr[tmp].l=spc;
 30         tr[tmp].wgt=tr[spc].wgt;
 31         Tupdate(spc);
 32         spc=tmp;
 33     }
 34     void Tlturn(int &spc)
 35     {
 36         int tmp=tr[spc].l;
 37         tr[spc].l=tr[tmp].r;
 
 38         tr[tmp].r=spc;
 39         tr[tmp].wgt=tr[spc].wgt;
 40         Tupdate(spc);
 41         spc=tmp;
 42     }
 43     void Tinsert(int &spc,int v)
 44     {
 45         if(spc==0)
 46         {
 47             spc=++siz;
 48             tr[spc].val=v;
 49             tr[spc].num=tr[spc].wgt=1;
 50             tr[spc].rdm=rand();
 51             return ;
 52         }
 53         tr[spc].wgt++;
 54         if(tr[spc].val==v)
 55         {
 56             tr[spc].num++;
 57         }else if(tr[spc].val>v)
 58         {
 59             Tinsert(tr[spc].l,v);
 60             if(tr[spc].rdm>tr[tr[spc].l].rdm)
 61                 Tlturn(spc);
 62         }else{
 63             Tinsert(tr[spc].r,v);
 64             if(tr[spc].rdm>tr[tr[spc].r].rdm)
 65                 Trturn(spc);
 66         }
 67     }
 68     void Tdelete(int &spc,int v)
 69     {
 70         if(spc==0)
 71             return ;
 72         if(tr[spc].val==v)
 73         {
 74             if(tr[spc].num>1)
 75             {
 76                 tr[spc].wgt--;
 77                 tr[spc].num--;
 78                 return ;
 79             }
 80             if(tr[spc].num==1)
 81             {
 82                 if(tr[spc].l*tr[spc].r==0)
 83                 {
 84                     spc=tr[spc].l+tr[spc].r;
 85                 }else{
 86                     if(tr[tr[spc].l].rdm>tr[tr[spc].r].rdm)
 87                     {
 88                         Trturn(spc);
 89                         Tdelete(spc,v);
 90                     }else{
 91                         Tlturn(spc);
 92                         Tdelete(spc,v);
 93                     }
 94                 }
 95                 return ;
 96             }
 97             
 98         }else if(tr[spc].val>v)
 99         {
100             tr[spc].wgt--;
101             Tdelete(tr[spc].l,v);
102         }else{
103             tr[spc].wgt--;
104             Tdelete(tr[spc].r,v);
105         }
106     }
107     int Trank(int spc,int v)
108     {    
109         if(!spc)
110         {
111             return 0;
112         }
113         if(tr[spc].val==v)
114         {
115             return tr[tr[spc].l].wgt+1;
116         }else if(tr[spc].val>v)
117         {
118             return Trank(tr[spc].l,v);
119         }else{
120             return Trank(tr[spc].r,v)+tr[spc].num+tr[tr[spc].l].wgt;
121         }
122     }
123     int Tnum(int spc,int rnk)
124     {
125         if(!spc)
126         {
127             return 0;
128         }
129         if(tr[tr[spc].l].wgt>=rnk)
130         {
131             return Tnum(tr[spc].l,rnk);
132         }else if(tr[spc].num+tr[tr[spc].l].wgt<rnk)
133         {
134             return Tnum(tr[spc].r,rnk-tr[spc].num-tr[tr[spc].l].wgt);
135         }else{
136             return tr[spc].val;
137         }
138     }
139     void Tlasmx(int spc,int v)
140     {
141         if(!spc)
142             return ;
143         if(tr[spc].val>=v)
144         {
145             Tlasmx(tr[spc].l,v);
146         }else{
147             ans=tr[spc].val;
148             Tlasmx(tr[spc].r,v);
149         }
150         return ;
151     }
152     void Tnxtmn(int spc,int v)
153     {
154         if(!spc)
155             return ;
156         if(tr[spc].val<=v)
157         {
158             Tnxtmn(tr[spc].r,v);
159         }else{
160             ans=tr[spc].val;
161             Tnxtmn(tr[spc].l,v);
162         }
163         return ;
164     }
165     void Trun(int opt,int x)
166     {
167         switch(opt)
168         {
169             case 1:
170                 Tinsert(root,x);
171                 break;
172             case 2:
173                 Tdelete(root,x);
174                 break;
175             case 3:
176                 printf("%d\n",Trank(root,x));
177                 break;
178             case 4:
179                 printf("%d\n",Tnum(root,x));
180                 break;
181             case 5:
182                 ans=0;    
183                 Tlasmx(root,x);
184                 printf("%d\n",ans);
185                 break;
186             case 6:
187                 ans=0;
188                 Tnxtmn(root,x);
189                 printf("%d\n",ans);
190                 break;
191         }
192     }
193 }T;
194 int n,opt,x;
195 int main()
196 {
197     srand(time(NULL));
198     scanf("%d",&n);
199     while(n--)
200     {
201         scanf("%d%d",&opt,&x);
202         T.Trun(opt,x);
203     }
204     return 0;
205 }

模板 普通平衡樹