＜肆＞redis源码分析之跳表(skiplist)

跳表(SkipList)，其实也是解决查找问题的一种数据结构，但是它既不属于平衡树结构，也不属于Hash结构，它的特点是元素是有序的。

跳表数据结构

typedef struct zskiplistNode {
    robj *obj; //节点数据
    double score;
    struct zskiplistNode*backward; //前驱
    struct zskiplistLevel {
        struct zskiplistNode*forward;//后继
        unsigned int span;//该层跨越的节点数量
    } level[];
} zskiplistNode;

typedef struct zskiplist {
    struct zskiplistNode*header, *tail;//双向链表
    unsigned long length;//节点的数目
    int level;//目前表的最大层数
} zskiplist;

跳表的操作

插入

zskiplistNode *zslInsert(zskiplist *zsl, double score, robj *obj) {
    zskiplistNode *update[ZSKIPLIST_MAXLEVEL], *x;
    unsigned int rank[ZSKIPLIST_MAXLEVEL];
    int i, level;

    serverAssert(!isnan(score));
	//根据score找到位置,并且将各层的的前置节点保存到rank[]
    x = zsl->header;
    for (i = zsl->level-1; i >= 0; i--) {
		/*  1.如果当前层的下一个节点的分数小于等于插入的分数，则在同层移动
			2.如果当前层的下一个节点的分数大于插入的分数，则降层，不移动
			3.查找插入位置的前一个节点,在此处插入 */
        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 &&
                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. */
	//获取level,生成节点
    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 = (unsigned int) zsl->length;             
        }
        zsl->level = level;
    }
    x = zslCreateNode(level,score,obj);
	//修改指针指向，将创建的节点插入
    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;
    }

    /* increment span for untouched levels */
    for (i = level; i < zsl->level; i++) {
        update[i]->level[i].span++;
    }
	//更新backward
    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;
}

删除

/* Delete an element with matching score/object from the skiplist. */
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;
    }
    /* 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 && equalStringObjects(x->obj,obj)) {
        zslDeleteNode(zsl, x, update);
        zslFreeNode(x);
        return 1;
    }
    return 0; /* not found */
}

查找

zslIsInRange 给定一个分值范围（range）， 比如 0 到 15 ， 20 到 28，诸如此类， 如果给定的分值范围包含在跳跃表的分值范围之内， 那么返回 1 ，否则返回 0 。 通过跳跃表的表头节点和表尾节点， 这个检测可以用 O(1) 复杂度完成.

zslFirstInRange 给定一个分值范围， 返回跳跃表中第一个符合这个范围的节点。 平均 O(log N) ，最坏 O(N) 。 N 为跳跃表长度。

zslLastInRange 给定一个分值范围， 返回跳跃表中最后一个符合这个范围的节点。 平均 O(log N) ，最坏 O(N) 。 N 为跳跃表长度.

zslDeleteRangeByScore 给定一个分值范围， 删除跳跃表中所有在这个范围之内的节点。 O(N) ， N 为被删除节点数量。

zslDeleteRangeByRank 给定一个排位范围， 删除跳跃表中所有在这个范围之内的节点。 O(N) ， N 为被删除节点数量。