redis6.0源码跳跃表

最新推荐文章于 2024-07-20 16:13:10 发布
最新推荐文章于 2024-07-20 16:13:10 发布
阅读量292 收藏 1
点赞数
分类专栏： redis 数据结构 文章标签： redis 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37731056/article/details/106085890
版权

跳跃表主要用于有序集合键，另一个是在集群节点中用作内部数据结构。

结构体定义

跳跃表的结构定义在server.h/zskiplist

typedef struct zskiplistNode {
    sds ele;//成员对象
    double score;//分数
    struct zskiplistNode *backward;
    //层
    struct zskiplistLevel {
    	//前进指针
        struct zskiplistNode *forward;
        //跨度
        unsigned long span;
    } level[];
} zskiplistNode;

typedef struct zskiplist {
    struct zskiplistNode *header, *tail;
    unsigned long length;
    int level;
} zskiplist;
  • header指向跳跃表的表头节点
  • tail指向跳跃表的表尾节点
  • level记录跳跃表内，层数最大的那个节点的层数
  • length跳跃表的长度

创建一个新的跳跃表

创建跳跃表函数在t_zset.c/zslCreate
在这里插入图片描述

zskiplistNode *zslCreateNode(int level, double score, sds ele) {
    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;
    zsl->length = 0;
    //初始化跳跃表节点
    zsl->header = zslCreateNode(ZSKIPLIST_MAXLEVEL,0,NULL);
    //初始化最大层级为32
    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;
}

添加新节点到跳跃表

添加新节点到跳跃表是调用zslInsert函数实现的，我们将配合例子分段讲解。
假设我们要在已有跳跃表中插入新的节点29,跳跃表示例如图表示：
在这里插入图片描述

zskiplistNode *zslInsert(zskiplist *zsl, double score, sds ele) {
    zskiplistNode *update[ZSKIPLIST_MAXLEVEL], *x;
    unsigned int rank[ZSKIPLIST_MAXLEVEL];
    int i, level;

    serverAssert(!isnan(score));
    x = zsl->header;
    for (i = zsl->level-1; i >= 0; i--) {
        rank[i] = i == (zsl->level-1) ? 0 : rank[i+1];
        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;
    }
    .....
}

步骤一:
在这里插入图片描述

  1. 由最高层开始遍历，i不断递减
  2. 如果前进指针不为空并且前进指针的分数小于插入节点的分数或者还有一种情况是两者分数相等，则需要条件是前进指针的字符串长度小于插入节点的字符串长度。
  3. 满足第二步条件会累加该层级的每个跳跃节点的span值，得到每个层级的rank[i]和新插入节点的前驱如图标红的update[i]。

步骤二：

.....
	//计算出新节点的层高
	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;
    }
.....

在这里插入图片描述

  1. 得到第一步每层的update[i]和rank[i]之后，我们知道了插入的位置，如图虚线部分。
  2. 通过zslRandomLevel计算出新插入节点的层高,假设层高level为5
  3. 因为层级为5已经超出跳跃表的层级5，所以同样的我们要在L5计算出rank[i]和update[i],可以得到rank[4]=0,update[4]为header节点。
  4. 最后更新一下跳跃表最高层级为5。

步骤三：

.....
	x = zslCreateNode(level,score,ele);
    for (i = 0; i < level; i++) {
        x->level[i].forward = update[i]->level[i].forward;
        update[i]->level[i].forward = x;

        /* update span covered by update[i] as x is inserted here */
        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];
    if (x->level[0].forward)
        x->level[0].forward->backward = x;
    else
        zsl->tail = x;
    zsl->length++;
    return x;

在这里插入图片描述

  1. 新插入节点的前进指针等于新插入节点的前驱的前进指针
  2. 新插入节点的前驱的前进指针改为指向新插入节点
  3. 新节点的span=新插入节点前驱的span-(rank[0]-rank[i])
  4. 新插入节点前驱的span=(rank[0] - rank[i]) + 1
  5. 更新插入节点的后退指针

每插入一个节点需要修改的部分为新插入节点的前驱节点的前进指针指向和span,还有新插入节点自身的前进指针指向和span,这里和链表类似。如果对3、4号不是特别理解，可以看如下图理解,比如在第四层，我们要计算出新插入节点的span，和新插入节点的前驱的span。

x->level[3].span =update[3]->level[3].span - (rank[0] - rank[i])= 3-(4-2)=1
update[3]->level[3].span =(rank[0] - rank[3]) + 1= (4-2)+1=3

在这里插入图片描述

删除节点

删除节点我们配合例子分段讲解。
假设我们要在已有跳跃表中删除分值为29的节点,跳跃表示例如图表示：
在这里插入图片描述

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;
    }
    /* We may have multiple elements with the same score, what we need
     * is to find the element with both the right score and object. */
    x = x->level[0].forward;
    if (x && score == x->score && sdscmp(x->ele,ele) == 0) {
        zslDeleteNode(zsl, x, update);
        if (!node)
            zslFreeNode(x);
        else
            *node = x;
        return 1;
    }
    return 0; /* not found */
}
  1. 找到每个层级要删除节点的前驱,如图标红部分：
    在这里插入图片描述
  2. 最底层L1要删除节点的前驱的前进指针就是可能要删除的节点,表示为x = x->level[0].forward，分值相等并且字符串长度相等则表示是要删除的节点数据。
    在这里插入图片描述
  3. 更新每层要删除节点的前驱的span和forward,更新最底层L1的后退指针,具体的方法为zslDeleteNode。
void zslDeleteNode(zskiplist *zsl, zskiplistNode *x, zskiplistNode **update) {
    int i;
    //更新每个层级的update[i]的span和forward
    for (i = 0; i < zsl->level; i++) {
        if (update[i]->level[i].forward == x) {
            update[i]->level[i].span += x->level[i].span - 1;
            update[i]->level[i].forward = x->level[i].forward;
        } else {
            update[i]->level[i].span -= 1;
        }
    }
    //更新最底层的后退指针
    if (x->level[0].forward) {
        x->level[0].forward->backward = x->backward;
    } else {
        zsl->tail = x->backward;
    }
    while(zsl->level > 1 && zsl->header->level[zsl->level-1].forward == NULL)
        zsl->level--;
    zsl->length--;
}

在这里插入图片描述
在这里插入图片描述

修改节点

修改节点的方法为zslUpdateScore，其实就是删除后重新插入的结果，所以这里不再重复讲解。

获得排位

给定分数和成员，计算出排位

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;
        }

        /* x might be equal to zsl->header, so test if obj is non-NULL */
        if (x->ele && sdscmp(x->ele,ele) == 0) {
            return rank;
        }
    }
    return 0;
}

更多讲解,欢迎关注我的github:
go成神之路

地鼠工程师
关注
专栏目录
如何理解redis跳表源码中的span？
Lance的专栏
12-30 2203
2018年12月30日12:26:04 我扑在跳表上，前后反复研究了十几二十次，一直都理解不了（大脑拒绝理解，停机）。昨晚下定决心（总结以前和现在学到的所有信息），拆分逻辑块，过滤这阶段不需要的信息，终于能理解跳表的基本结构了。 看源码有个小技巧（我的），不从main为入口，而是以model（模型）为逻辑块。 （1）先理解整体的zskiplist，哦，这个其实跟普通的链表是一样的，有heade...
Redis 6.0 源码阅读笔记(7) -- ZSet 数据类型源码分析
alpha_love的博客
05-09 388
1. 存储结构 在 有序集合对象 ZSet 的介绍中已经提到 ZSet 集合的底层存储结构主要有两种，其结构示例如下： OBJ_ENCODING_ZIPLIST 当 ziplist 作为 zset 的底层存储结构时，每个集合元素使用两个紧挨在一起的压缩列表节点来保存，第一个节点保存元素值，第二个元素保存元素的分值，而且分值小的靠近表头，大的靠近表尾 OBJ_ENCODING_SKIPLIST 底层实现是跳跃表结合字典。每个跳跃表节点...
【Redis-6.0.8】Redis中的跳表
Edidaughter的博客
04-06 399
1.引用及学习链接 B站跳表相关视频1 B站跳表相关视频2 微信读书《Redis 5设计与源码分析》跳表相关内容 2.
Redis源码（4）跳表zskiplist
最新发布
weixin_43823462的博客
07-20 1186
Redis源码之跳表
Redis学习之跳跃表源码分析
Y先森0.0
07-24 195
跳跃表的定义跳跃表是一种有序数据结构，它通过在每个结点中维持多个指向其他结点的指针，从而达到快速访问其他结点的目的跳跃表的结构关于跳跃表的学习请参考：https://www.jianshu.com/p/ac351674d8eb?utm_campaign=maleskine&utm_content=note&utm_medium=seo_notes&utm_source=re...
Redis源码-跳表
Jurvis_G的博客
03-09 246
zset 有序集合。这种容器同时使用两种数据结构保存同样的元素，以获得O(logN)插入和删除操作。 元素被添加进入一个哈希表，该哈希表是redis对象和score的映射； 同时元素被添加进入一个跳表，该跳表是score到redis对象的映射。 因此元素在跳表中是被排序好的。 跳表 /* 跳表 */ typedef struct zskiplist { struct zskiplistNode *header, *tail; unsigned long length; int l
【Redis源码】Redis 6.0 字符串 SDS 源码分析
长路漫漫的歇脚处
07-31 733
Redis 6.0 字符串 SDS 源码分析
Redis6.0-SourceCodeNote:Redis6.0源码阅读笔记-redis source code
03-25
Redis6.0-SourceCodeNote 长期更新Redis6.0原始阅读笔记 目前进度： 内存管理，源文件为zmalloc.h，zmalloc.c SDS（​​简单动态字符串），源文件为sdsalloc.h，sds.h，sds.c ...跳跃表，源文件为server.h，t_zset.c
Java面试丨Redis从基础到源码面试题（参考答案）
weixin_45985053的博客
08-10 274
java面试必备丨Redis从基础到源码面试题
Java面试丨Redis经典 20题
weixin_45985053的博客
08-08 1001
Redis，英文全称是（远程字典服务），是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。与MySQL数据库不同的是，Redis的数据是存在内存中的。它的读写速度非常快，每秒可以处理超过10万次读写操作。因此redis被广泛应用于缓存，另外，Redis也经常用来做分布式锁。除此之外，Redis支持事务、持久化、LUA 脚本、LRU 驱动事件、多种集群方案。...
Redis原理篇
weixin_46925850的博客
03-02 2751
Redis 一些原理性解答
Redis源码——跳跃表
qq_16500963的博客
11-19 87
在了解跳跃表之前，我们先了解一下有序链表。有序链表是所有元素以递增或递减方式有序排列的数据结构，其中每个节点都有指向下个节点的next指针，最后一个节点的next指针指向NULL。递增有序链表举例如下图所示。如上图所示的有序链表，如果要查询值为51的元素，需要从第一个元素开始依次向后查找、比较才可以找到，查找顺序为1→11→21→31→41→51，共6次比较，时间复杂度为O(N)。
Redis跳跃表源码解析
qq_35181209的博客
04-23 1024
跳跃表是一种有序的数据结构，支持平均O(logN)、最坏O(N)复杂度的节点查找。跳跃表应用在有序集合键和集群节点的场景上。本文参考Redis3.0版本的源码，注释参考了黄建宏的注释，并加上自己的理解。对于跳跃表和节点的定义是在redis.h中，而常用API的实现是在t_zset.c中。定义：/* * 跳跃表 */ typedef struct zskiplist { // 表头节点...
深挖 Redis 6.0 源码—— SDS
傲雪滨锋
08-20 668
本文精选自 Doocs 开源社区旗下“源码猎人”项目，作者杨立滨。项目将会持续更新，欢迎 Star 关注。项目地址：https://github.com/doocs/source-cod...
Redis 6.0源码学习 RedisObject
努力推石头的西西弗斯
07-28 653
  Redis 是一个开源(BSD许可)、基于内存、高性能的数据结构,可以作为K-V数据库、缓存、消息代理(message broker)和流引擎。  Redis提供了许多数据结构，诸如String、Hash、List、Set、Sorted Set、BitMap、Hyperloglog、Geospatial index和Stream。  Redis 使用标准版本标记进行版本控制：major.minor.patchlevel。偶数的版本号表示稳定的版本， 例如 1.2，2.0，2.2，2.4，2.6，2.8，
Redis - 跳表
wang_zhao_的博客
07-25 493
跳表0. 前言1. 结构源码2. 创建3. 插入4. 删除5. 获取 0. 前言        Redis的跳表在面试过程中，经常被问到，这里通过源码深入研究一个其实现原理。 1. 结构源码 // 跳表中的每一个节点的结构 typedef struct zskiplistNode { // 成员对象，sds 结构 sds ele; // 分值 double score; // 后退指针，指向当前节点
redis6.0源码学习（一）学习路径
程序员学编程 的专栏
12-08 368
redis6.0源码学习（一）学习路径 参考网上给出来的学习路径对源码进行学习，同时用博客的形式记录学习过程。 1 、熟悉Redis的数据结构部分 内存分配 zmalloc.c和zmalloc.h 动态字符串 sds.h和sds.c 双端链表 adlist.c和adlist.h 字典 dict.h和dict.c 跳跃表 server.h文件里面关于zskiplist结构和zskiplistNode结构，以及t_zset.c中所有zsl开头的函数，比如 zslCreate、zslInsert、zslDele
Redis 6.0 源码阅读笔记(6)-Set 数据类型源码分析
谈谈1974
09-20 1078
文章目录1. 存储的结构2. 源码分析 1. 存储的结构 在 redis 集合对象 Set 的介绍中我们知道 redis 对于集合对象 Set 有以下两种存储形式，其内存结构如下所示： OBJ_ENCODING_INTSET 集合保存的所有元素都是整数值是将会采用这种存储结构，但当集合对象保存的元素数量超过512 (由server.set_max_intset_entries 配置)后会转化为 OBJ_ENCODING_HT OBJ_ENCODING_HT 底层为 dict 字典，数据作为字典的键
Redis 源码分析跳跃表（skiplist）
CRMEB小程序商城的博客
02-21 814
跳跃表特点 1、按照 score 来排序，如果 score 相等，那么则按照 ele 来排序。 2、平均查询时间复杂度 O(logn)。 跳跃表实现 跳跃表是由 server.h/zskiplistNode 和 server.h/zskiplist 两个结构定义其中 zskiplistNode 结构用于订阅跳跃表的节点，而 zskiplist 结构用于保存跳跃表相关的信息，比如节点的数量，以及想表头节点和表尾节点的指针等 跳跃表实现 server.h/zskiplistNode 结构定义： /* ZSETs
Redis6.0之后
05-07
Redis 6.0 是 Redis 的一个重大版本更新，它带来了很多新的特性和改进，以下是其中一些主要的更新： 1. 有序集合模块 (Modules)：Redis 6.0 引入了一个全新的有序集合模块，它提供了一种新的方式来创建、扩展和管理...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值