Redis使用及源码剖析-5.Redis跳跃表-2021-1-19

最新推荐文章于 2023-10-18 09:58:52 发布
最新推荐文章于 2023-10-18 09:58:52 发布
阅读量142 收藏
点赞数
分类专栏： redis 文章标签： redis 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37292982/article/details/112837664
版权

文章目录

前言

跳跃表是Redis的底层数据结构之一，跳跃表（skiplist）是一种有序数据结构， 它通过在每个节点中维持多个指向其他节点的指针， 从而达到快速访问节点的目的。跳跃表支持平均 O(\log N) 最坏 O(N) 复杂度的节点查找， 还可以通过顺序性操作来批量处理节点。在大部分情况下， 跳跃表的效率可以和平衡树相媲美， 并且因为跳跃表的实现比平衡树要来得更为简单， 所以有不少程序都使用跳跃表来代替平衡树。
Redis跳表实现涉及redis.h 中的 zskiplist 结构和 zskiplistNode 结构， 以及 t_zset.c 中所有以 zsl 开头的函数， 比如 zslCreate 、 zslInsert 、 zslDeleteNode ，本文将详细分析Redis跳表的实现。

一、跳表节点实现

Redis跳跃表节点实现代码如下：

/*
 * 跳跃表节点
 */
typedef struct zskiplistNode {

    // 成员对象
    robj *obj;

    // 分值
    double score;

    // 后退指针
    struct zskiplistNode *backward;

    // 层
    struct zskiplistLevel {

        // 前进指针
        struct zskiplistNode *forward;

        // 跨度
        unsigned int span;

    } level[];

} zskiplistNode;

其中obj为跳跃表存放的数据成员，在跳跃表中必须唯一。score为跳跃表的分值，跳跃表节点就是按照分值排序的，分值可以重复。backward指向前一个跳跃表节点，便于倒序遍历跳表。level是柔性数组，实际节点中level按照节点层数来分配内存，其中forward指针指向该层的下一个节点，span记录的是两个节点的跨度。
一个实际的跳跃表示意图如下：
在这里插入图片描述

二、跳表实现

虽然仅靠多个跳跃表节点就可以组成一个跳跃表，但通过使用一个 zskiplist 结构来持有这些节点， 程序可以更方便地对整个跳跃表进行处理， 比如快速访问跳跃表的表头节点和表尾节点， 又或者快速地获取跳跃表节点的数量等信息。跳跃表的实现如下所示：

/*
 * 跳跃表
 */
typedef struct zskiplist {

    // 表头节点和表尾节点
    struct zskiplistNode *header, *tail;

    // 表中节点的数量
    unsigned long length;

    // 表中层数最大的节点的层数
    int level;

} zskiplist;

其中header和tail分别为表头和表尾指针，length是跳表节点数目（不包括header），level是跳表中除了header以外节点中层数的最大值。

三、跳表API

1、随机生成层数

每次生成一个新的跳表节点时都要指定该节点的层数，层数是按照翻硬币的方式随机产生的，如下所示：

/* 
 * 返回一个随机值，用作新跳跃表节点的层数。
 * 返回值介乎 1 和 ZSKIPLIST_MAXLEVEL 之间（包含 ZSKIPLIST_MAXLEVEL），
 * 根据随机算法所使用的幂次定律，越大的值生成的几率越小。
 *
 * T = O(N)
 */
#define ZSKIPLIST_P 0.25      /* Skiplist P = 1/4 */
#define ZSKIPLIST_MAXLEVEL 32
int zslRandomLevel(void) {
    int level = 1;

    while ((random()&0xFFFF) < (ZSKIPLIST_P * 0xFFFF))
        level += 1;

    return (level<ZSKIPLIST_MAXLEVEL) ? level : ZSKIPLIST_MAXLEVEL;
}

2、创建跳表节点

根据层数，分值和数据可以创建跳表节点，如下所示：

/*
 * 创建一个层数为 level 的跳跃表节点，
 * 并将节点的成员对象设置为 obj ，分值设置为 score 。
 *
 * 返回值为新创建的跳跃表节点
 *
 * T = O(1)
 */
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;
}

3、创建跳表

初始化空跳表的函数如下，其中header节点是按照最大层数ZSKIPLIST_MAXLEVEL创建的：

/*
 * 创建并返回一个新的跳跃表
 *
 * T = O(1)
 */
zskiplist *zslCreate(void) {
    int j;
    zskiplist *zsl;

    // 分配空间
    zsl = zmalloc(sizeof(*zsl));

    // 设置高度和起始层数
    zsl->level = 1;
    zsl->length = 0;

    // 初始化表头节点
    // T = O(1)
    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;
}

4、计算节点排位

排位rank表示该节点是跳表的第几个节点，计算排位API如下：

/* Find the rank for an element by both score and key.
 *
 * 查找包含给定分值和成员对象的节点在跳跃表中的排位。
 *
 * Returns 0 when the element cannot be found, rank otherwise.
 *
 * 如果没有包含给定分值和成员对象的节点，返回 0 ，否则返回排位。
 *
 * Note that the rank is 1-based due to the span of zsl->header to the
 * first element. 
 *
 * 注意，因为跳跃表的表头也被计算在内，所以返回的排位以 1 为起始值。
 *
 * T_wrost = O(N), T_avg = O(log N)
 */
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;
        }

        /* x might be equal to zsl->header, so test if obj is non-NULL */
        // 必须确保不仅分值相等，而且成员对象也要相等
        // T = O(N)
        if (x->obj && equalStringObjects(x->obj,o)) {
            return rank;
        }
    }

    // 没找到
    return 0;
}

5、插入新节点

根据分值和数据插入新节点的代码如下：

/*
 * 创建一个成员为 obj ，分值为 score 的新节点，
 * 并将这个新节点插入到跳跃表 zsl 中。
 * 
 * 函数的返回值为新节点。
 *
 * T_wrost = O(N^2), T_avg = O(N log N)
 */
zskiplistNode *zslInsert(zskiplist *zsl, double score, robj *obj) {
    zskiplistNode *update[ZSKIPLIST_MAXLEVEL], *x;
    unsigned int rank[ZSKIPLIST_MAXLEVEL];
    int i, level;

    redisAssert(!isnan(score));

    // 在各个层查找节点的插入位置
    // T_wrost = O(N^2), T_avg = O(N log N)
    x = zsl->header;
    for (i = zsl->level-1; i >= 0; i--) {

        /* store rank that is crossed to reach the insert position */
        // 如果 i 不是 zsl->level-1 层
        // 那么 i 层的起始 rank 值为 i+1 层的 rank 值
        // 各个层的 rank 值一层层累积
        // 最终 rank[0] 的值加一就是新节点的前置节点的排位
        // rank[0] 会在后面成为计算 span 值和 rank 值的基础
        rank[i] = i == (zsl->level-1) ? 0 : rank[i+1];

        // 沿着前进指针遍历跳跃表
        // T_wrost = O(N^2), T_avg = O(N log N)
        while (x->level[i].forward &&
            (x->level[i].forward->score < score ||
                // 比对分值
                (x->level[i].forward->score == score &&
                // 比对成员， T = O(N)
                compareStringObjects(x->level[i].forward->obj,obj) < 0))) {

            // 记录沿途跨越了多少个节点
            rank[i] += x->level[i].span;

            // 移动至下一指针
            x = x->level[i].forward;
        }
        // 记录将要和新节点相连接的节点
        update[i] = x;
    }

    /* we assume the key is not already inside, since we allow duplicated
     * scores, and the re-insertion of score and redis object should never
     * happen since the caller of zslInsert() should test in the hash table
     * if the element is already inside or not. 
     *
     * zslInsert() 的调用者会确保同分值且同成员的元素不会出现，
     * 所以这里不需要进一步进行检查，可以直接创建新元素。
     */

    // 获取一个随机值作为新节点的层数
    // T = O(N)
    level = zslRandomLevel();

    // 如果新节点的层数比表中其他节点的层数都要大
    // 那么初始化表头节点中未使用的层，并将它们记录到 update 数组中
    // 将来也指向新节点
    if (level > zsl->level) {

        // 初始化未使用层
        // T = O(1)
        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);

    // 将前面记录的指针指向新节点，并做相应的设置
    // T = O(1)
    for (i = 0; i < level; i++) {
        
        // 设置新节点的 forward 指针
        x->level[i].forward = update[i]->level[i].forward;
        
        // 将沿途记录的各个节点的 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]);

        // 更新新节点插入之后，沿途节点的 span 值
        // 其中的 +1 计算的是新节点
        update[i]->level[i].span = (rank[0] - rank[i]) + 1;
    }

    /* increment span for untouched levels */
    // 未接触的节点的 span 值也需要增一，这些节点直接从表头指向新节点
    // T = O(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;
}

其中update数组记录了每一层待插入节点的前一个节点。rank记录的是每层查找节点插入位置时跨过的节点数目，rank[0]+1表示插入节点的跳表的第几个节点。

6、删除节点

删除节点函数如下所示：

/* Internal function used by zslDelete, zslDeleteByScore and zslDeleteByRank 
 * 
 * 内部删除函数，
 * 被 zslDelete 、 zslDeleteRangeByScore 和 zslDeleteByRank 等函数调用。
 *
 * T = O(1)
 */
void zslDeleteNode(zskiplist *zsl, zskiplistNode *x, zskiplistNode **update) {
    int i;

    // 更新所有和被删除节点 x 有关的节点的指针，解除它们之间的关系
    // T = O(1)
    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;
        }
    }

    // 更新被删除节点 x 的前进和后退指针
    if (x->level[0].forward) {
        x->level[0].forward->backward = x->backward;
    } else {
        zsl->tail = x->backward;
    }

    // 更新跳跃表最大层数（只在被删除节点是跳跃表中最高的节点时才执行）
    // T = O(1)
    while(zsl->level > 1 && zsl->header->level[zsl->level-1].forward == NULL)
        zsl->level--;

    // 跳跃表节点计数器减一
    zsl->length--;
}

/* Delete an element with matching score/object from the skiplist. 
 *
 * 从跳跃表 zsl 中删除包含给定节点 score 并且带有指定对象 obj 的节点。
 *
 * T_wrost = O(N^2), T_avg = O(N log N)
 */
int zslDelete(zskiplist *zsl, double score, robj *obj) {
    zskiplistNode *update[ZSKIPLIST_MAXLEVEL], *x;
    int i;

    // 遍历跳跃表，查找目标节点，并记录所有沿途节点
    // T_wrost = O(N^2), T_avg = O(N log N)
    x = zsl->header;
    for (i = zsl->level-1; i >= 0; i--) {

        // 遍历跳跃表的复杂度为 T_wrost = O(N), T_avg = O(log N)
        while (x->level[i].forward &&
            (x->level[i].forward->score < score ||
                // 比对分值
                (x->level[i].forward->score == score &&
                // 比对对象，T = O(N)
                compareStringObjects(x->level[i].forward->obj,obj) < 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 = x->level[0].forward;
    if (x && score == x->score && equalStringObjects(x->obj,obj)) {
        // T = O(1)
        zslDeleteNode(zsl, x, update);
        // T = O(1)
        zslFreeNode(x);
        return 1;
    } else {
        return 0; /* not found */
    }

    return 0; /* not found */
}

总结

跳表是一个较为复杂的数据结构，特别是节点插入删除时设计到一系列节点的更新操作，需要详细阅读代码才能理解。

复习备考的龙龙
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python构建多叉树及多叉树的倒序遍历
cloud____的博客
09-13 2180
AllTreePath=[] class MultywayTree(): class Node():#初始化节点 def __init__(self,data): self.data=data self.child_list=[] self.parent=None def __init__(self,root):#初始化根节点 self.root=self.Node(root)
链表的基本操作#周报
xyycrossworld的博客
12-13 249
链表的基本操作 在说链表之前，我们先说说顺序存储。其中我们最熟悉的一种顺序存储的数据结构就是数组，当我们想要给数组中插入一个元素时，为保证顺序以及其他元素不丢失，我们需要在插入元素后，将后面的元素整体后移。所以容易看出这样有着这两个弊端：第一：我们所需要移动的元素有很多时，会浪费算力。第二：我们必须为数组开足够多的空间，否则会存在溢出风险。 为了避免这两个弊端，我们引入链式存储——链表。 什么是链表？ 简单来说，链表的利用结构体，额外开辟出一份内存空间去作指针，它总是指向下一个结点，
python循环构建多叉树、python全路径遍历多叉树
Fan-Yan的博客
10-18 878
一、全路径遍历多叉树 一般多叉树遍历有两种方法，先序遍历和后序遍历，这两种遍历方法每个节点只访问一遍，但我的情况是想要得到每一条从根节点到叶子节点的路径。 多叉树的数据结构及从根节点到叶子节点的遍历算法如下：二、自动构建多叉树 实际不可能手动构建而需要根据如下表自动构建多叉树，循环构建多叉树的代码如下：
JAVA实现图的构建、BFS、DFS（分邻接矩阵存储与邻接表存储）
No_Words_的博客
09-13 949
一、文章内容 1、以邻接矩阵存储的图（构建、BFS、DFS） 2、以邻接表存储的图（构建、BFS、DFS） 3、广度优先遍历用到的队列 二、以邻接矩阵存储的图（构建、BFS、DFS） 1、AMGraph.java import java.util.Scanner; // 邻接矩阵存储的图，以无向网为例 public class AMGraph { private static final int MAXINT = 10000;// 作为极大值 private static f
236 二叉树的最近公共祖先（递归）
二哈
05-16 283
1. 问题描述： 给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。百度百科中最近公共祖先的定义为：“对于有根树 T 的两个节点 p、q，最近公共祖先表示为一个节点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先） 示例 1： 输入：root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 输出：3 解释：节点 5 和节点 1 的最近公共祖先是节点 3 。 示例 2： 输入：root = [3,5,1,
redis-5.0.14-1.el7.remi.x86-64.rpm安装包(含有部署手册)
06-26
redis-5.0.14-1.el7.remi.x86_64.rpm安装包(含有部署手册) redis-5.0.14-1.el7.remi.x86_64.rpm安装包(含有部署手册) redis-5.0.14-1.el7.remi.x86_64.rpm安装包(含有部署手册) redis-5.0.14-1.el7.remi.x86_64.rpm...
redis-desktop-manager-0.9.3.817.exe
06-01
redis-desktop-manager-0.9.3.817.exeredis-desktop-manager-0.9.3.817.exeredis-desktop-manager-0.9.3.817.exeredis-desktop-manager-0.9.3.817.exeredis-desktop-manager-0.9.3.817.exeredis-desktop-manager-0.9...
redis-desktop-manager-0.8.8.384 Redis 客户端安装包
最新发布
03-19
至于安装和使用方面，用户可以通过下载相应的安装文件（如“redis-desktop-manager-0.8.8.384.exe”），然后按照安装向导进行操作。在软件安装完成后，用户可以新建一个连接，输入Redis服务器的相关信息（如IP地址、...
redis-desktop-manager-2019.4.0.exe
09-12
redis-desktop-manager-2019.4.0.exe
redis-5.0.12-1.el7.x86_64.rpm
07-19
redis 5.0.12的rpm包
LeetCode系列236—二叉树的最近公共祖先
fkuner的博客
09-14 56
题意 236. 二叉树的最近公共祖先 题解 方法一：递归 class Solution { public: TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) { if(root == nullptr || root == p || root == q) return root; TreeNode *left = lowestCommonAncestor(root->l
力扣第236题 二叉树的最近公共祖先 c++ 递归和回溯 附注释和简短代码
lenyan~的博客
10-12 376
相关标签给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。中最近公共祖先的定义为：“对于有根树 T 的两个节点 p、q，最近公共祖先表示为一个节点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（3节点5和节点1的最近公共祖先是节点3。5节点5和节点4的最近公共祖先是节点5。因为根据定义最近公共祖先节点可以为节点本身。1[2, 105]Node.val互不相同p!= qpq。
Python 从字典构造多叉树
空巢青年_rui的博客
06-23 2100
构造一个树节点类，每个节点都有一个int类型的值（val），和0个或多个子节点childs。 给定一个字典，其中字典的key为当前节点的val，value对应列表对应当前节点的childs的val值。请将该字典的构造为多叉树结构，使用root表示数的根节点，并打印每个节点的值及其子节点的值。（这里确保OrderDict字典的第一个key为树的根节点）。 运行结果： 对于第二种输出格式，其关系为：......
php递归有限分类,PHP实现无限级分类（不使用递归）
weixin_36445866的博客
03-18 374
在进行无限极分类中最常用的算法就是“递归”，熟悉PHP语言的朋友肯定知道，PHP不擅长递归 ,而且递归次数有限(100次左右，因操作系统和配置而异)。所以本文将会给大家带来几种不使用递归实现无限级分类的代码。供大家来学习使用。第一种：无限级分类在开发中经常使用，例如：部门结构、文章分类。无限级分类的难点在于“输出”和“查询”，例如将文章分类输出为列表形式；查找分类A下面所有分类包含的文章。1.实现...
php 三级分叉树,PHP常用的分类树形结构 可实现无限分级
weixin_42441929的博客
03-21 596
在很多系统中会有层级体系，特别是在各种管理系统的菜单、分类、部门等相关模块。一般而言，系统都会把这些对象保存在数据库中，并用一个pid字段去记录该对象的父级对象。那么问题来了，当从数据库中重新查出对象列表后，如何重新恢复其层级关系呢？下面的这个函数可以帮到你：/*** 数组层级缩进转换* @param array $array 源数组* @param int $pid* @param int ...
C语言（六）
waittttttttttt的博客
03-06 574
1、二叉树的非递归遍历 本题要求用非递归的方法实现对给定二叉树的 3 种遍历。 输入：输入二叉树结点构建二叉树 输出：输出 3 个函数分别按照访问顺序打印出结点的内容 include <stdio.h> #include <stdlib.h> typedef enum { false, true } bool; typedef char ElementType; typedef struct TNode *Position; typedef Position BinTree
c c++ 线性表之链式存储结构（单链表）
weixin_39926429的博客
01-06 236
#include <stdio.h> #include <stdlib.h> //链表中节点结构 typedef struct Link { int elem; struct Link *next; }link; link * initLink(); void Display(link *p); int _tmain(int argc, _TCHAR* argv[]) { printf("初始化链表：\n"); link *p=initLink(); D...
C语言数据结构循环双链表
m0_51579489的博客
04-09 667
#include<stdio.h> #include<stdlib.h> typedef int elemtype; typedef struct DLNode { elemtype data; struct DLNode* next, * front; }DLNode, * DListlink; DLNode* Creatlist1(DListlink& L, int n) { L = (DLNode*)malloc(sizeof(DLNode));...
php实现数据树形结构 递归方法
genziisme的专栏
09-13 2181
//2.定义递归查询 数据格式化 public function data($pid=0){ $data = \DB::table('types')->where('pid',$pid)->get(); foreach ($data as $key=>$val){ $val->zi = $this->data($val->id);
redis6-x64-window.zip
07-27
redis6-x64-window.zip是一个Windows平台下的Redis软件包文件。Redis是一个开源的内存数据存储系统，常用于快速读写和缓存数据。该软件包适用于64位Windows操作系统。 这个压缩文件包含了Redis的安装文件和相关的配置、文档等文件。通过解压该文件，可以获得Redis在Windows下的可执行文件(redis-server.exe)以及用于操作Redis的命令行工具(redis-cli.exe)。此外，还包含了Redis的配置文件(redis.conf)和一些示例配置文件，用户可以根据需要进行修改。 对于需要在Windows平台运行Redis的用户来说，下载并解压这个zip包是安装和使用Redis的第一步。解压后，用户可以使用redis-server.exe启动Redis服务器，并使用redis-cli.exe进行与服务器的交互。通过配置redis.conf文件，可以设置Redis的监听端口、密码、数据持久化方式等参数。 Redis在Windows平台下的安装和配置较为简单，但在生产环境中，还需要进行一些额外的设置，如设置Redis服务的启动方式、配置Redis的持久化机制等。因此，在使用Redis时，建议用户参考Redis的官方文档和相关教程，对Redis的安装、配置和使用进行更加详细的了解。 总而言之，redis6-x64-window.zip是Redis在Windows平台下的安装包，通过解压该文件，可以得到Redis的可执行文件和配置文件，从而在Windows系统下安装和使用Redis。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值