Redis 源码学习之跳跃表

最新推荐文章于 2024-10-20 11:51:06 发布

蜀沐

最新推荐文章于 2024-10-20 11:51:06 发布

阅读量88

点赞数

分类专栏： redis 文章标签： redis 数据结构

本文链接：https://blog.csdn.net/zxdrttu/article/details/120197907

版权

redis 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

跳跃表的应用

跳跃表的性质；
（1）由很多层结构组成；
（2）每一层都是一个有序的链表，排列顺序为由高层到底层，都至少包含两个链表节点，分别是前面的head节点和后面的nil节点；
（4）最底层的链表包含了所有的元素；
（5）如果一个元素出现在某一层的链表中，那么在该层之下的链表也全都会出现（上一层的元素是当前层的元素的子集）；
（6）链表中的每个节点都包含两个指针，一个指向同一层的下一个链表节点，另一个指向下一层的同一个链表节点；
跳跃表是一种有序的数据结构，它通过在每个节点中维持多个指向其他节点的指针，从而达到快速访问的目的。跳跃表在插入、删除和查找操作上的平均复杂度为O（logN），最坏为O（N），可以和红黑树相媲美，但是在实现起来，比红黑树简单很多
redis使用跳表的地方：有序集合键和集群节点中用作内部数据结构

跳跃表数据结构

1、跳表节点和跳表结构

typedef struct zskipilistNode{
   struct zskiplistLevel{
       struct zskipilistNode *forward;  前进指针
       unsigned int span;//跨度
   }level[];
   struct zskipilistNode *backward; //后退指针
   double score;//分数
   robj * obj;//成员对象
}zskipilistNode

层：level数组可以包含多个元素，每个元素都包含一个指向其他节点的指针，程序可以通过这些曾来加快访问其他节点的速度，层越多，速度越快
前进指针:用于从表头向表尾方向访问节点
跨度：用于记录两个节点之间的距离
后退指针：用于从表尾向表头方向访问节点，只能后退至前一个节点
分值：double 类型的数据，跳表中的所有节点都按照分值从小到大来排序
成员对象：是一个指针，指向字符串对象，存着SDS值，在同一个跳跃表中，各个节点保存的成员对象必须是唯一的，但是各个节点保存的分值可以是相同的

typedef struct zskiplist {
    // 跳跃表的表头节点和表尾节点
    struct zskiplistNode *header, *tail;
    // 表中节点的数量
    unsigned long length;
    // 表中层数最大的节点层数
    int level;
} zskiplist;

head 和tail 指针分别指向跳跃表的表头和表尾
length ：记录节点的数量

跳跃表基本操作

创建跳跃表
Redis在创建一个跳跃表的时候完成以下操作：
创建一个zskiplist结构
设定其level为1，长度length为0
初始化一个表头结点，其层数为32层，每一层均指向NULL

/*
 * 创建一个层数为 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;
}

/*
 * 创建并返回一个新的跳跃表
 *
 * T = O(1)
 */
 #define  ZSKIPLIST_MAXLEVEL 32
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;
}

插入节点
插入节点的关键在找到在何处插入该节点，跳跃表是按照score分值进行排序的，其查找步骤大致是：从当前最高的level开始，向前查找，如果当前节点的score小于插入节点的score，继续向前；反之，则降低一层继续查找，直到第一层为止。此时，插入点就位于找到的节点之后
步骤：
创建一个成员为 obj ，分值为 score 的新节点，
并将这个新节点插入到跳跃表 zsl 中。
函数的返回值为新节点。
时间复杂度： T_wrost = O(N), T_avg = O(log N)

zskiplistNode *zslInsert(zskiplist *zsl, double score, robj *obj) {
    zskiplistNode *update[ZSKIPLIST_MAXLEVEL], *x; // updata[]数组记录每一层位于插入节点的前一个节点
    unsigned int rank[ZSKIPLIST_MAXLEVEL]; // rank[]记录每一层位于插入节点的前一个节点的排名
    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--) {
        // 如果 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;
    }
     //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;
        // 计算新节点跨越的节点数量
        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;
    }

    // 未接触的节点的 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;
}

跳跃表删除
Redis提供了三种跳跃表节点删除操作。分别如下： + 根据给定分值和成员来删除节点，由zslDelete函数实现 + 根据给定分值来删除节点，由zslDeleteByScore函数实现 + 根据给定排名来删除节点，由zslDeleteByRank函数实现
上述三种操作的删除节点部分都由zslDeleteNode函数完成。zslDeleteNode函数用于删除某个节点，需要给定当前节点和每一层下当前节点的前一个节点

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

以zslDelete为例，根据节点的分值和成员来删除该节点
从跳跃表 zsl 中删除包含给定节点 score 并且带有指定对象 obj 的节点。
时间复杂度：T_wrost = O(N), T_avg = O( log N)

int zslDelete(zskiplist *zsl, double score, robj *obj) {
    zskiplistNode *update[ZSKIPLIST_MAXLEVEL], *x;
    int i;
    // 遍历跳跃表，查找目标节点，并记录所有沿途节点
    // T_wrost = O(N), T_avg = O(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;
    }
     //检查找到的元素 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;
    }
    return 0; 
}

区间操作
时间复杂度：O(logN),最坏O(N)

// 获取某个区间上第一个符合范围的节点。
zskiplistNode *zslFirstInRange(zskiplist *zsl, zrangespec *range) {
    zskiplistNode *x;
    int i;

    // 判断给定的分值范围是否在跳跃表的范围内
    if (!zslIsInRange(zsl,range)) return NULL;

    x = zsl->header;

    for (i = zsl->level-1; i >= 0; i--) {
        // 如果当前节点的分值小于给定范围的下限则一直向前查找
        while (x->level[i].forward &&
            !zslValueGteMin(x->level[i].forward->score,range))
                x = x->level[i].forward;
    }

    // x的下一个节点才是我们要找的节点
    x = x->level[0].forward;
    serverAssert(x != NULL);

    // 检查该节点不超过给定范围范围
    if (!zslValueLteMax(x->score,range)) return NULL;
    return x;
}
// 获取某个区间上最后一个符合范围的节点。
zskiplistNode *zslLastInRange(zskiplist *zsl, zrangespec *range) {
    zskiplistNode *x;
    int i;

    // 判断给定的分值范围是否在跳跃表的范围内
    if (!zslIsInRange(zsl,range)) return NULL;

    x = zsl->header;
    for (i = zsl->level-1; i >= 0; i--) {
        // 如果在给定范围内则一直向前查找
        while (x->level[i].forward &&
            zslValueLteMax(x->level[i].forward->score,range))
                x = x->level[i].forward;
    }

    // x即为要找的节点
    serverAssert(x != NULL);

    // 判断该分值是否在给定范围内
    if (!zslValueGteMin(x->score,range)) return NULL;
    return x;
}
// 删除给定分值范围内的所有元素
unsigned long zslDeleteRangeByScore(zskiplist *zsl, zrangespec *range, dict *dict) {
    zskiplistNode *update[ZSKIPLIST_MAXLEVEL], *x;
    unsigned long removed = 0;
    int i;

    x = zsl->header;
    // 找到小于或等于给定范围最小分值的节点
    // 并将每层上的节点保存到update数组
    for (i = zsl->level-1; i >= 0; i--) {
        while (x->level[i].forward && (range->minex ?
            x->level[i].forward->score <= range->min :
            x->level[i].forward->score < range->min))
                x = x->level[i].forward;
        update[i] = x;
    }

    // x的下一个节点则是给定区间内分值最小的节点
    x = x->level[0].forward;

    // 删除该区间下的所有节点
    while (x &&
           (range->maxex ? x->score < range->max : x->score <= range->max))
    {
        // 保存下一个节点
        zskiplistNode *next = x->level[0].forward;
        // 删除该节点
        zslDeleteNode(zsl,x,update);
        // 删除该节点的成员
        dictDelete(dict,x->obj);
        // 释放该节点
        zslFreeNode(x);
        removed++;
        x = next;
    }
    // 返回删除节点的个数
    return removed;
}
// 删除给定排名区间内的所有节点
unsigned long zslDeleteRangeByRank(zskiplist *zsl, unsigned int start, unsigned int end, dict *dict) {
    zskiplistNode *update[ZSKIPLIST_MAXLEVEL], *x;
    unsigned long traversed = 0, removed = 0;
    int i;

    x = zsl->header;
    // 找到给定排名区间内名次最小的节点
    // 并保存每一层下该节点的前一个节点
    for (i = zsl->level-1; i >= 0; i--) {
        while (x->level[i].forward && (traversed + x->level[i].span) < start) {
            traversed += x->level[i].span;
            x = x->level[i].forward;
        }
        update[i] = x;
    }
    // traversed保存当前删除节点的排名值
    traversed++;
    x = x->level[0].forward;
    while (x && traversed <= end) {
        // 记录下一个节点
        zskiplistNode *next = x->level[0].forward;
        // 删除该节点
        zslDeleteNode(zsl,x,update);
        // 删除该节点的成员
        dictDelete(dict,x->obj);
        // 释放该节点
        zslFreeNode(x);
        // 个数+1
        removed++;
        // 排名值加1
        traversed++;
        x = next;
    }
    // 返回删除的节点个数
    return removed;
}