skiplist 跳跃表详解及其编程实现

时间 2021-08-12 标签 html 前端 node git github redis 算法数组数据结构 dom

skiplist介绍

跳表(skip List)是一种随机化的数据结构，基于并联的链表，实现简单，插入、删除、查找的复杂度均为O(logN)。跳表的具体定义，html

请参考参考维基百科点我，中文版。跳表是由William Pugh发明的，这位确实是个大牛，搞出一些很不错的东西。简单说来跳表也是前端

链表的一种，只不过它在链表的基础上增长了跳跃功能，正是这个跳跃的功能，使得在查找元素时，跳表可以提供O(log n)的时间复杂node

度。红黑树等这样的平衡数据结构查找的时间复杂度也是O(log n)，而且相对于红黑树这样的平衡二叉树skiplist的优势是更好的支持并git

发操做，可是要实现像红黑树这样的数据结构并不是易事,可是只要你熟悉链表的基本操做,再加之对跳表原理的理解，实现一个跳表数据github

结构就是一个很天然的事情了。
redis

此外，跳表在当前热门的开源项目中也有不少应用，好比LevelDB的核心数据结构memtable是用跳表实现的，redis的sorted set数据算法

结构也是有跳表实现的。数组

skiplist主要思想

先从链表开始，若是是一个简单的链表（不必定有序），那么咱们在链表中查找一个元素X的话，须要将遍历整个链表直到找到元素X为止。数据结构

如今咱们考虑一个有序的链表：dom

从该有序表中搜索元素 {13, 39} ，须要比较的次数分别为 {3, 5}，总共比较的次数为 3 + 5 = 8 次。咱们想下有没有更优的算法? 咱们想到了对于

有序数组查找问题咱们可使用二分查找算法，但对于有序链表却不能使用二分查找。这个时候咱们在想下平衡树,好比BST,他们都是经过把一些

节点取出来做为其节点下某种意义的索引，好比父节点通常大于左子节点而小于右子节点。所以这个时候咱们想到相似二叉搜索树的作法把一些

节点提取出来，做为索引。获得以下结构：

在这个结构里咱们把{3, 18, 77}提取出来做为一级索引，这样搜索的时候就能够减小比较次数了,好比在搜索39时仅比较了3次(经过比较3,18,39)。

固然咱们还能够再从一级索引提取一些元素出来，做为二级索引,这样更能加快元素搜索。

这基本上就是跳表的核心思想，实际上是一种经过“空间来换取时间”的一个算法，经过在每一个节点中增长了向前的指针(即层)，从而提高查找的效率。

跳跃列表是按层建造的。底层是一个普通的有序链表。每一个更高层都充当下面列表的「快速跑道」，这里在层 i 中的元素按某个固定的几率 p (一般

为0.5或0.25)出如今层 i+1 中。平均起来，每一个元素都在 1/(1-p) 个列表中出现, 而最高层的元素（一般是在跳跃列表前端的一个特殊的头元素）

在 O(log1/p n) 个列表中出现。

SkipList基本数据结构及其实现

一个跳表，应该具备如下特征：

1,一个跳表应该有几个层（level）组成；

2,跳表的第一层包含全部的元素；

3,每一层都是一个有序的链表；

4,若是元素x出如今第i层，则全部比i小的层都包含x；

5,每一个节点包含key及其对应的value和一个指向同一层链表的下个节点的指针数组

如图所示。

跳表基本数据结构

定义跳表数据类型：

[cpp] view plain copy

//跳表结构
typedef struct skip_list
{
int level;// 层数
Node *head;//指向头结点
} skip_list;

其中level是当前跳表最大层数,head是指向跳表的头节点如上图。

跳表的每一个节点的数据结构：

[cpp] view plain copy

typedef struct node
{
keyType key;// key值
valueType value;// value值
struct node *next[1];// 后继指针数组，柔性数组可实现结构体的变长
} Node;

对于这个结构体重点说说，struct node *next[1] 其实它是个柔性数组，主要用于使结构体包含可变长字段。咱们能够经过以下方法获得包含可变

层数(n)的Node *类型的内存空间:

#define new_node(n)((Node*)malloc(sizeof(Node)+n*sizeof(Node*)))

经过上面咱们能够根据层数n来申请指定大小的内存，从而节省了没必要要的内存空间(好比固定大小的next数组就会浪费大量的内存空间)。

跳表节点的建立

[cpp] view plain copy

// 建立节点
Node *create_node(int level, keyType key, valueType val)
{
Node *p=new_node(level);
if(!p)
return NULL;
p->key=key;
p->value=val;
return p;
}

跳表的建立

列表的初始化须要初始化头部，并使头部每层（根据事先定义的MAX_LEVEL）指向末尾（NULL）

[cpp] view plain copy

//建立跳跃表
skip_list *create_sl()
{
skip_list *sl=(skip_list*)malloc(sizeof(skip_list));//申请跳表结构内存
if(NULL==sl)
return NULL;
sl->level=0;// 设置跳表的层level，初始的层为0层（数组从0开始）
Node *h=create_node(MAX_L-1, 0, 0);//建立头结点
if(h==NULL)
{
free(sl);
return NULL;
}
sl->head = h;
int i;
// 将header的next数组清空
for(i=0; i<MAX_L; ++i)
{
h->next[i] = NULL;
}
srand(time(0));
return sl;
}

跳表插入操做

咱们知道跳表是一种随机化数据结构，其随机化体如今插入元素的时候元素所占有的层数彻底是随机的，层数是经过随机算法产生的:

[cpp] view plain copy

//插入元素的时候元素所占有的层数彻底是随机算法
int randomLevel()
{
int level=1;
while (rand()%2)
level++;
level=(MAX_L>level)? level:MAX_L;
return level;
}

至关与作一次丢硬币的实验，若是遇到正面(rand产生奇数)，继续丢，遇到反面，则中止，用实验中丢硬币的次数level做为元素占有的层数。

显然随机变量 level 知足参数为 p = 1/2 的几何分布，level 的指望值 E[level] = 1/p = 2. 就是说，各个元素的层数，指望值是 2 层。

因为跳表数据结构总体上是有序的，因此在插入时，须要首先查找到合适的位置，而后就是修改指针（和链表中操做相似），而后更新跳表的

level变量。跳表的插入总结起来须要三步:

1:查找到待插入位置, 每层跟新update数组;

2:须要随机产生一个层数;

3:从高层至下插入,与普通链表的插入彻底相同;

好比插入key为25的节点，以下图。

对于步骤1,咱们须要对于每一层进行遍历并保存这一层中降低的节点(其后继节点为NULL或者后继节点的key大于等于要插入的key)，以下图,

节点中有白色星花标识的节点保存到update数组。

对于步骤2咱们上面已经说明了是经过一个随机算法产生一个随机的层数，可是当这个随机产生的层数level大于当前跳表的最大层数时，咱们

此时须要更新当前跳表最大层数到level之间的update内容，这时应该更新其内容为跳表的头节点head，想一想为何这么作,呵呵。而后就是更

新跳表的最大层数。

对于步骤3就和普通链表插入同样了，只不过如今是对每一层链表进行插入节点操做。最终的插入结果如图所示，由于新插入key为25的节点level随机

为4大于插入前的最大层数，因此此时跳表的层数为4。

实现代码以下:

[cpp] view plain copy

bool insert(skip_list *sl, keyType key, valueType val)
{
Node *update[MAX_L];
Node *q=NULL,*p=sl->head;//q,p初始化
int i=sl->level-1;
/******************step1*******************/
//从最高层往下查找须要插入的位置,并更新update
//即把降层节点指针保存到update数组
for( ; i>=0; --i)
{
while((q=p->next[i])&& q->key<key)
p=q;
update[i]=p;
}
if(q && q->key == key)//key已经存在的状况下
{
q->value = val;
return true;
}
/******************step2*******************/
//产生一个随机层数level
int level = randomLevel();
//若是新生成的层数比跳表的层数大
if(level>sl->level)
{
//在update数组中将新添加的层指向header
for(i=sl->level; i<level; ++i)
{
update[i]=sl->head;
}
sl->level=level;
}
//printf("%d\n", sizeof(Node)+level*sizeof(Node*));
/******************step3*******************/
//新建一个待插入节点,一层一层插入
q=create_node(level, key, val);
if(!q)
return false;
//逐层更新节点的指针,和普通链表插入同样
for(i=level-1; i>=0; --i)
{
q->next[i]=update[i]->next[i];
update[i]->next[i]=q;
}
return true;
}

跳表删除节点操做

删除节点操做和插入差很少，找到每层须要删除的位置，删除时和操做普通链表彻底同样。不过须要注意的是，若是该节点的level是最大的，

则须要更新跳表的level。实现代码以下:

[cpp] view plain copy

bool erase(skip_list *sl, keyType key)
{
Node *update[MAX_L];
Node *q=NULL, *p=sl->head;
int i = sl->level-1;
for(; i>=0; --i)
{
while((q=p->next[i]) && q->key < key)
{
p=q;
}
update[i]=p;
}
//判断是否为待删除的key
if(!q || (q&&q->key != key))
return false;
//逐层删除与普通链表删除同样
for(i=sl->level-1; i>=0; --i)
{
if(update[i]->next[i]==q)//删除节点
{
update[i]->next[i]=q->next[i];
//若是删除的是最高层的节点,则level--
if(sl->head->next[i]==NULL)
sl->level--;
}
}
free(q);
q=NULL;
return true;
}

跳表的查找操做

跳表的优势就是查找比普通链表快，其实查找操已经在插入、删除操做中有所体现，代码以下：

[cpp] view plain copy

valueType *search(skip_list *sl, keyType key)
{
Node *q,*p=sl->head;
q=NULL;
int i=sl->level-1;
for(; i>=0; --i)
{
while((q=p->next[i]) && q->key<key)
{
p=q;
}
if(q && key==q->key)
return &(q->value);
}
return NULL;
}

跳表的销毁

上面分别介绍了跳表的建立、节点插入、节点删除，其中涉及了内存的动态分配，在使用完跳表后别忘了释放所申请的内存，否则会内存泄露的。

很少说了，代码以下:

[cpp] view plain copy

// 释放跳跃表
void sl_free(skip_list *sl)
{
if(!sl)
return;
Node *q=sl->head;
Node *next;
while(q)
{
next=q->next[0];
free(q);
q=next;
}
free(sl);
}

关于skiplist实现部分就到这里，完整代码及其测试请移步: https://github.com/ustcdane/skiplist/ 。

skiplist复杂度分析

skiplist分析以下图(摘自这里 )

完整代码及其测试: https://github.com/ustcdane/skiplist/ , 接下来能够尝试着分析Redis 源代码中skiplist相关的数据结构了。

参考:

https://www.cs.auckland.ac.nz/software/AlgAnim/niemann/s_skl.htm

http://www.cnblogs.com/xuqiang/archive/2011/05/22/2053516.html

本文转载自：http://blog.csdn.net/daniel_ustc/article/details/20218489?utm_source=tuicool