Redis数据结构 跳跃表

目录

简介

为什么使用跳跃表

跳跃表的实现

跳跃表节点

层

前进指针

跨度

后退指针

分值和成员

跳跃表

随机层数

创建跳跃表

插入节点实现

节点删除实现

节点更新实现

元素排名的实现

跳跃表API

重点回顾

---

简介

跳跃表(skiplist)是一种有序数据结构，它通过在每个节点中维持多个指向其他节点的 指针，从而达到快速访问节点的目的。

跳跃表支持平均O(logN)、最坏O(N)复杂度的节点查找，还可以通过顺序性操作来批 量处理节点。

在大部分情况下，跳跃表的效率可以和平衡树相媲美，并且因为跳跃表的实现比平衡树 要来得更为简单，所以有不少程序都使用跳跃表来代替平衡树。

Redis使用跳跃表作为有序集合键的底层实现之一，如果一个有序集合包含的元素数量 比较多，又或者有序集合中元素的成员(member)是比较长的字符串时，Redis就会使用跳 跃表来作为有序集合键的底层实现。

举个例子，fruit-price是一个有序集合键，这个有序集合以水果名为成员，水果价 钱为分值，保存了30款水果的价钱：

fruit-price有序集合的所有数据都保存在一个跳跃表里面，其中每个跳跃表节点(node)都保存了一款水果的价钱信息，所有水果按价钱的高低从低到高在跳跃表里面排序：

跳跃表的第一个元素的成员为"banana", 它的分值为5;

跳跃表的第二个元素的成员为"cherry". 它的分值为6.5;

跳跃表的第三个元素的成员为"apple", 它的分值为8;

和链表、字典等数据结构被广泛地应用在Redis内部不同，Redis只在两个地方用到了 跳跃表，一个是实现有序集合键，另一个是在集群节点中用作内部数据结构，除此之外，跳 跃表在Redis里面没有其他用途。

为什么使用跳跃表

首先，因为 zset 要支持随机的插入和删除，所以它 不宜使用数组来实现，关于排序问题，我们也很容易就想到 红黑树/ 平衡树 这样的树形结构，为什么 Redis 不使用这样一些结构呢？

性能考虑： 在高并发的情况下，树形结构需要执行一些类似于 rebalance 这样的可能涉及整棵树的操作，相对来说跳跃表的变化只涉及局部 (下面详细说)；

实现考虑： 在复杂度与红黑树相同的情况下，跳跃表实现起来更简单，看起来也更加直观；

基于以上的一些考虑，Redis 基于 William Pugh 的论文做出一些改进后采用了 跳跃表 这样的结构。

本质是解决查找问题

我们先来看一个普通的链表结构：

 我们需要这个链表按照 score 值进行排序，这也就意味着，当我们需要添加新的元素时，我们需要定位到插入点，这样才可以继续保证链表是有序的，通常我们会使用 二分查找法，但二分查找是有序数组的，链表没办法进行位置定位，我们除了遍历整个找到第一个比给定数据大的节点为止 （时间复杂度 O(n)) 似乎没有更好的办法。

但假如我们每相邻两个节点之间就增加一个指针，让指针指向下一个节点，如下图：

 这样所有新增的指针连成了一个新的链表，但它包含的数据却只有原来的一半 （图中的为 3，11）。

现在假设我们想要查找数据时，可以根据这条新的链表查找，如果碰到比待查找数据大的节点时，再回到原来的链表中进行查找，比如，我们想要查找 7，查找的路径则是沿着下图中标注出的红色指针所指向的方向进行的：

 这是一个略微极端的例子，但我们仍然可以看到，通过新增加的指针查找，我们不再需要与链表上的每一个节点逐一进行比较，这样改进之后需要比较的节点数大概只有原来的一半。

利用同样的方式，我们可以在新产生的链表上，继续为每两个相邻的节点增加一个指针，从而产生第三层链表：

 

在这个新的三层链表结构中，我们试着 查找 13，那么沿着最上层链表首先比较的是 11，发现 11 比 13 小，于是我们就知道只需要到 11 后面继续查找，从而一下子跳过了 11 前面的所有节点。

可以想象，当链表足够长，这样的多层链表结构可以帮助我们跳过很多下层节点，从而加快查找的效率。

更进一步的跳跃表

跳跃表 skiplist 就是受到这种多层链表结构的启发而设计出来的。按照上面生成链表的方式，上面每一层链表的节点个数，是下面一层的节点个数的一半，这样查找过程就非常类似于一个二分查找，使得查找的时间复杂度可以降低到 O(logn)。

但是，这种方法在插入数据的时候有很大的问题。新插入一个节点之后，就会打乱上下相邻两层链表上节点个数严格的 2:1 的对应关系。如果要维持这种对应关系，就必须把新插入的节点后面的所有节点 （也包括新插入的节点） 重新进行调整，这会让时间复杂度重新蜕化成 O(n)。删除数据也有同样的问题。

skiplist 为了避免这一问题，它不要求上下相邻两层链表之间的节点个数有严格的对应关系，而是 为每个节点随机出一个层数(level)。比如，一个节点随机出的层数是 3，那么就把它链入到第 1 层到第 3 层这三层链表中。为了表达清楚，下图展示了如何通过一步步的插入操作从而形成一个 skiplist 的过程：

从上面的创建和插入的过程中可以看出，每一个节点的层数（level）是随机出来的，而且新插入一个节点并不会影响到其他节点的层数，因此，插入操作只需要修改节点前后的指针，而不需要对多个节点都进行调整，这就降低了插入操作的复杂度。

现在我们假设从我们刚才创建的这个结构中查找 23 这个不存在的数，那么查找路径会如下图：

 

跳跃表的实现

Redis的跳跃表由redis.h/zskiplistNode和redis.h/zskiplist两个结构定 义，其中zskiplistNode结构用于表示跳跃表节点，而zskiplist结构则用于保存跳 跃表节点的相关信息，比如节点的数量，以及指向表头节点和表尾节点的指针等等。

图展示了一个跳跃表示例，位于图片最左边的是zskiplist结构，该结构包含以下属性：

header: 指向跳跃表的表头节点。

tail: 指向跳跃表的表尾节点。

level: 记录目前跳跃表内，层数最大的那个节点的层数（表头节点的层数不计算 在内）。

length: 记录跳跃表的长度，也即是，跳跃表目前包含节点的数量（表头节点不计 算在内）。

位于zskiplist结构右方的是四个zskiplistNode结构，该结构包含以下属性：

层(level) : 节点中用Ll、L2、L3等字样标记节点的各个层，Ll代表第一层，L2 代表第二层，以此类推。每个层都带有两个属性：前进指针和跨度。前进指针用于 访问位于表尾方向的其他节点，而跨度则记录了前进指针所指向节点和当前节点的 距离。在上面的图片中，连线上带有数字的箭头就代表前进指针，而那个数字就是 跨度。当程序从表头向表尾进行遍历时，访问会沿着层的前进指针进行。

后退(backward)指针：节点中用BW字样标记节点的后退指针，它指向位于当前节 点的前一个节点。后退指针在程序从表尾向表头遍历时使用。

分值(score): 各个节点中的1.0、2.0和3.0是节点所保存的分值。在跳跃表中， 节点按各自所保存的分值从小到大排列。

成员对象(obj): 各个节点中的ol、o2和o3是节点所保存的成员对象。

注意表头节点和其他节点的构造是一样的：表头节点也有后退指针、分值和成员对象，不 过表头节点的这些属性都不会被用到，所以图中省略了这些部分，只显示了表头节点的各个层。

本节接下来的内容将对zskiplistNode和zskiplist两个结构进行更详细的介绍。

跳跃表节点

跳跃表节点的实现由redis.h/zskiplistNode结构定义：

层

跳跃表节点的level数组可以包含多个元素，每个元素都包含一个指向其他节点的指 针，程序可以通过这些层来加快访问其他节点的速度，一般来说，层的数量越多，访问其他 节点的速度就越快。

每次创建一个新跳跃表节点的时候，程序都根据幕次定律(power law, 越大的数出现 的概率越小）随机生成一个介于1和32之间的值作为level数组的大小，这个大小就是 层的“高度”。

图分别展示了三个高度为1层、3层和5层的节点，因为C语言的数组索引总是从 0开始的，所以节点的第一层是level[0], 而第二层是level[1], 以此类推。

前进指针

每个层都有一个指向表尾方向的前进指针(level [i] . forward属性），用于从表头 向表尾方向访问节点。图用虚线表示出了程序从表头向表尾方向，遍历跳跃表中所有节 点的路径：

1)迭代程序首先访问跳跃表的第一个节点（表头），然后从第四层的前进指针移动到表中的第二个节点。

2)在第二个节点时，程序沿着第二层的前进指针移动到表中的第三个节点。

3)在第三个节点时，程序同样沿着第二层的前进指针移动到表中的第四个节点。

4)当程序再次沿着第四个节点的前进指针移动时，它碰到一个NULL, 程序知道这时已经到达了跳跃表的表尾，于是结束这次遍历。

跨度

层的跨度(level [i] . span属性）用于记录两个节点之间的距离：

两个节点之间的跨度越大，它们相距得就越远。

指向NULL的所有前进指针的跨度都为0, 因为它们没有连向任何节点。

初看上去，很容易以为跨度和遍历操作有关，但实际上并不是这样，遍历操作只使用前 进指针就可以完成了，跨度实际上是用来计算排位(rank)的：在查找某个节点的过程中， 将沿途访问过的所有层的跨度累计起来，得到的结果就是目标节点在跳跃表中的排位。

举个例子，图用虚线标记了在跳跃表中查找分值为3.0、成员对象为o3的节点时， 沿途经历的层：查找的过程只经过了一个层，并且层的跨度为3, 所以目标节点在跳跃表中 的排位为3。

再举个例子，图用虚线标记了在跳跃表中查找分值为2.0、成员对象为o2的节点 时，沿途经历的层：在查找节点的过程中，程序经过了两个跨度为1的节点，因此可以计算 出，目标节点在跳跃表中的排位为2

后退指针

节点的后退指针(backward属性）用于从表尾向表头方向访问节点：跟可以一次跳过 多个节点的前进指针不同，因为每个节点只有一个后退指针，所以每次只能后退至前一个节点。

图用虚线展示了如果从表尾向表头遍历跳跃表中的所有节点：程序首先通过跳跃表 的tail指针访问表尾节点，然后通过后退指针访问倒数第二个节点，之后再沿着后退指针 访问倒数第三个节点，再之后遇到指向NULL的后退指针，于是访问结束。

分值和成员

节点的分值(score属性）是一个double类型的浮点数，跳跃表中的所有节点都按 分值从小到大来排序。

节点的成员对象(obj属性）是一个指针，它指向一个字符串对象，而字符串对象则保 存着一个SDS值。

在同一个跳跃表中，各个节点保存的成员对象必须是唯一的，但是多个节点保存的分值 却可以是相同的：分值相同的节点将按照成员对象在字典序中的大小来进行排序，成员对象 较小的节点会排在前面（靠近表头的方向），而成员对象较大的节点则会排在后面（靠近表 尾的方向）。

举个例子，在图所示的跳跃表中，三个跳跃表节点都保存了相同的分值10086.0, 但保存成员对象al的节点却排在保存成员对象02和o3的节点之前，而保存成员对象o2 的节点又排在保存成员对象o3的节点之前，由此可见，ol、o2、o3三个成员对象在字典 中的排序为ol<=o2<=o3。

跳跃表

仅靠多个跳跃表节点就可以组成一个跳跃表，如图所示。

但通过使用一个zskiplist结构来持有这些节点，程序可以更方便地对整个跳跃表进 行处理，比如快速访问跳跃表的表头节点和表尾节点，或者快速地获取跳跃表节点的数量 （也即是跳跃表的长度）等信息，如图所示。

zskiplist结构的定义如下：

header和tail指针分别指向跳跃表的表头和表尾节点，通过这两个指针，程序定位 表头节点和表尾节点的复杂度为O(1)。

通过使用length属性来记录节点的数量，程序可以在O(1)复杂度内返回跳跃表的长度。 level属性则用于在O(1)复杂度内获取跳跃表中层高最大的那个节点的层数量，注意 表头节点的层高并不计算在内。

随机层数

对于每一个新插入的节点，都需要调用一个随机算法给它分配一个合理的层数，源码在 t_zset.c/zslRandomLevel(void) 中被定义：

int zslRandomLevel(void) {
    int level = 1;
    while ((random()&0xFFFF) < (ZSKIPLIST_P * 0xFFFF))
        level += 1;
    return (level<ZSKIPLIST_MAXLEVEL) ? level : ZSKIPLIST_MAXLEVEL;
}

直观上期望的目标是 50% 的概率被分配到 Level 1，25% 的概率被分配到 Level 2，12.5% 的概率被分配到 Level 3，以此类推...有 2-63 的概率被分配到最顶层，因为这里每一层的晋升率都是 50%。

Redis 跳跃表默认允许最大的层数是 32，被源码中 ZSKIPLIST_MAXLEVEL 定义，当 Level[0] 有 264 个元素时，才能达到 32 层，所以定义 32 完全够用了。

创建跳跃表

这个过程比较简单，在源码中的 t_zset.c/zslCreate 中被定义：

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

    // 申请内存空间
    zsl = zmalloc(sizeof(*zsl));
    // 初始化层数为 1
    zsl->level = 1;
    // 初始化长度为 0
    zsl->length = 0;
    // 创建一个层数为 32，分数为 0，没有 value 值的跳跃表头节点
    zsl->header = zslCreateNode(ZSKIPLIST_MAXLEVEL,0,NULL);
    
    // 跳跃表头节点初始化
    for (j = 0; j < ZSKIPLIST_MAXLEVEL; j++) {
        // 将跳跃表头节点的所有前进指针 forward 设置为 NULL
        zsl->header->level[j].forward = NULL;
        // 将跳跃表头节点的所有跨度 span 设置为 0
        zsl->header->level[j].span = 0;
    }
    // 跳跃表头节点的后退指针 backward 置为 NULL
    zsl->header->backward = NULL;
    // 表头指向跳跃表尾节点的指针置为 NULL
    zsl->tail = NULL;
    return zsl;
}

插入节点实现

这几乎是最重要的一段代码了，但总体思路也比较清晰简单，如果理解了上面所说的跳跃表的原理，那么很容易理清楚插入节点时发生的几个动作 （几乎跟链表类似）：

找到当前我需要插入的位置 （其中包括相同 score 时的处理）；

创建新节点，调整前后的指针指向，完成插入；

为了方便阅读，我把源码 t_zset.c/zslInsert 定义的插入函数拆成了几个部分

第一部分：声明需要存储的变量

// 存储搜索路径
zskiplistNode *update[ZSKIPLIST_MAXLEVEL], *x;
// 存储经过的节点跨度
unsignedint rank[ZSKIPLIST_MAXLEVEL];
int i, level;

第二部分：搜索当前节点插入位置

serverAssert(!isnan(score));
x = zsl->header;
// 逐步降级寻找目标节点，得到 "搜索路径"
for (i = zsl->level-1; i >= 0; i--) {
    /* store rank that is crossed to reach the insert position */
    rank[i] = i == (zsl->level-1) ? 0 : rank[i+1];
    // 如果 score 相等，还需要比较 value 值
    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;
}

讨论： 有一种极端的情况，就是跳跃表中的所有 score 值都是一样，zset 的查找性能会不会退化为 O(n) 呢？

从上面的源码中我们可以发现 zset 的排序元素不只是看 score 值，也会比较 value 值 （字符串比较）

第三部分：生成插入节点

/* we assume the element is not already inside, since we allow duplicated
 * scores, reinserting the same element should never happen since the
 * caller of zslInsert() should test in the hash table if the element is
 * already inside or not. */
level = zslRandomLevel();
// 如果随机生成的 level 超过了当前最大 level 需要更新跳跃表的信息
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,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;
}

/* increment span for untouched levels */
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;

节点删除实现

删除过程由源码中的 t_zset.c/zslDeleteNode 定义，和插入过程类似，都需要先把这个 "搜索路径" 找出来，然后对于每个层的相关节点重排一下前向后向指针，同时还要注意更新一下最高层数 maxLevel，直接放源码 (如果理解了插入这里还是很容易理解的)：

/* Internal function used by zslDelete, zslDeleteByScore and zslDeleteByRank */
void zslDeleteNode(zskiplist *zsl, zskiplistNode *x, zskiplistNode **update) {
    int i;
    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--;
}

/* Delete an element with matching score/element from the skiplist.
 * The function returns 1 if the node was found and deleted, otherwise
 * 0 is returned.
 *
 * If 'node' is NULL the deleted node is freed by zslFreeNode(), otherwise
 * it is not freed (but just unlinked) and *node is set to the node pointer,
 * so that it is possible for the caller to reuse the node (including the
 * referenced SDS string at node->ele). */
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;
        return1;
    }
    return0; /* not found */
}

节点更新实现

当我们调用 ZADD 方法时，如果对应的 value 不存在，那就是插入过程，如果这个 value 已经存在，只是调整一下 score 的值，那就需要走一个更新流程。

假设这个新的 score 值并不会带来排序上的变化，那么就不需要调整位置，直接修改元素的 score 值就可以了，但是如果排序位置改变了，那就需要调整位置，该如何调整呢？

从源码 t_zset.c/zsetAdd 函数 1350 行左右可以看到，Redis 采用了一个非常简单的策略：

/* Remove and re-insert when score changed. */
if (score != curscore) {
    zobj->ptr = zzlDelete(zobj->ptr,eptr);
    zobj->ptr = zzlInsert(zobj->ptr,ele,score);
    *flags |= ZADD_UPDATED;
}

把这个元素删除再插入这个，需要经过两次路径搜索，从这一点上来看，Redis 的 ZADD 代码似乎还有进一步优化的空间。

元素排名的实现

跳跃表本身是有序的，Redis 在 skiplist 的 forward 指针上进行了优化，给每一个 forward 指针都增加了 span 属性，用来 表示从前一个节点沿着当前层的 forward 指针跳到当前这个节点中间会跳过多少个节点。在上面的源码中我们也可以看到 Redis 在插入、删除操作时都会小心翼翼地更新 span 值的大小。

所以，沿着 "搜索路径"，把所有经过节点的跨度 span 值进行累加就可以算出当前元素的最终 rank 值了：

/* Find the rank for an element by both score and key.
 * Returns 0 when the element cannot be found, rank otherwise.
 * Note that the rank is 1-based due to the span of zsl->header to the
 * first element. */
unsigned long zslGetRank(zskiplist *zsl, double score, sds ele) {
    zskiplistNode *x;
    unsignedlong 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))) {
            // span 累加
            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;
        }
    }
    return0;
}

跳跃表API

表列出了跳跃表的所有操作API。

重点回顾

跳跃表是有序集合的底层实现之一。

Redis的跳跃表实现由zskiplist和zskiplistNode两个结构组成，其中zskiplist 用于保存跳跃表信息（比如表头节点、表尾节点、长度），而zskiplistNode则用于表 示跳跃表节点。

每个跳跃表节点的层高都是1至32之间的随机数。

在同一个跳跃表中，多个节点可以包含相同的分值，但每个节点的成员对象必须是 唯一的。

跳跃表中的节点按照分值大小进行排序，当分值相同时，节点按照成员对象的大小 进行排序。