Redis源码阅读笔记（六）skiplist跳跃表结构

- 跳跃表简介

在介绍redis的skiplist之前先对跳跃表这一数据结构要有一个了解，跳跃表本质上就是一种查找结构，用于解决算法中的查找问题，即根据给定的key，快速查找到对应的value，它的效率可以比拟平衡二叉树，在插入和删除效率上甚至优于平衡树。但是跳跃表的实现缺要简单很多。以下为跳跃表的一个示例：

从图中可以看出跳跃表主要有以下几个部分构成：

1、 表头head：负责维护跳跃表的节点指针
2、 节点node：实际保存元素值，每个节点有一层或多层（每次插入节点会随机生成一个层数）
3、 层level：保存着指向该层下一个节点的指针
4、 表尾tail：全部由null组成
跳跃表的遍历总是从高层开始，然后随着元素值范围的缩小，慢慢降低到低层。

- skiplist结构简介

Redis中的skiplist正是基于上述跳跃表来实现的，但是在上述基础上为了更加贴合自己需要的功能，进行了一些修改：
1.原本的跳跃表是基于值进行排序的，每次的插入过程是首先找到应该插入的位置然后再进行插入操作，而redis中skiplist是键值对存储，因此可以允许相同的键存在，当发现有相同的键存在时会进一步比较值的大小并进行插入。
2.skiplist保存了一个tail指针指向该跳跃表的最后一个节点，然后每个节点除了最底层的后继指针以外还有一个前驱指针，用于从表尾向表头遍历。

- skiplist数据结构实现 ``` /* ZSETs use a specialized version of Skiplists 跳跃表节点*/ 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;

<h6>- skiplist相关API具体实现

建立一个skiplist节点，需要传入所在的level,score和要保存的值

zskiplistNode *zslCreateNode(int level, double score, robj *obj) {
zskiplistNode *zn = zmalloc(sizeof(zn)+levelsizeof(struct zskiplistLevel));
zn->score = score;
zn->obj = obj;
return zn;
}

创建一个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;
}

新节点生成随机层数

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

在现有zsl中插入一个节点

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

redisAssert(!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 &&
            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 = 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,obj);
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;

}

<h6>- skiplist与平衡树、哈希表的比较

- skiplist和各种平衡树（如AVL、红黑树等）的元素是有序排列的，而哈希表不是有序的。因此，在哈希表上只能做单个key的查找，不适宜做范围查找。所谓范围查找，指的是查找那些大小在指定的两个值之间的所有节点。
- 在做范围查找的时候，平衡树比skiplist操作要复杂。在平衡树上，我们找到指定范围的小值之后，还需要以中序遍历的顺序继续寻找其它不超过大值的节点。如果不对平衡树进行一定的改造，这里的中序遍历并不容易实现。而在skiplist上进行范围查找就非常简单，只需要在找到小值之后，对第1层链表进行若干步的遍历就可以实现。
- 平衡树的插入和删除操作可能引发子树的调整，逻辑复杂，而skiplist的插入和删除只需要修改相邻节点的指针，操作简单又快速。
- 从内存占用上来说，skiplist比平衡树更灵活一些。一般来说，平衡树每个节点包含2个指针（分别指向左右子树），而skiplist每个节点包含的指针数目平均为1/(1-p)，具体取决于参数p的大小。如果像Redis里的实现一样，取p=1/4，那么平均每个节点包含1.33个指针，比平衡树更有优势。
- 查找单个key，skiplist和平衡树的时间复杂度都为O(log n)，大体相当；而哈希表在保持较低的哈希值冲突概率的前提下，查找时间复杂度接近O(1)，性能更高一些。所以我们平常使用的各种Map或dictionary结构，大都是基于哈希表实现的。
从算法实现难度上来比较，skiplist比平衡树要简单得多。