Skip List（跳跃表）原理详解与实现

最新推荐文章于 2023-03-16 22:10:33 发布
最新推荐文章于 2023-03-16 22:10:33 发布
阅读量7.3k 收藏 3
点赞数 1
分类专栏： 数据结构和算法学习

本文内容框架：

§1 Skip List 介绍

§2 Skip List 定义以及构造步骤
§3 Skip List 完整实现

§4 Skip List 概率分析

§5 小结

 

 

 

§1 Skip List 介绍

 

Skip List是一种随机化的数据结构，基于并联的链表，其效率可比拟于二叉查找树（对于大多数操作需要O(log n)平均时间）。基本上，跳跃列表是对有序的链表增加上附加的前进链接，增加是以随机化的方式进行的，所以在列表中的查找可以快速的跳过部分列表(因此得名)。所有操作都以对数随机化的时间进行。Skip List可以很好解决有序链表查找特定值的困难。

 

 

§2 Skip List 定义以及构造步骤

 

Skip List定义

像下面这样（初中物理经常这样用，这里我也盗用下）：

一个跳表，应该具有以下特征：

  1. 一个跳表应该有几个层（level）组成；
  2. 跳表的第一层包含所有的元素；
  3. 每一层都是一个有序的链表；
  4. 如果元素x出现在第i层，则所有比i小的层都包含x；
  5. 第i层的元素通过一个down指针指向下一层拥有相同值的元素；
  6. 在每一层中，-1和1两个元素都出现(分别表示INT_MIN和INT_MAX)；
  7. Top指针指向最高层的第一个元素。

构建有序链表

的一个跳跃表如下： 

Skip List构造步骤：

       1、给定一个有序的链表。

2、选择连表中最大和最小的元素，然后从其他元素中按照一定算法（随机）随即选出一些元素，将这些元素组成有序链表。这个新的链表称为一层，原链表称为其下一层。
3、为刚选出的每个元素添加一个指针域，这个指针指向下一层中值同自己相等的元素。Top指针指向该层首元素
4、重复2、3步，直到不再能选择出除最大最小元素以外的元素。

 一、查找

   目的：在跳跃表中查找一个元素x
   在跳跃表中查找一个元素x，按照如下几个步骤进行：
      1. 从最上层的链（Sh）的开头开始
      2. 假设当前位置为p，它向右指向的节点为q（p与q不一定相邻），且q的值为y。将y与x作比较
          (1) x=y  输出查询成功及相关信息
          (2) x>y  从p向右移动到q的位置
          (3) x<y  从p向下移动一格

      3. 如果当前位置在最底层的链中（S0），且还要往下移动的话，则输出查询失败

 

二、插入
     目的：向跳跃表中插入一个元素x
     首先明确，向跳跃表中插入一个元素，相当于在表中插入一列从S0中某一位置出发向上的连续一段元素。有两个参数需要确定，即插入列的位置以及它的“高度”。
     关于插入的位置，我们先利用跳跃表的查找功能，找到比x小的最大的数y。根据跳跃表中所有链均是递增序列的原则，x必然就插在y的后面。
     而插入列的“高度”较前者来说显得更加重要，也更加难以确定。由于它的不确定性，使得不同的决策可能会导致截然不同的算法效率。为了使插入数据之后，保持该数据结构进行各种操作均为O(logn)复杂度的性质，我们引入随机化算法（Randomized Algorithms）。

     我们定义一个随机决策模块，它的大致内容如下：

 产生一个0到1的随机数r     r ← random() 
如果r小于一个常数p，则执行方案A，  if  r<p then do A 
否则，执行方案B         else do B 
     初始时列高为1。插入元素时，不停地执行随机决策模块。如果要求执行的是A操作，则将列的高度加1，并且继续反复执行随机决策模块。直到第i次，模块要求执行的是B操作，我们结束决策，并向跳跃表中插入一个高度为i的列。


     我们来看一个例子：
     假设当前我们要插入元素“40”，且在执行了随机决策模块后得到高度为4
     步骤一：找到表中比40小的最大的数，确定插入位置


步骤二：插入高度为4的列，并维护跳跃表的结构 

三、删除

    目的：从跳跃表中删除一个元素x
    删除操作分为以下三个步骤：

在跳跃表中查找到这个元素的位置，如果未找到，则退出 
将该元素所在整列从表中删除 
将多余的“空链”删除 


§3 Skip List 完整实现

 

下面来定义跳表的数据结构（基于C）

首先是每个节点的数据结构

typedef  struct nodeStructure  
{  
  
    int key;  
  
    int value;  
  
    struct nodeStructure *forward[1];  
}nodeStructure;  

跳表的结构如下
typedef   struct skiplist  
{  
  
     int level;  
  
    nodeStructure *header;  
}skiplist;  

下面是跳表的基本操作
首先是节点的创建
nodeStructure* createNode( int level, int key, int value)  
{  
  
    nodeStructure *ns=(nodeStructure *)malloc( sizeof(nodeStructure)+level* sizeof(nodeStructure*));    
  
    ns->key=key;    
  
    ns->value=value;    
  
     return ns;    
}  
列表的初始化

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

skiplist* createSkiplist()  
{  
  
    skiplist *sl=(skiplist *)malloc( sizeof(skiplist));    
  
    sl->level=0;    
  
    sl->header=createNode(MAX_LEVEL-1,0,0);    
  
     for( int i=0;i<MAX_LEVEL;i++)    
  
    {    
  
        sl->header->forward[i]=NULL;    
  
    }  
  
     return sl;  
}
插入元素

插入元素的时候元素所占有的层数完全是随机的，通过随机算法产生

int randomLevel()    
{  
  
     int k=1;  
  
     while (rand()%2)    
  
        k++;    
  
    k=(k<MAX_LEVEL)?k:MAX_LEVEL;  
  
     return k;    
}  
跳表的插入需要三个步骤，第一步需要查找到在每层待插入位置，然后需要随机产生一个层数，最后就是从高层至下插入，插入时算法和普通链表的插入完全相同。 
bool insert(skiplist *sl, int key, int value)  
{  
  
    nodeStructure *update[MAX_LEVEL];  
  
    nodeStructure *p, *q = NULL;  
  
    p=sl->header;  
  
     int k=sl->level;  
  
     // 从最高层往下查找需要插入的位置  
  
     // 填充update  
  
     for( int i=k-1; i >= 0; i--){  
  
         while((q=p->forward[i])&&(q->key<key))  
  
        {  
  
            p=q;  
  
        }  
  
        update[i]=p;  
  
    }  
  
     // 不能插入相同的key  
  
     if(q&&q->key==key)  
  
    {  
  
         return  false;  
  
    }  
  
    
  
     // 产生一个随机层数K  
  
     // 新建一个待插入节点q  
  
     // 一层一层插入  
  
    k=randomLevel();  
  
     // 更新跳表的level  
  
     if(k>(sl->level))  
  
    {  
  
         for( int i=sl->level; i < k; i++){  
  
            update[i] = sl->header;  
  
        }  
  
        sl->level=k;  
  
    }  
  
    
  
    q=createNode(k,key,value);  
  
     // 逐层更新节点的指针，和普通列表插入一样  
  
     for( int i=0;i<k;i++)  
  
    {  
  
        q->forward[i]=update[i]->forward[i];  
  
        update[i]->forward[i]=q;  
  
    }  
  
     return  true;  
}  
删除节点

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

bool deleteSL(skiplist *sl, int key)  
{  
  
    nodeStructure *update[MAX_LEVEL];  
  
    nodeStructure *p,*q=NULL;  
  
    p=sl->header;  
  
     // 从最高层开始搜  
  
     int k=sl->level;  
  
     for( int i=k-1; i >= 0; i--){  
  
         while((q=p->forward[i])&&(q->key<key))  
  
        {  
  
            p=q;  
  
        }  
  
        update[i]=p;  
  
    }  
  
     if(q&&q->key==key)  
  
    {  
  
         // 逐层删除，和普通列表删除一样  
  
         for( int i=0; i<sl->level; i++){    
  
             if(update[i]->forward[i]==q){    
  
                update[i]->forward[i]=q->forward[i];    
  
            }  
  
        }   
  
        free(q);  
  
         // 如果删除的是最大层的节点，那么需要重新维护跳表的  
  
         for( int i=sl->level-1; i >= 0; i--){    
  
             if(sl->header->forward[i]==NULL){    
  
                sl->level--;    
  
            }    
  
        }    
  
         return  true;  
  
    }  
  
     else  
  
         return  false;  
}  

查找

跳表的优点就是查找比普通链表快，当然查找操作已经包含在在插入和删除过程，实现起来比较简单。


nt search(skiplist *sl, int key)  
{  
  
    nodeStructure *p,*q=NULL;  
  
    p=sl->header;  
  
     // 从最高层开始搜  
  
     int k=sl->level;  
  
     for( int i=k-1; i >= 0; i--){  
  
         while((q=p->forward[i])&&(q->key<=key))  
  
        {  
  
             if(q->key==key)  
  
            {  
  
                 return q->value;  
  
            }  
  
            p=q;  
  
        }  
  
    }  
  
     return NULL;  
}  

完整代码如下： 
#include<stdio.h>  
#include<stdlib.h>  
    
#define MAX_LEVEL 10  // 最大层数  
    
// 节点  
typedef   struct nodeStructure  
{  
     int key;  
     int value;  
     struct nodeStructure *forward[1];  
}nodeStructure;  
    
// 跳表  
typedef   struct skiplist  
{  
     int level;  
    nodeStructure *header;  
}skiplist;  
    
// 创建节点  
nodeStructure* createNode( int level, int key, int value)  
{  
    nodeStructure *ns=(nodeStructure *)malloc( sizeof(nodeStructure)+level* sizeof(nodeStructure*));    
    ns->key=key;    
    ns->value=value;    
     return ns;    
}  
    
// 初始化跳表  
skiplist* createSkiplist()  
{  
    skiplist *sl=(skiplist *)malloc( sizeof(skiplist));    
    sl->level=0;    
    sl->header=createNode(MAX_LEVEL-1,0,0);    
     for( int i=0;i<MAX_LEVEL;i++)    
    {    
        sl->header->forward[i]=NULL;    
    }  
     return sl;  
}  
    
// 随机产生层数  
int randomLevel()    
{  
     int k=1;  
     while (rand()%2)    
        k++;    
    k=(k<MAX_LEVEL)?k:MAX_LEVEL;  
     return k;    
}  
    
// 插入节点  
bool insert(skiplist *sl, int key, int value)  
{  
    nodeStructure *update[MAX_LEVEL];  
    nodeStructure *p, *q = NULL;  
    p=sl->header;  
     int k=sl->level;  
     // 从最高层往下查找需要插入的位置  
     // 填充update  
     for( int i=k-1; i >= 0; i--){  
         while((q=p->forward[i])&&(q->key<key))  
        {  
            p=q;  
        }  
        update[i]=p;  
    }  
     // 不能插入相同的key  
     if(q&&q->key==key)  
    {  
         return  false;  
    }  
    
     // 产生一个随机层数K  
     // 新建一个待插入节点q  
     // 一层一层插入  
    k=randomLevel();  
     // 更新跳表的level  
     if(k>(sl->level))  
    {  
         for( int i=sl->level; i < k; i++){  
            update[i] = sl->header;  
        }  
        sl->level=k;  
    }  
    
    q=createNode(k,key,value);  
     // 逐层更新节点的指针，和普通列表插入一样  
     for( int i=0;i<k;i++)  
    {  
        q->forward[i]=update[i]->forward[i];  
        update[i]->forward[i]=q;  
    }  
     return  true;  
}  
    
// 搜索指定key的value  
int search(skiplist *sl, int key)  
{  
    nodeStructure *p,*q=NULL;  
    p=sl->header;  
     // 从最高层开始搜  
     int k=sl->level;  
     for( int i=k-1; i >= 0; i--){  
         while((q=p->forward[i])&&(q->key<=key))  
        {  
             if(q->key == key)  
            {  
                 return q->value;  
            }  
            p=q;  
        }  
    }  
     return NULL;  
}  
    
// 删除指定的key  
bool deleteSL(skiplist *sl, int key)  
{  
    nodeStructure *update[MAX_LEVEL];  
    nodeStructure *p,*q=NULL;  
    p=sl->header;  
     // 从最高层开始搜  
     int k=sl->level;  
     for( int i=k-1; i >= 0; i--){  
         while((q=p->forward[i])&&(q->key<key))  
        {  
            p=q;  
        }  
        update[i]=p;  
    }  
     if(q&&q->key==key)  
    {  
         // 逐层删除，和普通列表删除一样  
         for( int i=0; i<sl->level; i++){    
             if(update[i]->forward[i]==q){    
                update[i]->forward[i]=q->forward[i];    
            }  
        }   
        free(q);  
         // 如果删除的是最大层的节点，那么需要重新维护跳表的  
         for( int i=sl->level - 1; i >= 0; i--){    
             if(sl->header->forward[i]==NULL){    
                sl->level--;    
            }    
        }    
         return  true;  
    }  
     else  
         return  false;  
}  
    
void printSL(skiplist *sl)  
{  
     // 从最高层开始打印  
    nodeStructure *p,*q=NULL;  
    
     // 从最高层开始搜  
     int k=sl->level;  
     for( int i=k-1; i >= 0; i--)  
    {  
        p=sl->header;  
         while(q=p->forward[i])  
        {  
            printf("%d -> ",p->value);  
            p=q;  
        }  
        printf("\n");  
    }  
    printf("\n");  
}  
int main()  
{  
    skiplist *sl=createSkiplist();  
     for( int i=1;i<=19;i++)  
    {  
        insert(sl,i,i*2);  
    }  
    printSL(sl);  
     // 搜索  
     int i=search(sl,4);  
    printf("i=%d\n",i);  
     // 删除  
     bool b=deleteSL(sl,4);  
     if(b)  
        printf("删除成功\n");  
    printSL(sl);  
    system("pause");  
     return 0;  
}  
§4 Skip List 概率分析 

§5 小结

本篇博文已经详细讲解了Skip List数据结构的所有内容，应该可以有一个深入的了解。如果你有任何建议或者批评和补充，请留言指出，不胜感激，更多参考请移步互联网。

 

参考：

①Skip List: http://www.cs.auckland.ac.nz/software/AlgAnim/niemann/s_skl.htm

②Songeliu: http://www.spongeliu.com/63.html

③Shi Kai Lun ： http://yilee.info/skip-list.html

④Michael T. Goodrich Roberto Tamassia Algorithm Design Foundations, Analysis, and Internet Examples

⑤http://epaperpress.com/sortsearch/skl.html

转自： http://dsqiu.iteye.com/blog/1705530
wintree
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RESNET残差网络跳跃连接
qq_34171593的博客
04-26 3932
RESNET在处理神经网络梯度消失方面表现出了优越的性能，那么这个网络是如何处理梯度消失的？又是怎样进行反向传播的？下面将详细讲解一下： 要想解决这个问题要从最本质的训练流程出发： 正向传播过程：假设一个二分类全连接神经网络结构没有隐藏层，直接全连接然后分类，那么可以得到： ,,其中z1是全连接结果，w是权重，b是偏置，F1是分类结果，g()是非线性分类函数 我们对其进行反向传播不难得到梯度：,其中J是损失函数 有了最基本的正向反向传播概念，通过上图，不难求出RESNET的梯度表达式：...
《数据结构与算法分析》随机化算法--跳跃表详解
yw8355507的专栏
09-30 1177
前言：       随机化算法这一章，先介绍了如何产生随机数，不过这个产生的代码已经完全给出来了，我也没有什么编码的必要了，还有一个是素性测试，利用了费马定理，可惜我看了好多遍都没有完全看懂代码和定理的联系，暂且也不再这里介绍了，今天只说说跳跃表的实现。 我的github： 我实现的代码全部贴在我的github中，欢迎大家去参观。 https://github.com/Yi
SkipList 跳表的原理以及实现
lxw1844912514的博客
08-27 666
一、概念何为跳表呢？我们先维基百科对其定义继续剖析：跳跃列表是一种数据结构。它允许快速查询一个有序连续元素的数据链表,而其快速查询是通过维护一个多层次的链表，且每一层链表中的元素是前一层链...
关于跳跃连接 卷积网络
qq_69030183的博客
05-14 1万+
关于跳跃连接 卷积网络
跳跃表（Skip list）原理
zzhongcy的专栏
08-10 2677
前言 Redis大家可能都很很熟悉了吧，它有五种数据结构如下： String：字符串 Hash：字典 List：列表 Set：集合 Sorted Set：有序集合 这里我们就讲讲Sorted Set，它是一个 set 保证了内部 value 的唯一性，另一方面又可以给每个 value 赋予一个排序的权重值 score，来达到排序的目的。它的内部实现就依赖了一种叫做「跳跃列表」的数据结构。 为什么要有跳跃表 我们在实际开发中经常会有在一堆数据中查找一个指定数据的需求，而常用...
Java实现跳跃表(skiplist)的简单实例
08-29
主要介绍了Java编程中跳跃表的概念和实现原理，并简要叙述了它的结构，具有一定参考价值，需要的朋友可以了解下。
c++实现跳跃表（Skip List）的方法示例
08-29
跳表（skiplist）是一个非常优秀的数据结构，实现简单，插入、删除、查找的复杂度均为O(logN)，下面这篇文章主要介绍了c++实现跳跃表（Skip List）的相关资料，需要的朋友可以参考借鉴，下面随着小编来一起学习学习...
SKIP LIST的实现原理1
08-08
例子：删除 71 ————————————————————转载结束————————————————————— 下面是完整的skipSet的实现，有详细的注释。
跳表SkipList的原理及实现
07-02
跳表是由William Pugh发明。他在 Communications of the ACM June 1990, 33(6) 668-676 发表了Skip lists: a probabilistic alternative to balanced trees，在该论文中详 细解释了跳表的数据结构和插入删除操作。
跳跃表skiplist参考文档
04-10
redis中使用的skiplist数据结构
0046算法笔记——【随机化算法】舍伍德随机化思想解决跳跃表问题
liufeng_king的专栏
06-24 4598
问题描述      如果用有序链表来表示一个含有n个元素的有序集S，则在最坏情况下，搜索S中一个元素需要O(n)计算时间。提高有序链表效率的一个技巧是在有序链表的部分结点处增设附加指针以提高其搜索性能。在增设附加指针的有序链表中搜索一个元素时，可借助于附加指针跳过链表中若干结点，加快搜索速度。这种增加了向前附加指针的有序链表称为跳跃表。      应在跳跃表的哪些结点增加附加指针以及在该结点处
跳表（Skip List）
热门推荐
https://github.com/hakusai22
04-30 2万+
跳表SkipList一. 跳表的定义 一. 跳表的定义 跳表(SkipList)：增加了向前指针的链表叫做指针。跳表全称叫做跳跃表，简称跳表。跳表是一个随机化的数据结构，实质是一种可以进行二分查找的有序链表。跳表在原有的有序链表上增加了多级索引，通过索引来实现快速查询。跳表不仅能提高搜索性能，同时也可以提高插入和删除操作的性能。 跳表是一个随机化的数据结构，可以被看做二叉树的一个变种，它在性能上和红黑树、AVL树不相上下，但是跳表的原理非常简单，目前在Redis和LevelDB中都有用到。 ...
pytorch学习笔记八
StrangeStranger的博客
08-17 575
pytorch学习笔记八————使用卷积进行泛化(略精细一点的图像识别)
Skip List（跳跃表）原理详解
qiki_糖没味儿的程序媛小屋
07-14 1368
为什么选择跳跃表目前经常使用的平衡数据结构有：B树，红黑树，AVL树，Splay Tree, Treep等。想象一下，给你一张草稿纸，一只笔，一个编辑器，你能立即实现一颗红黑树，或者AVL树出来吗？ 很难吧，这需要时间，要考虑很多细节，要参考一堆算法与数据结构之类的树，还要参考网上的代码，相当麻烦。用跳表吧，跳表是一种随机化的数据结构，目前开源软件 Redis 和 LevelDB 都有用到它，它的...
跳表 skiplist 简介
最新发布
苏木川的博客
03-16 840
跳表是一个包含随机算法的数据结构，跳表的查找、插入、删除的平均时间复杂度都是 O(logn)，而且可以按照范围区间查找元素，空间复杂度是 O(n)。
Redis-跳跃表（skip List）
养歌的博客
12-13 5926
什么是跳跃表（skip list） 跳表全称叫做跳跃表，简称跳表。跳表是一个随机化的数据结构， 跳跃表（skiplist）是一个用于有序元素序列快速搜索的随机化的数据结构，由美国计算机科学家William Pugh发明于1989年，论文《Skip lists: a probabilistic alternative to balanced trees》中提出。 它的效率和红黑树以及 AVL 树不相上下，但实现起来比较容易。是一种可以于平衡树媲美的层次化链表结构——查找、删除、添加等操作都可以在对数期望时间下
SkipList(跳跃表)详解
程序员の墨梅
04-27 1万+
Introduction: skiplist本质上也是一种查找结构，用于解决算法中的查找问题（Searching），即根据给定的key，快速查到它所在的位置（或者对应的value） 一般用于解决查找问题的数据结构分为两个大类：一个是基于各种平衡树，一个是基于哈希表。但skiplist却比较特殊，它没法归属到这两大类里面 这种数据结构是由William Pugh发明的，最早出现于他在1990年发表的...
请使用go预言实现一个skipList
02-12
在 Go 语言中实现一个 SkipList 的话，需要遵循以下步骤： 1. 定义一个结构体，表示一个节点，该结构体包含一个键和值以及一个指向前后相邻节点的指针列表。 2. 定义一个结构体，表示一个 SkipList，该结构体包含...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值