zoukankan      html  css  js  c++  java
  • 模板 普通平衡树

    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
    ",Trank(root,x));
    177                 break;
    178             case 4:
    179                 printf("%d
    ",Tnum(root,x));
    180                 break;
    181             case 5:
    182                 ans=0;    
    183                 Tlasmx(root,x);
    184                 printf("%d
    ",ans);
    185                 break;
    186             case 6:
    187                 ans=0;
    188                 Tnxtmn(root,x);
    189                 printf("%d
    ",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 }
  • 相关阅读:
    逻辑回归
    异常
    内部类
    接口
    多态
    final关键字(最终的)
    不能被继承的父类成员
    对象初始化的过程
    方法重写
    abstract关键字
  • 原文地址:https://www.cnblogs.com/blog-Dr-J/p/9452399.html
Copyright © 2011-2022 走看看