Redis基础（二） 跳跃表

百炼000
262 阅读4分钟

跳跃表

特性：

  1. 有序
  2. 效率高（堪比红黑树）
  3. 实现简单（相对于红黑树、平衡树来说）

实现过程

skiplist.png

  1. 有很多层构成
  2. 有一个头节点（header）,头节点中有一个64层的结构，每一层的结构包含指向本层的下一个节点的指针，指向本层下个节点中间所跨越的节点个数为本层的跨度（span）
  3. 除头节点外，层数最多的节点的层高为跳跃表的高度（level）
  4. 每层都是一个有序链表，数据递增
  5. 除header节点外，一个元素在上层有序链表中出现，则它一定会在下层有序链表中出现。
  6. 跳跃表的每层最后一个节点指向NULL，表示本层有序链表的结束
  7. 跳跃表拥有一个tail指针，指向跳跃表最后一个节点
  8. 最底层的有序链表包含所有节点，最底层的节点个数为跳跃表的长度（length）（不包含头节点）
  9. 每个节点包含一个后退指针，头节点和第一个节点指向NULL;其它节点指向最底层的前一个节点。

实现在 server.h 中

zskiplist.png

跳跃表节点结构

  1. ele: 用于存储字符串类型的数据

  2. score: 用于存储排序的分值

  3. backward: 后退指针

  4. level：柔性数组。每个节点的数组长度不一样，在生成跳跃表时，随机生成1~64的值，值越大出现的概率越低。

    level包含以下两个元素：

    a. forward: 指向本层下一个节点，尾节点的forward为NULL b. span: forward指向的节点与本节点之间的元素个数。span越在，跳过的节点个数越多。

跳跃表是Redis有序集合的底层实现方式之一

  1. 每个节点的ele存储有序集合的成员member值
  2. score存储成员score值，所有节点的分值是按从小到大的方式排序的。当有序集合的成员分值相同时，节点会按member的字典序进行排序。

跳跃表结构

  1. header： 指向跳跃表头节点。头节点是跳跃表的一个特殊节点，它的level数组元素个数为64。头节点在有序集合中不存储任何member和score值，ele值为NULL,score值为0;节不计入跳跃表的总长度。头节点在初始化时，64个元素的forward都指向NULL,span值都为0。
  2. tail： 指向跳跃表尾节点
  3. length: 跳跃表的长度，表示除头节点之外的节点总数。
  4. level： 跳跃表的高度

获取头节点、尾结节、长度、高度的时间复杂度都为O(1)

操作

增、删、改、查

创建、插入、删除、查找

层高

函数随机生成一个1~64的值，作为新建节点的高度，值越大出现的概率越低。层高确定后便不会再修改。跳跃表节点的期望层高为1/(1-0.25) 约为 1.33

#define ZSKIPLIST_MAXLEVEL 64
#define ZSKIPLIST_P 0.25 

/* Returns a random level for the new skiplist node we are going to create.
 * The return value of this function is between 1 and ZSKIPLIST_MAXLEVEL
 * (both inclusive), with a powerlaw-alike distribution where higher
 * levels are less likely to be returned. */
int zslRandomLevel(void) {
    int level = 1;
    while ((random()&0xFFFF) < (ZSKIPLIST_P * 0xFFFF))
        level += 1;
    return (level<ZSKIPLIST_MAXLEVEL) ? level : ZSKIPLIST_MAXLEVEL;
}

创建跳跃表节点

  1. 申请内存：结构体的最后一个元素为柔性数组，申请内存时需要指定柔性数组的大小，一个节点占用的内存大小为zskiplistNode的内存大小与level个zskiplistLevel的内存大小之和
  2. 变量初始化
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;
}

头节点

/* Create a new skiplist. */
zskiplist *zslCreate(void) {
    int j;
    zskiplist *zsl;

    zsl = zmalloc(sizeof(*zsl));
    zsl->level = 1;
    zsl->length = 0;
    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;
}

插入节点

  1. 查找要插入的位置
  2. 调整跳跃表的高度
  3. 插入节点
  4. 调整backward
/* Insert a new node in the skiplist. Assumes the element does not already
 * exist (up to the caller to enforce that). The skiplist takes ownership
 * of the passed SDS string 'ele'. */
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--) {
        /* store rank that is crossed to reach the insert position */
        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;
    }
    /* 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();
    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;
}

删除节点

  1. 查找需要更新的节点
  2. 设置span和forward

删除跳跃表

  1. 获取跳跃表对象
  2. 从第0层开始，通过forward指针逐步向后遍历，每遇到一个节点便释放其内存，当所有节点的内存都被释放之后，释放跟踪表对象。
avatar
文章
阅读
粉丝