码迷，mamicode.com
首页 > 其他好文 > 详细

skip跳跃表的实现

时间：2014-06-07 07:18:01      阅读：239      评论：0      收藏：0      [点我收藏+]

标签：c   class   blog   a   http   tar   

skiplist介绍

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

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

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

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

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

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

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

结构也是有跳表实现的。

 

skiplist主要思想

 

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

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

                                             bubuko.com,布布扣

 

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

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

节点取出来作为其节点下某种意义的索引，比如父节点一般大于左子节点而小于右子节点。因此这个时候我们想到类似二叉搜索树的做法把一些

节点提取出来，作为索引。得到如下结构：

                                      bubuko.com,布布扣

 

在这个结构里我们把{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和一个指向同一层链表的下个节点的指针数组

如图所示。

                     bubuko.com,布布扣

 

跳表基本数据结构

定义跳表数据类型：

[cpp] view plaincopy
 
  1. //跳表结构  
  2. typedef struct skip_list  
  3. {  
  4.     int level;// 层数  
  5.     Node *head;//指向头结点  
  6. } skip_list;  

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

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

[cpp] view plaincopy
 
  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 plaincopy
 
  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 plaincopy
 
  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.   
  8.     sl->level=0;// 设置跳表的层level，初始的层为0层（数组从0开始）  
  9.   
  10.     Node *h=create_node(MAX_L-1, 0, 0);//创建头结点  
  11.     if(h==NULL)  
  12.     {  
  13.         free(sl);  
  14.         return NULL;  
  15.     }  
  16.     sl->head = h;  
  17.     int i;  
  18.      // 将header的next数组清空  
  19.     for(i=0; i<MAX_L; ++i)  
  20.     {  
  21.         h->next[i] = NULL;  
  22.     }  
  23.     srand(time(0));  
  24.     return sl;  
  25. }  

跳表插入操作

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

[cpp] view plaincopy
 
  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，想想为什么这么做,呵呵。然后就是更

新跳表的最大层数。

                  bubuko.com,布布扣

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

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

                 bubuko.com,布布扣

 

  实现代码如下:

[cpp] view plaincopy
 
  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.     //逐层更新节点的指针,和普通链表插入一样  
  41.     for(i=level-1; i>=0; --i)  
  42.     {  
  43.         q->next[i]=update[i]->next[i];  
  44.         update[i]->next[i]=q;  
  45.     }  
  46.     return true;  
  47. }  

跳表删除节点操作

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

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

[cpp] view plaincopy
 
  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.     //逐层删除与普通链表删除一样  
  19.     for(i=sl->level-1; i>=0; --i)  
  20.     {  
  21.         if(update[i]->next[i]==q)//删除节点  
  22.         {  
  23.             update[i]->next[i]=q->next[i];  
  24.             //如果删除的是最高层的节点,则level--  
  25.             if(sl->head->next[i]==NULL)  
  26.                 sl->level--;  
  27.         }  
  28.     }  
  29.     free(q);  
  30.     q=NULL;  
  31.     return true;  
  32. }  

跳表的查找操作

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

[cpp] view plaincopy
 
  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 plaincopy
 
  1. // 释放跳跃表  
  2. void sl_free(skip_list *sl)  
  3. {  
  4.     if(!sl)  
  5.         return;  
  6.       
  7.     Node *q=sl->head;  
  8.     Node *next;  
  9.     while(q)  
  10.     {  
  11.         next=q->next[0];  
  12.         free(q);  
  13.         q=next;  
  14.     }  
  15.     free(sl);  
  16. }  

 

skiplist复杂度分析

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

 

       bubuko.com,布布扣

bubuko.com,布布扣

 

 

参考:

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

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

skip跳跃表的实现,布布扣,bubuko.com

skip跳跃表的实现

标签：c   class   blog   a   http   tar   

原文地址：http://www.cnblogs.com/lippi/p/3770550.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！