不GG的Splay

最新推荐文章于 2024-09-07 23:49:10 发布
最新推荐文章于 2024-09-07 23:49:10 发布
阅读量50 收藏
点赞数
分类专栏： 理论知识 文章标签： splay tree 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yuki_imoto/article/details/113743067
版权

Splay（伸展树）是一种维护二叉搜索树的数据结构，可以用它干一些很神奇的东西，这篇文章先来介绍它的基本操作。

首先定义几个变量：

  • fa[x] 表示 x 的父节点

  • ch[x][y] 表示 x 的儿子节点，y=0 表示左儿子，y=1 表示右儿子

  • cnt[x] 表示 x 这个数出现了几次

  • val[x] 表示 x 节点的权值是多少

  • size[x] 表示以 x 为根的树节点个数（树的大小）

  • tot_size 表示树的总大小

  • root 表示当前根节点是哪个

下面介绍操作：

clear(x)

把 x 节点上的所有信息清空

void clear(int x) {
    fa[x]=ch[x][0]=ch[x][1]=cnt[x]=size[x]=val[x]=0;
}

get(x)

判断 x 节点为它父节点的左儿子还是右儿子（左0右1）

int get(int x) {
    return ch[fa[x]][1]==x;
}

update(x)

维护以 x 为根的树的大小

在下面的操作的时候如果会update很多点，一定要从下往上维护。

void update(int x) {
    if(x) {
        size[x]=cnt[x];
        if(ch[x][0]) size[x]+=size[ch[x][0]];
        if(ch[x][1]) size[x]+=size[ch[x][1]];
    }
}

rotate(x)

Splay中最最最重要的一个环节。

把 x 节点旋转到 x 的父节点的位置。

可是这是二叉树呀，这样操作不就乱了吗？

所以我们要维护某些节点之间的父子关系。

首先我们要明确在这次操作中会涉及到的节点：

1、x，你就是转它肯定会涉及它呀

2、fa[x]，你要把 x 转到那里肯定也会涉及到它

3、fa[fa[x]]，把 x 转到了 fa[x] 时，fa[fa[x]] 的儿子就不是 fa[x] 了，会变成 x

好了，rotate操作就会涉及到这 3 个节点，每个节点改变它的父亲和儿子，就会有六条语句，其中如果 fa[x] 已经是根了，那么就不用改变 fa[fa[x]] 的儿子了。

最关键的问题来了：父子关系怎么分配呢？

因为我们想把 x 到 fa[x] 的位置，那么它们的的父子关系必然会互换。唯一要确定的就是左右儿子的问题。

假设 x 是 fa[x] 的左儿子，那么 fa[x] 的原本的左儿子 x 将会变成 x 的右儿子（这里为什么是右儿子，因为这样才会保持二叉搜索树的性质）。反之亦然，所以我们用 which 来记录 x 与 fa[x] 的关系，最后维护一下旋转后的树的大小（因为 fa[x] 已经是 x 的儿子了，所以先update(fa[x])），代码如下：

void rotate(int x) {
    int pa=fa[x],papa=fa[pa],which=get(x);
    ch[pa][which]=ch[x][!which];fa[ch[x][!which]]=pa;
    ch[x][!which]=pa;fa[pa]=x;
    fa[x]=papa;if(papa) ch[papa][ch[papa][1]==pa]=x;
    update(pa);update(x);
}

splay(x)

这个函数是通过不断的rotate把 x 转到根的位置。

注意三点一线的时候是先转fa[x]再转x

void splay(int x) {
    for(int f;f=fa[x];rotate(x)) {
        if(fa[f]) rotate(get(f)==get(x)?f:x);
    }
    root=x;
}

insert(x)

插入一个数x。

三种情况：

1、**空树。**直接改改信息return就好了。

2、**x重复。**cnt[x]++，维护一下return。

3、**找到了最底下。**新开节点维护一下return。

这个具体看代码吧，应该很好理解。

下面两种情况不要忘记splay一下。

void insert(int v) {
    if(root==0) {
        tot_size++;
        ch[tot_size][0]=ch[tot_size][1]=fa[tot_size]=0;
        val[tot_size]=v;
        cnt[tot_size]=size[tot_size]=1;
        root=tot_size;
        return;
    }
    int f=0,now=root;
    while(true) {
        if(val[now]==v) {
            cnt[now]++;
            update(now);
            update(f);
            splay(now);
            return;
        }
        f=now;
        now=ch[now][val[now]<v];
        if(now==0) {
            tot_size++;
            ch[tot_size][0]=ch[tot_size][1]=0;
            fa[tot_size]=f;
            val[tot_size]=v;
            cnt[tot_size]=1,size[tot_size]=1;
            ch[f][val[f]<v]=tot_size;
            update(f);
            splay(tot_size);
            return;
        }
    }
}

find(x)

查找x这个数的排名

就按照二叉搜索树的性质往下查找，注意我们在往左子树找的时候是不用累加结果的，因为最左边的就是第一个，在往右边找的时候再加上左子树的大小，找到的时候别忘了把 x splay到根方便以后的操作。

int find(int x) {
    int res=0,now=root;
    while(true) {    
        if(x<val[now]) {
            now=ch[now][0];
        }
        else {
            res+=size[ch[now][0]];
            if(x==val[now]) {
                splay(now);
                return res+1;
            }
            res+=cnt[now];
            now=ch[now][1];
        }
    }
}

findx(x)

查找排名为x的树的节点

和find类似无非就是多判断一下子树的大小看看能否继续查找，temp表示的是已经搜了多少个节点。

int findx(int p) {
    int now=root;
    while(true) {
        if(ch[now][0] && p<=size[ch[now][0]]) {
            now=ch[now][0];
        }
        else {
            int temp=size[ch[now][0]]+cnt[now];
            if(p<=temp) return val[now];
            p-=temp;
            now=ch[now][1];
        }
    }
}

pre() 和 next()

查找根节点的前驱和后继节点

如果要查找x的前驱或后继的话，就先insert(x)，把它转到根，再del(x)，删除。

这个操作很简单，根节点的前驱就是根节点左子树中最靠右的那个，后继就是右子树中最靠左的那个，想一想，为什么？

int pre() {
    int now=ch[root][0];
    while(ch[now][1]) now=ch[now][1];
    return now;
}

int next() {
    int now=ch[root][1];
    while(ch[now][0]) now=ch[now][0];
    return now;
}

del(x)

删除大小为x的节点

首先我们随便find一下，目的是让x转到根节点，现在root就是x。

然后就会出现下面几种情况：

1、**x有重复。**那么直接cnt[root]–，return就好了。

2、**root没有儿子了，即树上只有x一个节点。**那么直接删除根节点，return。

3、**root只有左儿子或只有右儿子。**那就把它的这个儿子变成父亲，然后删除父亲，return。

4、**root有两个儿子。**那么为了满足二叉搜索树的性质，我们把根的前驱变成新的根，再把原来根的右子树接到新根的右儿子上，最后删除原来的根，维护一下新根，return。

void del(int x) {
    int gg=find(x);
    if(cnt[root]>1) {
        cnt[root]--;
        return;
    }
    if(!ch[root][0] && !ch[root][1]) {
        clear(root);
        root=0;
        return;
    }
    if(!ch[root][0]) {
        int oldroot=root;
        root=ch[root][1];
        fa[root]=0;
        clear(oldroot);
        return;
    }
    else if(!ch[root][1]) {
        int oldroot=root;
        root=ch[root][0];
        fa[root]=0;
        clear(oldroot);
        return;
    }
    int oldroot=root;
    splay(pre());
    fa[ch[oldroot][1]]=root;
    ch[root][1]=ch[oldroot][1];
    clear(oldroot);
    update(root);
    return;
}

最后整合成一道模板题。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#define MAXN 1000005

using namespace std;

int read() {
    int x=0,f=1;char ch=getchar();
    while(ch<'0' || ch>'9') {if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0' && ch<='9') {x=x*10+ch-'0';ch=getchar();}
    return x*f;
}

int fa[MAXN],cnt[MAXN],ch[MAXN][2],size[MAXN],val[MAXN],tot_size,root;

void clear(int x) {
    fa[x]=ch[x][0]=ch[x][1]=cnt[x]=size[x]=val[x]=0;
}

int get(int x) {
    return ch[fa[x]][1]==x;
}

void update(int x) {
    if(x) {
        size[x]=cnt[x];
        if(ch[x][0]) size[x]+=size[ch[x][0]];
        if(ch[x][1]) size[x]+=size[ch[x][1]];
    }
}

void rotate(int x) {
    int pa=fa[x],papa=fa[pa],which=get(x);
    ch[pa][which]=ch[x][!which];fa[ch[x][!which]]=pa;
    ch[x][!which]=pa;fa[pa]=x;
    fa[x]=papa;if(papa) ch[papa][ch[papa][1]==pa]=x;
    update(pa);update(x);
}

void splay(int x) {
    for(int f;f=fa[x];rotate(x)) {
        if(fa[f]) rotate(get(f)==get(x)?f:x);
    }
    root=x;
}

void insert(int v) {
    if(root==0) {
        tot_size++;
        ch[tot_size][0]=ch[tot_size][1]=fa[tot_size]=0;
        val[tot_size]=v;
        cnt[tot_size]=size[tot_size]=1;
        root=tot_size;
        return;
    }
    int f=0,now=root;
    while(true) {
        if(val[now]==v) {
            cnt[now]++;
            update(now);
            update(f);
            splay(now);
            return;
        }
        f=now;
        now=ch[now][val[now]<v];
        if(now==0) {
            tot_size++;
            ch[tot_size][0]=ch[tot_size][1]=0;
            fa[tot_size]=f;
            val[tot_size]=v;
            cnt[tot_size]=1,size[tot_size]=1;
            ch[f][val[f]<v]=tot_size;
            update(f);
            splay(tot_size);
            return;
        }
    }
}

int find(int x) {
    int res=0,now=root;
    while(true) {    
        if(x<val[now]) {
            now=ch[now][0];
        }
        else {
            res+=size[ch[now][0]];
            if(x==val[now]) {
                splay(now);
                return res+1;
            }
            res+=cnt[now];
            now=ch[now][1];
        }
    }
}

int findx(int p) {
    int now=root;
    while(true) {
        if(ch[now][0] && p<=size[ch[now][0]]) {
            now=ch[now][0];
        }
        else {
            int temp=size[ch[now][0]]+cnt[now];
            if(p<=temp) return val[now];
            p-=temp;
            now=ch[now][1];
        }
    }
}

int pre() {
    int now=ch[root][0];
    while(ch[now][1]) now=ch[now][1];
    return now;
}

int next() {
    int now=ch[root][1];
    while(ch[now][0]) now=ch[now][0];
    return now;
}

void del(int x) {
    int gg=find(x);
    if(cnt[root]>1) {
        cnt[root]--;
        return;
    }
    if(!ch[root][0] && !ch[root][1]) {
        clear(root);
        root=0;
        return;
    }
    if(!ch[root][0]) {
        int oldroot=root;
        root=ch[root][1];
        fa[root]=0;
        clear(oldroot);
        return;
    }
    else if(!ch[root][1]) {
        int oldroot=root;
        root=ch[root][0];
        fa[root]=0;
        clear(oldroot);
        return;
    }
    int oldroot=root;
    splay(pre());
    fa[ch[oldroot][1]]=root;
    ch[root][1]=ch[oldroot][1];
    clear(oldroot);
    update(root);
    return;
}

int main() {
    int n=read();
    while(n--) {
        int opt=read(),x=read();
        if(opt==1) insert(x);
        if(opt==2) del(x);
        if(opt==3) printf("%d\n",find(x));
        if(opt==4) printf("%d\n",findx(x));
        if(opt==5) {
            insert(x);
            printf("%d\n",val[pre()]);
            del(x);
        }
        if(opt==6) {
            insert(x);
            printf("%d\n",val[next()]);
            del(x);
        }
    }
    return 0;
}
由希Yuki
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
学习笔记——Splay
ZCETHAN 的博客
07-30 145
前言 前几天有幸听学长讲平衡树，想着好久没写博客了，记录一下。 简介 Splay，平衡树的一种，依靠每次将访问到的点旋到根来保持树的平衡。 并且，Splay 还可以高效解决序列翻转等操作。 实现 前提 以下代码是基于这样的定义的： struct Tree{int ch[2],val,siz,fa;}nd[MAXN];//表示某一个节点 void pushup(int rt){nd[rt].siz=nd[nd[rt].ch[0]].siz+nd[nd[rt].ch[1]].siz+1;}//更新某个节点子树的
Splay Tree
zhengxu_Lee的博客
03-13 345
Splay Tree的引入       类似于内存管理中的页面置换算法，在BST中最近被访问的节点，也更有可能在下一次被访问，为了利用这一局部性，SplayTree在每次访问一个节点后，都把这个节点提到根节点的位置，因此Splay Tree和其他BST的最大区别在于他的Search，Insert，Remove算法都是动态的。具体操作       双层伸展的精髓在于每次向上追溯两层，而非一层，反复考...
hdu 1890 splay树
阳光下的泡沫
02-24 371
Robotic Sort Time Limit: 6000/2000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 3340    Accepted Submission(s): 1423 Problem Description Somewhere dee
8.1 Splay树
ZXG20000的博客
03-02 184
参考博客: https://blog.csdn.net/hellochenlu/article/details/53022709 参考博客: https://blog.csdn.net/amoscykl/article/details/81589827 本章问题 1.splay逐层伸展到根和双层伸展有什么区别呢？ 假设节点的个数为n，则旋转操作的总次数的为(n-1)+{(n-1)+(n-2)+(n-3)+…+1}=(n2+n-2)/2=Ω\OmegaΩ(n2) 逐层伸展，对于规模为任意n的伸展树，只
AVL、Splay和性能分析（伪）
__hao__的博客
12-23 1275
先说明一下，这个玩意是学校数据结构课的作业。完全是赶着ddl写完的，所以后面我都有点不知道自己在写什么。gprof也不太会，瞎弄的。主要放这里做个归档，如果对大家有帮助就更好了。当然，有问题也欢迎大家批评指正。 平衡二叉搜索树性能分析 问题描述 在AVL、Splay和红黑树三种平衡二叉搜索树中至少实现两种，需要支持以下操作：元素插入、删除和查询。在题目中，所有数据均为非负整数。查询时给出一非负整数xxx，需要求出树中满足y≤xy\le xy≤x的最大整数yyy；若树中不存在满足条件的yyy，查询返回-1.
splay教程集合
急流勇进
03-17 605
前言 splay是一个维护序列(一堆数)比较好的数据结构，他通过双旋可以有效的避免二叉排序树退化成一条链的情况（证明可以看论文），让平均复杂度在logn，他可以维护一个序列即：有n个数字，每个数字的位置跟值都告诉你了，有许多在某个区间(位置)上的操作。还可以维护一堆数字即：没有位置的概念，就是给你一堆数字，没有在区间上的操作，通常存在序列区间上反转，交换，插入删除新的数字，求第k个位置的数字的时候...
数据结构实现之Splay伸展树
清文的博客
02-03 1480
Splay Tree 是二叉查找树的一种，它与平衡二叉树、红黑树不同的是，Splay Tree从不强制地保持自身的平衡，每当查找到某个节点n的时候，在返回节点n的同时，Splay Tree会将节点n旋转到树根的位置，这样就使得Splay Tree天生有着一种类似缓存的能力，因为每次被查找到的节点都会被搬到树根的位置，所以当80%的情况下我们需要查找的元素都是某个固定的节点，或者是一
伸展树Splay Tree
peanWang的博客
08-28 394
伸展树 伸展树是自平衡的二叉查找树，伸展树不像AVL树，要时刻保持平衡。伸展树通过分摊保持查找的高效率。 伸展树的基本思想：当一个节点被访问后，它就要进过一系列AVL树旋转被放在根上。 数据局部性 可视化伸展树 http://www.link.cs.cmu.edu/splay/ 这个网站是伸展树的创始人做到一个project。将伸展树可视化。学伸展树的时候可以看看。...
数据结构（五）----树（含堆）
weixin_73579966的博客
09-04 1025
树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的.1.最上面的称为根结点，它没有前驱结点。2.除了根结点，其余结点被分成多个互不相交的集合，其中每个集合又是一棵子树，这些子树的根节点只有一个前驱，可以有0或多个后继3.树是递归定义的。一棵树：子树不能相交总的来说，二叉树的主要难点在于链式二叉树，而其中最重要的思想在于——递归，把大事化为一个重复递归的小事，而贯穿其中的方法是：画图。
数据结构----树
2301_77841194的博客
09-07 723
1、树(Tree)是n(n≥0)个结点的有限集。n=O时称为空树。在任意一棵非空树中:(1）有且仅有一个特定的称为根(Root)的结点;(2)当n>1时,其余结点可分为m(m>0)个互不相交的有限集T1、T2、……、Tm,其中每一个集合本身又是一棵树,并且称为根的子树(SubTree)2、树的结点包含一个数据元素及若干指向其子树的分支。结点拥有的子树数称为结点的度(Degree)。度为0的结点称为叶结点（Leaf）或终端结点;度不为0的结点称为非终端结点或分支结点。
Java-数据结构-栈和队列-Stack和Queue (oﾟ▽ﾟ)o
最新发布
2303_80388948的博客
09-07 558
栈：是一种特殊的线性表，其 只允需在固定的一端进行插入和删除操作。 进行插入和删除的一端叫做栈顶，另一端叫做栈底。并且要遵循 先进后出 的规则。 队列：是一种只允许一端进行插入元素，在另一端进行删除元素的特殊的线性表。 队列具有 先进先出 的性质：进行插入的一端叫做队尾，进行删除的一端叫做队头。也就是队尾进，队头出。
数据结构（六）----排序
weixin_73579966的博客
09-07 457
上面这三个是比较基础的排序算法，通常归在一起比较，从性能上来说，插入>冒泡>选择（诶嘿冒泡居然还不是倒数第一）下面将要介绍的则是一些改进的、有技术含量的排序了完结撒花！！！相信如果你掌握了本讲的所有排序算法并且能熟练手撕出来，你绝对是面试中的佼佼者1。
数据结构——单链表实现和注释浅解
hedhjd的博客
09-07 154
【代码】数据结构——单链表实现和注释浅解。
数据结构（1）数据结构基础（单向链表）
weixin_68239724的博客
09-03 647
数据结构是一组用来保存一种或多种特定关系的数据的集合。其主要目的是组织和存储数据，以便于高效的访问和修改。程序 = 数据结构 + 算法单向链表是一种线性数据结构，由一系列节点构成，每个节点包含数据部分和指向下一个节点的指针。它是一种灵活的存储方式，相比于数组，单向链表不需要连续的内存空间。
考研系列-408真题数据结构篇(18-23)
Nelson_hehe的博客
09-04 127
此文章是本人在备考过程中408真题数据结构部分（2018年-2023年）的易错题及相应的知识点整理，后期复习也尝尝用到，对于知识提炼归纳理解起到了很大的作用，分享出来希望帮助到大家~
常见的排序
2302_79712403的博客
09-07 432
常见的10大排序，这里先详细的介绍前7种排序；稳定性定义：如果两个元素具有相同的关键字，那么在排序后他们的相对顺序不变；排序前有标记的5在前面，排序后依旧在前面即稳定，如果位置互换了就不稳定；
数据结构--经典排序之选择排序（超详细！！）
2301_79381549的博客
09-04 552
它的工作原理是，首先在未排序序列中找到最小（或最大）元素，存放到排序序列的起始位置，然后再从剩余未排序元素中继续寻找最小（或最大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。.如果在交换之前，max恰好是begin，那么由于begin位置的值已经被交换出去，我们需要更新max为min的位置。.接着，我们使用Swap函数将begin位置的值与最小值进行交换，这样确保了begin位置始终是已排序的最小值。.Swap 函数是一个简单的值交换函数，它接受两个整数的指针，并交换它们所指向的值。
【数据结构】--初识泛型
2303_80341387的博客
09-07 336
一般的类和方法，只能使用具体的类型: 要么是基本类型，要么是自定义的类。如果要编写可以应用于多种类型的代码，这种刻板的限制对代码的束缚就会很大。----- 来源《Java编程思想》对泛型的介绍。泛型是在JDK1.5引入的新的语法，通俗讲，泛型：就是适用于许多许多类型。从代码上讲，就是对类型实现了参数化。
Splay时间复杂度
09-13
Splay树是一种自平衡二叉搜索树，其时间复杂度取决于具体的操作。以下是Splay树常见操作的时间复杂度： 1. 插入（Insertion）：在平均情况下，Splay树的插入操作的时间复杂度为O(log n)，其中n是树中节点的数量。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值