Redis源码学习:跳表(Skip List)的工作原理详解

Redis 跳跃表实现原理 & 时间复杂度分析 本文回顾了一下跳表这种数据结构,并分析了Redis的跳跃表是怎么实现的以及它的常用API的时间复杂度 阅读详情

什么是跳表

跳表(Skip List),首先它是链表,是一种随机化的数据结构,Redis 使用跳表作为有序集合(Sorted Set)的底层实现之一。跳表能够提供高效的插入、删除、查找操作。本文通过阅读源码来分析跳表的工作原理。

跳表的设计思想

跳表的设计思想是通过多级链表来加速查找操作。在一个简单的链表中,查找元素的时间复杂度是 O(n),而在跳表中,通过引入多级索引,查找操作的平均时间复杂度可以降到 O(log n)。

跳表的基本结构如下图所示:

Level 4:        1---------------------->7
Level 3:        1-------->4------------>7
Level 2:        1-------->4------>6---->7
Level 1:  0---->1---->2-->4-->5-->6-->7-->8

每个节点以一定的概率提升到更高一级,形成多个层级的链表。最高层级的链表包含所有节点的索引,而底层链表包含所有节点。

跳表的结构

在 Redis 的源码中,跳表的数据结构定义在 server.h 文件中,主要由以下几个结构体组成:

  • zskiplistNode:跳表节点。
  • zskiplist:跳表。
// 跳表节点
typedef struct zskiplistNode {
    double score;                       // 节点的分数,排序、查找使用
    sds ele;                            // 节点的值
    struct zskiplistNode *backward;     // 后退指针,指向前一个节点
    struct zskiplistLevel {
        struct zskiplistNode *forward;  // 前进指针,指向后一个节点
        unsigned int span;              // 跨度
    } level[];                          // 层级数组
} zskiplistNode;

// 跳表
typedef struct zskiplist {
    struct zskiplistNode *header, *tail; // 头节点和尾节点
    unsigned long length;                // 跳表长度
    int level;                           // 当前最大层级,默认1
} zskiplist;

跳表的操作

接下来,我们来看一下 Redis 中对跳表的主要操作:插入、删除和查找。具体实现代码在 t_zset.c 文件中:

创建跳表节点

创建一个新的跳表节点:

zskiplistNode* zslCreateNode(int level, double score, sds ele) {
    // 为节点分配内存,level 决定节点具有的层数
    zskiplistNode *zn = zmalloc(sizeof(*zn) + level * sizeof(struct zskiplistLevel));
    zn->score = score;  // 节点的分数
    zn->ele = ele;      // 节点的值
    return zn;
}

创建跳表

创建一个新的跳表:

zskiplist* zslCreate(void) {
    int j;
    zskiplist *zsl;

    // 分配跳表的内存
    zsl = zmalloc(sizeof(*zsl));
    zsl->level = 1;  // 初始层级为 1
    zsl->length = 0; // 初始长度为 0
    // 创建头节点,最大层数为 ZSKIPLIST_MAXLEVEL
    zsl->header = zslCreateNode(ZSKIPLIST_MAXLEVEL, 0, NULL);
    for (j = 0; j < ZSKIPLIST_MAXLEVEL; j++) {
        zsl->header->level[j].forward = NULL;
        zsl->header->level[j].span = 0;
    }
    zsl->header->backward = NULL;
    zsl->tail = NULL;
    return zsl;
}

插入

插入操作的核心在于找到新节点插入的位置,并更新相关的指针:

zskiplistNode* zslInsert(zskiplist *zsl, double score, sds ele) {
    zskiplistNode *update[ZSKIPLIST_MAXLEVEL], *x;
    unsigned int rank[ZSKIPLIST_MAXLEVEL];
    int i, level;
    
    x = zsl->header;  // 从头节点开始
    for (i = zsl->level-1; i >= 0; i--) {  // 从最高层往下遍历
        while (x->level[i].forward && 
               (x->level[i].forward->score < score || 
               (x->level[i].forward->score == score && 
                sdscmp(x->level[i].forward->ele, ele) < 0))) {  // 查找插入位置
            rank[i] += x->level[i].span;
            x = x->level[i].forward;
        }
        update[i] = x;  // 记录每层的前驱节点
    }
    level = zslRandomLevel();  // 随机生成新节点的层数
    if (level > zsl->level) {  // 如果新节点层数超过当前最大层数
        for (i = zsl->level; i < level; i++) {
            rank[i] = 0;
            update[i] = zsl->header;
            update[i]->level[i].span = zsl->length;
        }
        zsl->level = level;  // 更新跳表的层数
    }
    x = zmalloc(sizeof(*x)+level*sizeof(struct zskiplistLevel));  // 分配新节点内存
    x->score = score;
    x->ele = sdsdup(ele);
    for (i = 0; i < level; i++) {  // 插入新节点,并更新相关指针和跨度
        x->level[i].forward = update[i]->level[i].forward;
        update[i]->level[i].forward = x;
        x->level[i].span = update[i]->level[i].span - (rank[0] - rank[i]);
        update[i]->level[i].span = (rank[0] - rank[i]) + 1;
    }
    for (i = level; i < zsl->level; i++) {
        update[i]->level[i].span++;
    }
    x->backward = (update[0] == zsl->header) ? NULL : update[0];  // 更新 backward 指针
    if (x->level[0].forward)
        x->level[0].forward->backward = x;
    else
        zsl->tail = x;  // 如果新节点是最后一个节点,更新尾节点指针
    zsl->length++;  // 更新跳表的长度
    return x;
}

这段代码做了以下几个关键步骤:

  1. 遍历各层,找到新节点的插入位置。
  2. 随机确定新节点的层数,并更新跳表的层数。
  3. 插入新节点,并更新相关指针和跨度。

随机层级生成

在插入操作中有一个随机层级的生成操作,使用的随机函数zslRandomLevel:

int zslRandomLevel(void) {
	// 初始层数是1
    int level = 1;
    // 以 ZSKIPLIST_P 的概率提升层级,随机层数的值是0.25
    while ((random()&0xFFFF) < (ZSKIPLIST_P * 0xFFFF))
        level += 1;
    // ZSKIPLIST_MAXLEVEL 最大层数是64
    return (level < ZSKIPLIST_MAXLEVEL) ? level : ZSKIPLIST_MAXLEVEL;
}

删除

删除操作的核心在于找到要删除的节点,并更新相关的指针。

int zslDelete(zskiplist *zsl, double score, sds ele, zskiplistNode **node) {
    zskiplistNode *update[ZSKIPLIST_MAXLEVEL], *x;
    int i;

    x = zsl->header;  // 从头节点开始
    for (i = zsl->level-1; i >= 0; i--) {  // 从最高层往下遍历
        while (x->level[i].forward && 
               (x->level[i].forward->score < score || 
               (x->level[i].forward->score == score && 
                sdscmp(x->level[i].forward->ele, ele) < 0))) {  // 查找要删除的节点位置
            x = x->level[i].forward;
        }
        update[i] = x;  // 记录每层的前驱节点
    }

    x = x->level[0].forward;  // 指向要删除的节点
    if (x && score == x->score && sdscmp(x->ele, ele) == 0) {  // 确认节点存在
        zslDeleteNode(zsl, x, update);  // 删除节点,并更新指针
        if (!node) 
            zfree(x->ele);  // 释放节点内存
        zfree(x);
        return 1;  // 删除成功
    }
    return 0;  // 节点不存在,删除失败
}

在删除操作中:

  1. 遍历各层,找到要删除节点的位置。
  2. 删除节点,并更新相关指针和跨度。

查找

查找操作相对简单,核心在于从高层到低层逐层遍历,直到找到目标节点或确认目标节点不存在。

unsigned long zslGetRank(zskiplist *zsl, double score, sds ele) {
    zskiplistNode *x;
    unsigned long rank = 0;
    int i;

    x = zsl->header;  // 从头节点开始
    for (i = zsl->level-1; i >= 0; i--) {  // 从最高层往下遍历
        while (x->level[i].forward && 
               (x->level[i].forward->score < score || 
               (x->level[i].forward->score == score && 
                sdscmp(x->level[i].forward->ele, ele) < 0))) {  // 查找目标节点
            rank += x->level[i].span;
            x = x->level[i].forward;
        }
        if (x->level[i].forward && score == x->level[i].forward->score && 
            sdscmp(x->level[i].forward->ele, ele) == 0) {  // 找到目标节点
            rank += x->level[i].span;
            return rank;  // 返回目标节点的排名
        }
    }
    return 0;  // 目标节点不存在
}

在查找操作中:

  1. 从最高层开始,逐层向前移动,直到找到目标节点或确认其不存在。
  2. 返回目标节点的排名(或返回 0 表示不存在)。

在比较结点时,相应地有两个判断条件:

  1. 当查找到的结点保存的元素权重,比要查找的权重小时,跳表就会继续访问该层上的下一个结点。
  2. 当查找到的结点保存的元素权重,等于要查找的权重时,跳表会再检查该结点保存的 SDS 类型数据,是否比要查找的 SDS 数据小。如果结点数据小于要查找的数据时,跳表仍然会继续访问该层上的下一个结点。

总结

Redis 的跳表通过多级索引结构,实现了高效的插入、删除和查找操作。希望这篇文章能够帮助你更好地理解跳表的工作原理和实现细节。

Redis 源码硬核解析系列专题 - 第四篇:核心数据结构之跳表(Skip List) 跳表的实现位于和中。代码片段server.hsds ele;// 元素(SDS字符串)// 分数// 后退指针// 前进指针// 跨度(到下个节点的距离)} level[];// 层数组(柔性数组)// 头节点// 尾节点// 节点数int level;// 最大层数硬核解析:每个节点包含元素、分数和多层前进指针(level[]:指向该层下一个节点。span:记录跨越的节点数,用于范围查询。backward:后退指针,便于双向遍历。zskiplist:管理整个跳表, 阅读详情

相关推荐

Redis必知必会之zset底层—Skip List跳跃列表(面试加分项)

一、简介 跳表全称叫做跳跃表,简称跳表。跳表是一个随机化的数据结构,实质就是一种可以进行二分查找的有序链表。跳表在原有的有序链表上面增加了多级索引,通过索引来实现快速查找。跳表不仅能提高搜索性能,同时也可以提高插入和删除操作的性能。 ​ Skip List(跳跃列表)这种随机的数据结构,可以看做是一个二叉树的变种,它在性能上与红黑树、AVL树很相近;但是Skip List(跳跃列表)的实现相比前两者要简单很多,目前Redis的zset实现采用了Skip List(跳跃列表)(其它还有LevelDB等也使

Java框架、并发编程、分布式、微服务、Redis、HarmonyOS、中间件等技术 1572

图解Redis之数据结构篇——跳跃表

文章导航-readme 前言 跳跃表是一种有序的数据结构,它通过在每个节点中维持多个指向其他节点的指针,从而达到快速访问节点的目的。这么说,我们可能很难理解,我们可以先回忆一下链表。 一、复习跳跃表 1.1 什么是跳跃表 对于一个单链表来讲,即便链表中存储的数据是有序的,如果我们要想在其中查找某个数据,也只能从头到尾遍历链表。这样查找效率就会很低,时间复杂度会很高,是...

yufaxingxing的博客 982

nacos3.1.0适配国产数据库

Nacos 3.1.0适配国产数据库指南 本文介绍了Nacos 3.1.0版本适配达梦数据库和人大金仓数据库的具体步骤。主要内容包括:添加达梦和人大金仓的JDBC驱动依赖,修改nacos-persistence模块的配置文件及相关Java类,以及打包和运行注意事项。文章特别指出3.1.0版本需要JDK17环境,并提供了解决常见问题的建议,如添加VM options配置和不同启动方式等。通过本文的配置指导,可以实现Nacos服务在国产数据库环境下的正常运行。

梦昼初的博客 1467

Redis中的跳跃表

跳跃表  跳跃表(skiplist)是一种有序数据结构,它通过在每个节点中维持多个指向其他节点的指针,从而达到快速访问节点的目的。  跳跃表支持平均O(logN)、最坏O(N)复杂度的节点查找,还可以通过顺序性操作来批量处理节点。  在大部分情况下,跳跃表的效率可以和平衡树相媲美,并且因为跳跃表的实现比平衡树要来得更为简单,所以有不少程序都使用跳跃表来代替平衡树。  Redis使用跳跃表作为有序集合

universe_ant的博客 1万+

DESeq2实战:如何用LRT检验分析基因表达随时间变化的模式(附完整代码)

本文详细介绍了如何使用DESeq2中的LRT检验分析基因表达随时间变化的模式,包括实验设计、数据预处理、模型构建、结果提取与可视化等完整流程。通过实战案例和完整代码,帮助生物信息学研究者掌握时间序列RNA-seq分析的核心技术,特别适合需要快速上手的实践者。

weixin_42620255的博客 475

DRV2605L触觉驱动芯片实战指南:从自动校准到音频转触觉应用

触觉反馈技术是现代人机交互的核心组成部分,它通过精确控制振动马达来模拟物理触感,广泛应用于智能手机、游戏手柄和汽车触摸屏等领域。其原理在于将电信号转化为机械振动,关键在于如何高效、精准地驱动不同类型的马达(如ERM和LRA)。这项技术的核心价值在于提升交互的真实感和沉浸感。在工程实践中,集成驱动芯片如DRV2605L通过内置智能反馈引擎和自动校准功能,解决了传统驱动方式响应慢、效果不一致的难题。它特别适用于需要高质量触觉反馈的应用场景,例如消费电子、游戏外设和车载信息娱乐系统。其中,自动校准能自适应优化驱动

weixin_42631411的博客 343

Redis 跳跃表原理

跳跃表 跳跃表 (skiplist) 是一种有序数据结构,它通过在每个节点中维持多个指向其他节点的指针从而达到快速访问节点的目的。 跳跃表是 redis 有序集合 zset 的底层实现方式之一。(当元素个数<128的时候,用 ziplist 实现) 原理 首先从有序数组说起,对于有序数据的查找,可以使用二分查找法将时间复杂度降到 O(logn),但是插入和删除都需要 O(n) 的复杂度。 再说链表,查找时需要从头节点开始遍历,复杂度为 O(n),不过插入、删除只需要移动指针,复杂度为 O(1)。

九月的野花一片 1704

ICC2: 如何让CTS指定pin多长指定长度

这里create_clock不需要写到sdc里,在脚本里写就行,需要注意的是脚本里存在remove_clock_tree的话,add_buffer就要放remove_clock_tree后面,或者给guide buffer设don't touch也行。跟innovus的操作逻辑一样,如果要让tree上的某一点长长,要先考虑这个点后面的clock tree能正常balance。我正在「拾陆楼」和朋友们讨论有趣的话题,你⼀起来吧?-5意味着长长5ns,相反正值意味着做短。

m0_61544122的博客 690

Redis中的跳表是怎么回事

引子 早些年笔者一次真实的美团面试经历。 面试官:请问Redis有哪些数据结构? 我:string、hash、list、set、zset、 bitmaps、hyperloglogs、geospatial、布隆过滤器。 面试官:zset主要用什么应用场景? 我:zset主要是一种有权重的set集合,因为每一个元素都可以有一个“分数”,redis提供了根据这个分数操作的api,比如取分数前几的啊,所以我们可以用作一些类似于排行榜的东西,比如点赞次数前几名的啦,,叭叭叭。 面试官:嗯,,,那它的底层的数据结构

程序员大航子 4757

光学相干断层扫描(OCT)在 妇科诊断 中的革命性应用

尽管OCT在妇科的应用提供了许多潜在的优势,但它仍然是一个相对新的技术,并不是所有医疗机构都有能力提供这种类型的成像服务。随着技术的发展和医生对OCT的熟悉程度的提高,预计OCT将在妇科和其他医学领域中扮演越来越重要的角色。早期发现和准确的分类是提高治疗成功率的关键。虽然这是一个相对较新的应用领域,但OCT的非侵入性和高分辨率成像能力可能提供有价值的信息,以提高辅助生殖技术的成功率。:光学相干断层扫描(OCT)在阴道和外阴组织的评估中的应用正在逐渐展开,提供了一种新的方法来诊断和监测各种妇科疾病。

LiRongLu_的博客 1722

SCI论文发表很容易【5】:比较容易中的期刊

整理了一些经管方面比较容易中稿的期刊,可供大家参考

qq_25018077的博客 1681

Redis100篇 - 揭秘Redis的跳表 为什么它能支撑ZSet的高效排序

本文深入剖析了Redis跳表(Skip List)的核心原理与实现机制,揭示其如何高效支持ZSet的有序操作。文章首先对比了跳表与平衡树的优劣,指出跳表在实现复杂度、范围查询和并发性能上的优势;随后通过可视化图解和源码分析,详细解析了跳表的多层链表结构及其O(log N)时间复杂度的搜索原理;最后结合Redis源码展示了跳表的数据结构定义和关键操作流程。全文通过理论分析、代码示例和图表说明,帮助读者全面理解Redis跳表的设计精髓及其在有序集合中的高效应用。

千淘万漉虽辛苦,吹尽狂沙始到金 2万+

EMI辐射发射超标案例

EMI辐射发射超标案例

让你爱上电路设计 8508

Skip List--跳表(全网最详细的跳表文章没有之一)

跳表是可以实现二分查找的有序链表;每个元素插入时随机生成它的level;最底层包含所有的元素;如果一个元素出现在level(x),那么它肯定出现在x以下的level中;每个索引节点包含两个指针,一个向下,一个向右;(笔记目前看过的各种跳表源码实现包括Redis 的zset 都没有向下的指针,那怎么从二级索引跳到一级索引呢?留个悬念,看源码吧,文末有跳表实现源码)跳表查询、插入、删除的时间复杂度为O(log n),与平衡二叉树接近;

好好学java 8714

【机器学习】随机森林(Random Forest,简称 RF):预测光伏电站功率 || 缺失数据处理 || 重复行处理...

【机器学习】随机森林(Random Forest,简称 RF):预测光伏电站功率。

追光者♂:记录、分享、总结、提升,现象级专栏《Python从入门到人工智能》作者,无惧黑暗,坚信曙光 1653

C# WinForm 基于DirectShow.dll编写的程序,可边预览边保存视频,音频和图片

基于微软的DirectShow.dll的二次开发1.自动识别连接的摄像头跟麦克风且可以对其进行选择(默认选中第一个)2.可录制wmv和avi两种格式的视频并且都带有音频,avi可以录制的分辨率和帧数进行选择,wmv默认进行了淸晰度优化如不喜欢可去除代码中有相关提示3.可在预览点开之后进行拍照,也可边录制视频边拍照4.添加了视频和音频的压缩功能(酌情使用)这次二次开发发现C#对DirectShow的相关信息太少,这次做完也不敢藏私共享出来,还望大家指正

跳表(Skip List)详解与可视化技术博客

跳表由 William Pugh 于 1989 年提出,论文《Skip Lists: A Probabilistic Alternative to Balanced Trees》首次系统阐述了跳表结构。跳表设计初衷是为了解决链表查找效率低的问题,同时避免平衡树的复杂旋转操作。本质:跳表是分层有序链表,用概率分布实现高效查找。查找快:多层索引,查找效率 O(logn),适合大数据量。插入删改易:随机分层,操作简单,代码易实现。适用场景广:数据库索引、缓存系统、分布式 KV 存储。与树结构互补。

IT技术学习与工作笔记分享 911

RU DOS版、EFI版32bit/64bit BIOS常用工具

DOS版、EFI版的RU工具,可用来查看IO、MEM、PCI、SMBIOS等资源。亲测在EFI SHELL下可用。

Redis 跳表(Skip List)原理细节深度解析

/ 跳表节点sds ele;// 成员对象(SDS字符串)// 排序分值// 后退指针(双向链表)// 前进指针// 跨度(用于排名计算)} level[];// 柔性数组,层级随机生成// 跳表结构// 节点总数int level;// 当前最大层数设计亮点span 字段:记录节点在某一层的跨度,支持 O(1) 时间复杂度计算元素排名(ZRANKbackward 指针:构成双向链表,支持逆序遍历柔性数组(level[]):内存紧凑,避免指针冗余跳表的精妙之处在于用概率换结构。

xiaoyu❅的博客 1550

老版QQ原生表情gif动态

这是老版的QQ表情,不过全是动态的的,Windows照片查看器是不会动的,可以右击用浏览器打开查看,再说一遍是老版的,只是分享给宁愿用老版也要动态的人。

怀旧版电脑GBC模拟器

再现原版GBC掌机的界面,电脑运行连游戏界面都一样大小,很怀旧,很真实,(英文版)强烈推荐,很小的文件,很难才找到的。

Redis数据结构之——跳表skiplist

Redis数据结构之——跳表skiplist

weixin_46935110的博客 7083

数据结构——跳表skip list

转载:Skip List–跳表 理解跳表,从单链表开始说起 下图是一个简单的有序单链表,单链表的特性就是每个元素存放下一个元素的引用。即:通过第一个元素可以找到第二个元素,通过第二个元素可以找到第三个元素,依次类推,直到找到最后一个元素。 什么是跳表? 跳表的查找、插入、删除元素的流程 跳表查找、插入、删除元素的时间复杂度 跳表插入元素时,如何动态维护索引? 为什么Redis选择使用跳表而不是红黑树来实现有序集合? 工业上其他使用跳表的场景 友情提示:下文在跳表插入数据时,会讲述如何动态维护索引,实现比

Overvautious的博客 1560

深入图解:Redis 中跳表(Skip List)的实现原理到底是怎么回事?

Redis的ZSet使用跳表(SkipList)实现,通过多级索引提升查询效率至O(logN)。跳表通过随机层数避免索引重建开销,比红黑树更省内存且实现简单。Redis还优化了跳表,支持反向遍历和跨度统计,更适合ZSet的范围查询和排名操作。跳表的设计巧妙结合索引和概率,是空间换时间的典范。

2302_80014993的博客 751

Skip List 跳表

Redis,Elasticsearch中都有用到跳表这种数据结构,所以理解跳表的实现原理对与深入学习redis和elasticsearch非常重要。 下文在跳表插入数据时,会讲述如何动态维护索引,实现比较简单,逻辑比较绕,可以选择暂时性的跳过,毕竟这块偏向于源码。但必须知道跳表插入、删除、查找元素的时间复杂度跟红黑树都是一样量级的,都是O(logn),而且可以按照范围区间查找元素,毕竟平时的工作都是直接使用封装好的跳表,例如:java.util.concurrent下的ConcurrentSkipListM

你今天真好看呀 419

【恋上数据结构】跳表(Skip List)原理及实现

跳表(Skip List)引出跳表跳表介绍跳表原理及实现使用跳表优化链表跳表基础结构跳表的搜索跳表的添加、删除跳表的层数跳表的复杂度分析跳表 - 完整源码 数据结构与算法笔记:恋上数据结构笔记目录 引出跳表 一个有序链表搜索、添加、删除的平均时间复杂度是多少? O(n) 能否利用二分搜索优化有序链表,将搜索、添加、删除的平均时间复杂度降低至 O(logn)? 链表没有像数组那样的高效随...

萌宅鹿的技术小屋 1158
上一篇: Redis源码学习:高性能Hash表的设计与实现
下一篇: Redis源码学习:ziplist的数据结构和连锁更新问题
我是DL
博客等级 码龄10年 509粉丝 93原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

我是DL

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值