Redis源码剖析(跳表)

最新推荐文章于 2024-04-13 22:42:25 发布
最新推荐文章于 2024-04-13 22:42:25 发布
阅读量196 收藏
点赞数
原文链接：https://blog.csdn.net/sinat_35261315/article/details/79028999?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-4.channel_param&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-4.chann
版权

在树形结构中，常见的平衡树有AVL树和红黑树，但是由于AVL树过于平衡，导致维护平衡所需的代价过大，使用的不多，不过其中几种旋转算法还是值得学习的。取而代之的是较为平衡的红黑树，STL中的map和set都是采用红黑树实现的，插入和查找效率为O(logN)。

而跳表也是一种较为平衡的数据结构，与红黑树不同的是，它是链状结构而非树形结构，不过，跳表的插入查找效率也为O(logN)，和红黑树有一拼，而且最重要的是，跳转在实现上比红黑树简单的多。

跳表结构
同数组相比，链表的插入删除效率是O(1)，但是如果想要在链表中查找某个元素，就糟糕了，复杂度会是O(N)，为了提高查找效率，就有了跳表的概念。所谓跳表，就是可以跳跃的链表，回想二分查找算法，每次的查找都是跳跃性的，这才使得二分法效率这么高，跳表的设计同样也借鉴了二分法的策略，实现跳跃查找，当然，需要跳表中的元素有序
普通的链表每个节点仅仅保存了指向下一个节点的指针，只能移动到下一个相邻节点，也就是跳一步。而跳表为了可以一次跳很多步，保存了很多指针，指向该节点后面的不同节点

在server.h头文件中，可以找到跳表节点的定义和跳表的定义

/* 跳表节点 */
typedef struct zskiplistNode {
    robj *obj;  /* 数据 */
    double score; /* 分数 */
    struct zskiplistNode *backward; //前一个节点指针
    struct zskiplistLevel {
        struct zskiplistNode *forward; //后面某个节点，也就是next指针
        unsigned int span; //跨度
    } level[]; /* 跳表中保存了多个指向下一个节点的指针 */
} zskiplistNode;

跳表实际上也是保存键值对的结构，其中obj保存实际的数据而score用于排序使用，这保证了跳表内部是有序的。此外，level数组记录了多个指向后面节点的指针，同时也记录了两个节点之间的跨度;为了方便，接下来将跳表节点中指向下一个节点的指针称为next指针，而level数组称为next数组

/* 跳表 */
typedef struct zskiplist {
    struct zskiplistNode *header, *tail; //表头表尾
    unsigned long length; /* 跳表中节点个数 */
    int level; //跳表总层数
} zskiplist;

跳表定义中记录了表头表尾，level记录了当前跳表的总层数
下面是跳表的一个例子，可以看到，每个节点都有若干个next指针，通过这些指针，可以直线跳跃移动，而不再是只能移动到相邻节点

跳表操作
创建跳表
创建跳表由zslCreate函数实现，函数中需要调用zslCreateNode创建跳表节点，主要就是申请内存，设置初值

//t_zset.c
/**
 * 创建一个跳表节点
 * level : 节点包含的层数，即节点next数组的大小，每一层有一个next指针 
 * score : 该节点的分值，用于使跳表数据有序
 * obj   : 跳表保存的数据
 **/
zskiplistNode *zslCreateNode(int level, double score, robj *obj) {
    /* 申请跳表节点内存 */
    zskiplistNode *zn = zmalloc(sizeof(*zn)+level*sizeof(struct zskiplistLevel));
    /* 设置初值 */
    zn->score = score;
    zn->obj = obj;
    return zn;
}

/* 创建一个跳表 */
zskiplist *zslCreate(void) {
    int j;
    zskiplist *zsl;

    /* 申请跳表内存, 初始总层数为1 */
    zsl = zmalloc(sizeof(*zsl));
    zsl->level = 1;
    zsl->length = 0;
    /* 申请表头节点，默认有32层 */
    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;
}

值得注意的是，表头节点是在创建跳表就申请好的，不属于跳表数据的一部分。

搜索操作
跳表的多数操作都是基于搜索的，考虑这样一个需求，就是在跳表中查找某个节点，如果该节点不存在，找到它应该插入的位置。虽然Redis中没有实现搜索功能，但是后面会看到，插入删除等函数都是基于搜索的
假设此时跳表结构如下，需要从跳表中查找分值为23的节点
在这里插入图片描述
查找操作的步骤如下
从最高层开始尝试移动，比较next节点的分值和待查找分值大小
如果next节点的分值小于待查找分值，则移动到next节点
如果next节点的分值大于等于待查找分值，则降层，如果此时为第0层不能继续降层，当前节点位置就是待查找节点的前一个节点
查找完成后，找到的节点的下一个节点不是待查找节点，就是分值23应该插入的位置

在这里插入图片描述
每次搜索操作，不管是找到还是没找到，返回的节点都是目标位置的前一个节点，所以，需要判断返回节点的下一个节点的分值与给定分值的关系从而得知要查找的节点是否在跳表中。当然也可以获得要插入的位置，比如查找分值为21的节点，返回的同样是指向20的节点，该节点的下一个位置就是分值为21应该插入的位置
插入操作
插入操作实际上就是执行了一遍搜索功能，由于插入一个节点，会破坏某些节点的next数组。所以需要在搜索过程中记录每一层的前一个节点，以插入22为例，每一层的前一个节点分别是7,20,20三个节点(实际上是两个)

//t_zset.c
/* 在跳表中插入节点，值为score数据为obj */
/* 因为插入节点会破坏原跳表的结构，所以需要先找到会被破坏的那些节点 
 * 被破坏的节点是每一层插入位置的前一个节点，因为它的next数组需要更改 */
zskiplistNode *zslInsert(zskiplist *zsl, double score, robj *obj) {
    /* update保存每一层插入位置的前一个节点 */
    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];
        /* 实际上就是跳表的查找规则
         * 如果当前层上的next指针指向的节点分值大于要查找的分值，则在同层移动
         * 如果当前层上的next指针指向的节点分值小于要查找的分值，则降层，不移动 */
        /* 而如果要查找每一层插入位置的上一个节点，那么降层时的节点就要要找的节点 */
        while (x->level[i].forward &&
            (x->level[i].forward->score < score ||
                (x->level[i].forward->score == score &&
                compareStringObjects(x->level[i].forward->obj,obj) < 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 = zslCreateNode(level,score,obj);
    /* 因为新节点只存在[0 : level]层，所以对于高于level层的那些节点没有影响 */
    for (i = 0; i < level; i++) {
        /* 每一层都相当于链表插入 */
        x->level[i].forward = update[i]->level[i].forward;
        update[i]->level[i].forward = x;
        /* 更新跨度span */
        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;
}

删除操作
删除操作首先在跳表中查找需要删除的节点，如果找到，则将其删除。需要注意，删除和插入一样，都会破坏某些节点的next指针，所以需要更新
zslDelete函数用于找到匹配的节点，zslDeleteNode函数用于将节点从跳表中删除

//t_zset.c
/* 从跳表中删除节点 */
void zslDeleteNode(zskiplist *zsl, zskiplistNode *x, zskiplistNode **update) {
    int i;
    /* 对于每一层，改变其next数组和跨度 */
    for (i = 0; i < zsl->level; i++) {
        /* 如果当前节点的当前层的next节点是要删除的节点，改变其next指针和跨度 */
        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--;
}

/* 删除分值score和数据obj匹配的节点 */
int zslDelete(zskiplist *zsl, double score, robj *obj) {
    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 &&
                compareStringObjects(x->level[i].forward->obj,obj) < 0)))
            x = x->level[i].forward;
        update[i] = x;
    }

    /* 判断是否存在要删除的节点，x是插入位置前的节点，那么它的next指针就是需要删除的节点 */
    x = x->level[0].forward;
    if (x && score == x->score && equalStringObjects(x->obj,obj)) {
        /* 如果是，则调用删除节点操作 */
        zslDeleteNode(zsl, x, update);
        zslFreeNode(x);
        return 1;
    }
    return 0; /* not found */
}

计算某个节点的排名
Redis跳表可以计算某个数据在跳表中的排名，由zslGetRank函数完成，函数仍然使用查找方法

//t_zset.c
/* 计算数据o在跳表中的排名 */
unsigned long zslGetRank(zskiplist *zsl, double score, robj *o) {
    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 &&
                compareStringObjects(x->level[i].forward->obj,o) <= 0))) {
            /* 跨度代表当前节点到下一个节点跳过了几个节点，所以排名需要增加跨度个 */
            rank += x->level[i].span;
            x = x->level[i].forward;
        }
        /* 当降层后，说明当前层的下一个节点的值已经大于score了，需要降低一层继续查找
         * 当然也有可能已经找到，所以需要判断是否匹配 */
        if (x->obj && equalStringObjects(x->obj,o)) {
            return rank;
        }
    }
    return 0;
}

对象系统中的跳表
跳表是作为有序集合的底层实现存在的，在object.c文件中，可以看到创建有序集合时将编码设置为跳表

//object.c
/* 创建有序集合对象，底层使用跳表实现 */
robj *createZsetObject(void) {
    /* 申请有序集合内存 */
    zset *zs = zmalloc(sizeof(*zs));
    robj *o;

    /* 为有序集合创建字典 */
    zs->dict = dictCreate(&zsetDictType,NULL);
    /* 创建有序集合中的跳表 */
    zs->zsl = zslCreate();
    o = createObject(OBJ_ZSET,zs);
    /* 设置编码格式为跳表 */
    o->encoding = OBJ_ENCODING_SKIPLIST;
    return o;
}

小结
跳表是较平衡的数据结构，实现简单，插入删除等都是建立在搜索上的。可以发现，搜索是先尝试在高层上移动，因为移动的跨度大，可以快速的达到目的地，当不满足在高层移动的条件时，再降层移动，直到降到最低层。

wrhoylj
关注
【架构师修炼之路】Redis 极简教程 : 基本数据结构, 跳表原理, Spring Boot 项目使用实例
AI天才研究院
11-10 8858
引言 本文主要介绍 Spring Boot 应用中使用 Redis 的基础知识. Redis 是什么 Redis: REmote DIctionary Server Redis is an in-memory database that persists on disk. The data model is key-value, but many different kind of valu...
【架构师修炼之路】Redis 极简教程 : 基本数据结构, 跳表原理, Spring Boot 项目使用实例...
AI天才研究院
11-10 8857
引言 本文主要介绍 Spring Boot 应用中使用 Redis 的基础知识. Redis 是什么 Redis: REmote DIctionary Server Redis is an in-memory database that persists on disk. The data model is key-value, but many differen...
C语言笔记：链表的简单理解
weixin_42124234的博客
09-23 500
文章目录简介代码加图示 简介 （1）什么是链表？其特点是什么？ 线性链表（包括单链表，双向链表，单向循环链表等多种形式，这里仅讨论单链表）是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。我们使用数组可以保存一系列相同类型的数据，但是数组的空间大小是固定不变的（编译时确定），如果数据元素的数量不确定，使用数组来存放就会非常麻烦，经常会出现存储空间浪费...
c语言链表详解
热门推荐
飞剑神
11-24 1万+
c语言链表 1. 链表介绍 c语言的单向链表翻转是面试官常问问题之一,故此,咱就谈一谈,链表并不是如此可怕,学不会,想不通. 链表和数组一样都是存储数据,链表是非连续,非顺序的存储结构. 链表是灵活的内存动态管理(随机分配空间),删除创建结点非常方便 链表组成:由一系列结点组成. 链表结点:实际上是结构体变量. typedef struct _LINKNODE { int dat
如何理解C语言链表,如何理解c语言链表
weixin_36261385的博客
05-21 767
C语言链表就是一种数据结构，可以在上面动态的进行传输分配还可以定义节点数据类别或者实现对节点的增删改查等链表是一种常见的基础数据结构，结构体指针在这里得到了充分的借助。链表可以动态的进行传输分配，也就是说，链表是一个功能极为强大的变量，它可以在结点中定义多种数据类别，还可以按照需要轻易增添，删除，插入节点。接下来将在文章中为你们具体介绍C语言中的链表，希望对你们有所帮助【推荐课程：C语言教程】链表...
c语言单向链表怎么理解,C语言链表怎么理解?
weixin_35836501的博客
05-21 115
看完本文，大家会对C的指针，结构体和链表有一个更深刻的认识。在C中，链表是由一个个小节点链接而成。节点是什么？节点是一个结构体，它包含数据和指向下一个节点的指针。节点怎样链接？节点在内存是随机分布的，它并不是像链表图示那样一个接着一个的。两个节点链接的实现是靠节点中的指针。当获取一个节点时，我们便获取了这个节点里面的数据和指向另一个节点的指针，通过这个指针我们便能够获取下一个节点。这就是链接的实现...
创建双向链表
qq_59978514的博客
08-09 1213
问题描述 创建一个双向链表，并将这个链表中的数据输出在窗体上，输入要查找的学生姓名，将查找的姓名 从链表中删除，并显示删除后的链表。 算法分析 引用头文件 #include <stdio.h> #include <malloc.h> #include <string.h> 声明结构体类型 typedef struct MyStruct { char name[20]; struct MyStruct *prior,*next; }st...
redis源码剖析 | 跳表与压缩列表剖析
lijiewoyun的博客
07-17 1014
6、每次随机一个0-1之间的数，如果这个数小于0.25（25%概率），那就给这个元素加一层指针，持续随机直到大于0.25结束，最终确定这个元素的层数（层数越高，概率越低，且限制最多64层，详见t_zset.c的zslRandomLevel函数）这样一来，当新插入一个结点时，只需要修改前后结点的指针，而其他结点的层数就不需要随之改变了，这就降低了插入操作的复杂度。b跳表是在链表的基础上增加了多级索引，通过索引的几次跳转，实现数据快速定位，跳表的查找复杂度就是O(logN)。...
redis深度剖析一（五种常用的数据类型底层实现）
简单，快乐，拥抱变化
04-05 1983
redis深度剖析之五种数据结构底层
【Redis技术进阶之路】「底层源码解析」揭秘高效存储模型与数据结构底层实现（跳跃表）
最新发布
BASK2311的博客
04-13 782
跳跃表是有序集合的底层实现机制之一，Redis的跳跃表实现精巧地由zskiplist和zskiplistNode两个结构共同构成。其中，zskiplist结构负责保存整个跳跃表的关键信息，如表头节点、表尾节点以及长度等，而zskiplistNode结构则用于具体表示跳跃表中的每一个节点。
redis 源码分析--跳跃表
耿小渣的进阶之路
04-08 232
简介 跳跃表（skiplist）是一种有序的数据结构，它通过在每个节点中维持多个指向其他节点的指针，从而达到快速访问节点的目的。跳跃表支持平均O（logN）、最坏O（N）复杂度的节点查找，还可以通过顺序性操作来批量处理节点。 Redis只在两个地方用到了跳跃表，一个是实现有序集合键，另一个是在集群节点中用作内部数据结构。 定义 typedef struct redisObject { ...
Redis 源码分析跳跃表（skiplist）
CRMEB小程序商城的博客
02-21 827
跳跃表特点 1、按照 score 来排序，如果 score 相等，那么则按照 ele 来排序。 2、平均查询时间复杂度 O(logn)。 跳跃表实现 跳跃表是由 server.h/zskiplistNode 和 server.h/zskiplist 两个结构定义其中 zskiplistNode 结构用于订阅跳跃表的节点，而 zskiplist 结构用于保存跳跃表相关的信息，比如节点的数量，以及想表头节点和表尾节点的指针等 跳跃表实现 server.h/zskiplistNode 结构定义： /* ZSETs
【Redis】Redis跳表与实现源码解析（Redis专栏启动）
小明的Java问道之路
12-12 3886
本文介绍Redis跳表与实现源码解析，包括什么是跳表，跳表的数据结构原理、特点，到Redis源码中的跳表实现。
android 中 ArrayList 、LinkList、List 区别
weixin_30505485的博客
04-19 285
1.大学数据结构中ArrayList是实现了基于动态数组的数据结构，LinkList基于链表的数据结构。 2.对于随机访问get和set，ArrayList优于LinkList，因为LinkedList要移动指针。 3.对于新增和删除操作add和remove，LinkList比较占优势，因为ArrayList要移动数据。 从上面三点可以看出： ArrayList和Lin...
redis 源码分析 跳表实现
hahackeris的专栏
07-04 478
redis 跳表实现
Redis-跳跃列表原理源码分析
哆啦A梦
01-17 475
1、Redis 的 zset 是一个复合结构，结构特点： 1）需要通过hash 结构来存储 value 和 score 的对应关系 2）要支持按照 score 来排序 3）还要按照指定 score 的范围来获取 value 列表的 4）要实现上诉的功能的结构，作者想到了跳跃列表 5）zset的结构：通过一个hash字典加跳跃列表skiplist   2、跳跃列表结构 1）基本结...
Android LinkedList★★
zenmela2011的专栏
04-05 1070
1. LinkedList ①LinkedList是一种可以在任何位置进行高效地插入和移除操作的有序序列，它是基于双向链表实现的。 ②LinkedList 实现 List 接口，能对它进行队列操作；实现 Deque 接口，即能将LinkedList当作双端队列使用；实现了Cloneable接口，即覆盖了函数clone()，能克隆；实现java.io.Serializable接口，这意味着LinkedList支持序列化，能通过序列化去传输。 ③LinkedList 是非同步的。 2.LinkedList.
Android LinkedList 分析
寻梦者
04-13 733
简介 LinkedList是Collection下的一个list实现，它是一个以双向链表实现的List，除了作为List使用，还可以当做队列和栈来使用，下面我们就来看看具体的实现细节。 继承关系图 通过上面的继承关系图，我们知道它实现了List接口，还实现了Queue和Deque接口，所以还能作为双端队列进行使用，最后还实现了Serializable 接口，说明也是可序列化的。 源代码分析 模...
【创】数据结构与算法——双向链表byC语言【C语言网】
ChristinaXinny的博客
12-25 189
//节点结构 typedef struct line{ struct line * prior; //指向直接前趋 int data; struct line * next; //指向直接后继 }line; //创建 line* initLine(line * head){ head=(line*)malloc(sizeof(line));//创建链表第一个结点（首元结点） head-...
Redis源码剖析：RedisObject与数据结构
"Redis源码分析1.基本定义" 在Redis的源码分析中，我们首先会接触到的是Redis的核心数据结构——RedisObject，它是Redis中所有数据类型的抽象表示。RedisObject包含了数据类型、编码方式以及指向实际数据的指针，这...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值