Splay学习笔记

导

为什么非要学习Splay呢？

因为动态树必须用Splay呀QAQ

基本思想

就是让这个树旋转来旋转去的，维持一个相对平衡

其中spaly指的是单旋，splay指的是双旋，都可以被卡，双旋不容易被卡一些，况且如果你写的是splay的话，那就应该写双旋咯。

其中双旋的内涵式，z字型旋转两次x，线性旋转y再旋转x

操作的话基本上是如果需要调用元素，就把那个元素弄到跟结点来。

用法引导

相较于线段树，这个东西更加灵活，可以增删，而且可以查找第k大什么的，但是比线段树要慢很多，因为线段树是绝对平衡的。不过除了动态树之外的，我打算直接用treap呢。

操作简述

• 插入：根据二叉树性质找到一个空的叶子结点，然后旋转为根结点。
• 查找：排序，统计等都是找到了然后旋转为根结点
• 删除：把需要的结点旋转为根结点，有左儿子：把左儿子的最大节点旋上来，然后右儿子的左儿子接左儿子的右儿子，左儿子变成右儿子的左儿子，然后右儿子变成根结点（好麻烦QAQ）；否则：直接把0和右儿子连接。注意重置根结点。

代码

呜啊~~~一下午才弄出来哎。。。
这里实现插入，删除，求第k大，询问元素大小几个基本操作

struct Splay{
    int rt,np,sz[maxn],w[maxn],fa[maxn],ch[maxn][2];
    void Initial()
    {
        rt=np=0;
        memset(fa,0,sizeof(fa));
        memset(sz,0,sizeof(sz));
        memset(ch,0,sizeof(ch));
    }
    void Link(int i,int d,int j)
    {
        ch[i][d]=j;
        fa[j]=i;
    }
    void pushup(int now)
    {
        sz[now]=1;
        if(ch[now][0])sz[now]+=sz[ch[now][0]];
        if(ch[now][1])sz[now]+=sz[ch[now][1]];
    }
    void rot(int x)
    {
        int y=fa[x],z=fa[y];
        int d=ch[y][1]==x;
        Link(y,d,ch[x][d^1]);
        Link(z,ch[z][1]==y,x);
        Link(x,d^1,y);
        pushup(y);
        pushup(x);
    }
    void splay(int x,int anc)//应该要必须保证x在anc下方才可以 
    {
        if(!x)return;//重要 
        while(fa[x]!=anc)
        {
            int y=fa[x],z=fa[y];
            if(z!=anc)
                (ch[z][0]==y)==(ch[y][0]==x)?rot(y):rot(x);
            rot(x);
        }
        if(!anc)rt=x;
    }
    void Insert(int now,int x)
    {
        int d=0;//初值！！ 
        while(now)
        {
            d=x>w[now];
            if(!ch[now][d])break;
            now=ch[now][d];
        }
        w[++np]=x,sz[np]=1;
        Link(now,d,np);
        splay(np,0);//每次Splay之前只需要保证当前平衡树是满足要求的即可，旋转上去是为了完成pushup。 
    }
    int Find(int now,int x)
    {
        while(now)
        {
            if(w[now]==x)break;
            now=ch[now][x>w[now]];
        }
        splay(now,0);
        return now;
    }
    void Delete(int now,int x)
    {
        int p=Find(now,x);
        if(!p)return;
        if(ch[p][0])
        {
            int t=ch[p][0];
            while(ch[t][1])t=ch[t][1];
            splay(t,p);
            Link(ch[p][0],1,ch[p][1]);
            Link(0,0,ch[p][0]);
            rt=ch[p][0];
            pushup(rt);
        }
        else
        {
            Link(0,0,ch[p][1]);
            rt=ch[p][1];
        }
    }
    int Count(int now,int x)
    {
        int ret=0,t;
        while(now)
        {
            t=1+sz[ch[now][0]];
            if(x>w[now])//这里是>哦 
                ret+=t,now=ch[now][1];
            else
                now=ch[now][0];
        }
        return ret;
    }
    int Rank(int now,int x)
    {
        if(Find(now,x))
            return Count(rt,x)+1;//根被换过了 
        return 0;
    }
    int Kth(int now,int k)
    {
        int t;
        while(now)
        {
            t=1+sz[ch[now][0]];
            if(t==k)break;
            if(t<k)now=ch[now][1],k-=t;
            else now=ch[now][0];
        }
        splay(now,0);
        return now;
    }
    void DFS(int now)
    {
        if(!now)return ;
        cout<<w[now]<<" ";
        DFS(ch[now][0]);
        DFS(ch[now][1]);
    }
}sp;

注意
- 关于二叉树，旋转之后两个大小相同的元素，可能在左边，也可能在右边的，不过按照道理来说，只要分类方式唯一，那么就不会从出现这种问题。
- 注意方向判断用x>=w[now]