skip跳跃表的实现

skiplist介绍

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

跳表是由William Pugh发明的,这位确实是个大牛,搞出一些很不错的东西。简单说来跳表也是

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

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

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

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

此外,跳表在当前热门的开源项目中也有很多应用,比如LevelDB的核心数据结构memtable是用跳表实现的,redis的sorted set数据

结构也是有跳表实现的。

skiplist主要思想

先从链表开始,如果是一个简单的链表(不一定有序),那么我们在链表中查找一个元素X的话,需要将遍历整个链表直到找到元素X为止。

现在我们考虑一个有序的链表:

从该有序表中搜索元素 {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

  1. //跳表结构

  2. typedef struct skip_list

  3. {

  4. int level;// 层数

  5. Node *head;//指向头结点

  6. } skip_list;

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

跳表的每个节点的数据结构:

[cpp] view
plain
copy

  1. typedef struct node

  2. {

  3. keyType key;// key值

  4. valueType value;// value值

  5. struct node *next[1];// 后继指针数组,柔性数组 可实现结构体的变长

  6. } Node;

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

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

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

通过上面我们可以根据层数n来申请指定大小的内存,从而节省了不必要的内存空间(比如固定大小的next数组就会浪费大量的内存空间)。

跳表节点的创建

[cpp] view
plain
copy

  1. // 创建节点

  2. Node *create_node(int level, keyType key, valueType val)

  3. {

  4. Node *p=new_node(level);

  5. if(!p)

  6. return NULL;

  7. p->key=key;

  8. p->value=val;

  9. return p;

  10. }

跳表的创建

列表的初始化需要初始化头部,并使头部每层(根据事先定义的MAX_LEVEL)指向末尾(NULL)

[cpp] view
plain
copy

  1. //创建跳跃表

  2. skip_list *create_sl()

  3. {

  4. skip_list *sl=(skip_list*)malloc(sizeof(skip_list));//申请跳表结构内存

  5. if(NULL==sl)

  6. return NULL;
  7. sl->level=0;// 设置跳表的层level,初始的层为0层(数组从0开始)
  8. Node *h=create_node(MAX_L-1, 0, 0);//创建头结点

  9. if(h==NULL)

  10. {

  11. free(sl);

  12. return NULL;

  13. }

  14. sl->head = h;

  15. int i;

  16. // 将header的next数组清空

  17. for(i=0; i<MAX_L; ++i)

  18. {

  19. h->next[i] = NULL;

  20. }

  21. srand(time(0));

  22. return sl;

  23. }

跳表插入操作

我们知道跳表是一种随机化数据结构,其随机化体现在插入元素的时候元素所占有的层数完全是随机的,层数是通过随机算法产生的:

[cpp] view
plain
copy

  1. //插入元素的时候元素所占有的层数完全是随机算法

  2. int randomLevel()

  3. {

  4. int level=1;

  5. while (rand()%2)

  6. level++;

  7. level=(MAX_L>level)? level:MAX_L;

  8. return level;

  9. }

相当与做一次丢硬币的实验,如果遇到正面(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

  1. bool insert(skip_list *sl, keyType key, valueType val)

  2. {

  3. Node *update[MAX_L];

  4. Node *q=NULL,*p=sl->head;//q,p初始化

  5. int i=sl->level-1;

  6. /******************step1*******************/

  7. //从最高层往下查找需要插入的位置,并更新update

  8. //即把降层节点指针保存到update数组

  9. for( ; i>=0; --i)

  10. {

  11. while((q=p->next[i])&& q->key<key)

  12. p=q;

  13. update[i]=p;

  14. }

  15. if(q && q->key == key)//key已经存在的情况下

  16. {

  17. q->value = val;

  18. return true;

  19. }

  20. /******************step2*******************/

  21. //产生一个随机层数level

  22. int level = randomLevel();

  23. //如果新生成的层数比跳表的层数大

  24. if(level>sl->level)

  25. {

  26. //在update数组中将新添加的层指向header

  27. for(i=sl->level; i<level; ++i)

  28. {

  29. update[i]=sl->head;

  30. }

  31. sl->level=level;

  32. }

  33. //printf("%d\n", sizeof(Node)+level*sizeof(Node*));

  34. /******************step3*******************/

  35. //新建一个待插入节点,一层一层插入

  36. q=create_node(level, key, val);

  37. if(!q)

  38. return false;
  39. //逐层更新节点的指针,和普通链表插入一样

  40. for(i=level-1; i>=0; --i)

  41. {

  42. q->next[i]=update[i]->next[i];

  43. update[i]->next[i]=q;

  44. }

  45. return true;

  46. }

跳表删除节点操作

删除节点操作和插入差不多,找到每层需要删除的位置,删除时和操作普通链表完全一样。不过需要注意的是,如果该节点的level是最大的,

则需要更新跳表的level。实现代码如下:

[cpp] view
plain
copy

  1. bool erase(skip_list *sl, keyType key)

  2. {

  3. Node *update[MAX_L];

  4. Node *q=NULL, *p=sl->head;

  5. int i = sl->level-1;

  6. for(; i>=0; --i)

  7. {

  8. while((q=p->next[i]) && q->key < key)

  9. {

  10. p=q;

  11. }

  12. update[i]=p;

  13. }

  14. //判断是否为待删除的key

  15. if(!q || (q&&q->key != key))

  16. return false;
  17. //逐层删除与普通链表删除一样

  18. for(i=sl->level-1; i>=0; --i)

  19. {

  20. if(update[i]->next[i]==q)//删除节点

  21. {

  22. update[i]->next[i]=q->next[i];

  23. //如果删除的是最高层的节点,则level--

  24. if(sl->head->next[i]==NULL)

  25. sl->level--;

  26. }

  27. }

  28. free(q);

  29. q=NULL;

  30. return true;

  31. }

跳表的查找操作

跳表的优点就是查找比普通链表快,其实查找操已经在插入、删除操作中有所体现,代码如下:

[cpp] view
plain
copy

  1. valueType *search(skip_list *sl, keyType key)

  2. {

  3. Node *q,*p=sl->head;

  4. q=NULL;

  5. int i=sl->level-1;

  6. for(; i>=0; --i)

  7. {

  8. while((q=p->next[i]) && q->key<key)

  9. {

  10. p=q;

  11. }

  12. if(q && key==q->key)

  13. return &(q->value);

  14. }

  15. return NULL;

  16. }

跳表的销毁

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

不多说了,代码如下:

[cpp] view
plain
copy

  1. // 释放跳跃表

  2. void sl_free(skip_list *sl)

  3. {

  4. if(!sl)

  5. return;
  6. Node *q=sl->head;

  7. Node *next;

  8. while(q)

  9. {

  10. next=q->next[0];

  11. free(q);

  12. q=next;

  13. }

  14. free(sl);

  15. }

skiplist复杂度分析

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

参考:

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

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

时间: 2024-10-10 01:44:22

skip跳跃表的实现的相关文章

跳跃表Skip List【附java实现】

skip list的原理 Java中的LinkedList是一种常见的链表结构,这种结构支持O(1)的随机插入及随机删除, 但它的查找复杂度比较糟糕,为O(n). 假如我们有一个有序链表如下,如果我们想找到值为59的节点,需要查找7次.怎么提高查询效率呢?通常的做法是使用二分法,但LinkedList的随机访问时间复杂度同样为O(n),因此朴素的二分法并不适用.那怎么办呢? 我们可以在节点中增加额外的跳跃节点,如下: 这样我们可以根据跳跃节点查询,只需要查找3次.至于查询47,我们先根据跳跃节点

skip list跳跃表实现

跳表(skip List)是一种随机化的数据结构,基于并联的链表,实现简单,插入.删除.查找的复杂度均为O(logN).跳表的具体定义,跳表是由William Pugh发明的,这位确实是个大牛,搞出一些很不错的东西.简单说来跳表也是 链表的一种,只不过它在链表的基础上增加了跳跃功能,正是这个跳跃的功能,使得在查找元素时,跳表能够提供O(log n)的时间复杂 度.红黑树等这样的平衡数据结构查找的时间复杂度也是O(log n),并且相对于红黑树这样的平衡二叉树skiplist的优点是更好的支持并

跳跃表,字典树(单词查找树,Trie树),后缀树,KMP算法,AC 自动机相关算法原理详细汇总

第一部分:跳跃表 本文将总结一种数据结构:跳跃表.前半部分跳跃表性质和操作的介绍直接摘自<让算法的效率跳起来--浅谈"跳跃表"的相关操作及其应用>上海市华东师范大学第二附属中学 魏冉.之后将附上跳跃表的源代码,以及本人对其的了解.难免有错误之处,希望指正,共同进步.谢谢. 跳跃表(Skip List)是1987年才诞生的一种崭新的数据结构,它在进行查找.插入.删除等操作时的期望时间复杂度均为O(logn),有着近乎替代平衡树的本领.而且最重要的一点,就是它的编程复杂度较同类

浅析SkipList跳跃表原理及代码实现

本文将总结一种数据结构:跳跃表.前半部分跳跃表性质和操作的介绍直接摘自<让算法的效率跳起来--浅谈“跳跃表”的相关操作及其应用>上海市华东师范大学第二附属中学 魏冉.之后将附上跳跃表的源代码,以及本人对其的了解.难免有错误之处,希望指正,共同进步.谢谢. 跳跃表(Skip List)是1987年才诞生的一种崭新的数据结构,它在进行查找.插入.删除等操作时的期望时间复杂度均为O(logn),有着近乎替代平衡树的本领.而且最重要的一点,就是它的编程复杂度较同类的AVL树,红黑树等要低得多,这使得其

跳跃表SkipList

SkipList在各种开源引擎中用处普遍,例如redis的sortedset容器.luence里面的索引字典等均用到了skiplist. 1.SkipList     在数据结构里面,我们知道有两种基本数据存储结构:数组和链表.它们均有其各自的特点,数组(特别是有序数组),可以进行快速查询,但不便于删除操作;链表,可以进行快速的增删操作,但是又不便于查询.那有没可能存在一种数据结构,结合两者各自的优点呢?     基于这样的思路,William Pugh这位马里兰大学的计算机教授,于1989年提

查找——图文翔解SkipList(跳跃表)

跳跃表 跳跃列表(也称跳表)是一种随机化数据结构,基于并联的链表,其效率可比拟于二叉查找树(对于大多数操作需要O(logn)平均时间). 基本上,跳跃列表是对有序的链表增加上附加的前进链接,增加是以随机化的方式进行的,所以在列表中的查找可以快速的跳过部分列表元素,因此得名.所有操作都以对数随机化的时间进行. 如下图所示,是一个即为简单的跳跃表.传统意义的单链表是一个线性结构,向有序的链表中插入一个节点需要O(n)的时间,查找操作需要O(n)的时间.如果我们使用图中所示的跳跃表,就可以大大减少减少

跳跃表 C#

           虽然avl树和红黑树在数据搜索和排序方面都是有效的数据结构,但是都显得特别麻烦,跳跃表就显得特别简单,虽然简单 不影响他性能,在平均情况下,其插入.删除.查找数据时间复杂度都是O(log(N)),其最坏情况下都为O(N).                                                                                                                                

跳跃表skiplist简析

1.简述 跳跃表(skiplist)最初由William Pugh发表在ACM通讯上的论文<Skip lists: a probabilistic alternative to balanced trees >中,作者给出的定义是:跳表是在很多应用中有可能替代平衡树而作为实现方法的一种数据结构.跳跃列表的算法有同平衡树一样的渐进的预期时间边界,并且更简单.更快速和使用更少的空间.其实,跳表,顾名思义,跳跃的链表,跳表在链表的基础上增加了前向指针,对于链表而言,顺序查找的时间复杂度为线性时间,为

【转】浅析SkipList跳跃表原理及代码实现

SkipList在Leveldb以及lucence中都广为使用,是比较高效的数据结构.由于它的代码以及原理实现的简单性,更为人们所接受.首先看看SkipList的定义,为什么叫跳跃表? "Skip lists  are data structures  that use probabilistic  balancing rather  than  strictly  enforced balancing. As a result, the algorithms  for insertion  a