`

Skip List(跳跃表)原理详解与实现

 
阅读更多

Skip List(跳跃表)原理详解与实现

 

本文内容框架:

§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指针指向最高层的第一个元素。

构建有序链表

link list

的一个跳跃表如下:


Skip List构造步骤:

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

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

 

 

§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;  
}
 

 

跳表的插入需要三个步骤,第一步需要查找到在每层待插入位置,然后需要随机产生一个层数,最后就是从高层至下插入,插入时算法和普通链表的插入完全相同。

跳表,Skip List

 

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;
}
 

 

 红色区域为辅助数组update的内容

删除节点

删除节点操作和插入差不多,找到每层需要删除的位置,删除时和操作普通链表完全一样。不过需要注意的是,如果该节点的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;
}
 

 

查找

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

跳表,Skip List

 搜索key=14的示意图

 

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;
}
 

 

完整代码如下:

 

#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

 

 

 

 

 

 

 

  • 大小: 93 KB
  • 大小: 32.1 KB
  • 大小: 152.4 KB
1
0
分享到:
评论
2 楼 renread 2015-09-14  
这个柔性数组有问题吧。应该用struct nodeStructure *forward[0];  或者struct nodeStructure *forward[];
1 楼 bigfish290 2014-03-26  
楼主,我看晕了。
每个节点应该有一个next,一个down指针,在您这里怎么只有一个forward指针呢。

你的这个forward到底是next还是down
另外在insert函数中,视乎没有很好地使用到跳跃表的查找优势,就是根据上层检查可以跳过下层的检索。

相关推荐

    跳跃表skiplist参考文档

    跳跃表(Skiplist)是一种在Redis中广泛使用的数据结构,它作为一种概率性的平衡树替代方案,通过概率性平衡而非严格平衡,实现了更简单、更快的插入和删除算法。本篇将深入探讨跳跃表的基本概念、工作原理以及其在...

    VB.net编写的SkipList 跳跃链表

    跳表(Skiplist)是一种高效的数据结构,它在实现上类似于多层索引的跳跃式访问,由Marc P. Lehmann在1990年提出。VB.NET是一种基于.NET Framework的面向对象的编程语言,它提供了丰富的库和工具,使得开发者能够...

    A skip list cookbook.

    ### Skip List 数据结构详解 #### 一、引言与背景 Skip list 是一种概率性数据结构,它在很多场景下可以替代平衡树作为首选的实现方法。与平衡树相比,Skip list 具有更简单的实现、更快的速度以及更低的空间消耗...

    skiplist跳表C++实现

    下面我们将深入探讨跳表的基本原理、C++实现的关键点以及测试程序的设计。 跳表的核心思想是通过多层索引来加速查找过程。每一层索引称为一个“级别”,最底层被称为0级,而上一层则是下一层的两倍概率存在。最高...

    SkipList.pptx

    跳跃表(Skiplist)技术分享 跳跃表(Skiplist)是一种高效的数据结构,能够快速查询一个有序连续元素的数据链表。它的平均查找和插入时间复杂度都是 O(log n) ,优于普通队列的 O(n) 。下面是跳跃表的详细知识点:...

    C# 简单的跳跃表实现

    下面将详细介绍跳跃表的工作原理以及如何在C#中实现它。 跳跃表的核心思想是通过随机概率增加节点的层级,使得查找效率近似于对数时间复杂度。每层节点都包含一部分下层节点,这样在查找时,可以跳过部分节点,从而...

    skipList.rar

    本压缩包"skipList.rar"包含了一个用C++实现的跳跃表,该实现参考了Redis中的zskiplist。下面将详细介绍跳跃表的概念、工作原理以及C++实现的关键点。 跳跃表是一种随机化的数据结构,由多个层(level)组成,每层...

    Java实现跳跃表(skiplist)的简单实例

    "Java实现跳跃表(skiplist)的简单实例" 跳跃表(Skiplist)是一种随机化数据结构,基于并联的链表,其效率可比拟于二叉查找树(对于大多数操作需要O(log n)平均时间),并且对并发算法友好。跳跃表的结构是:假如...

    SkipList_Java.rar_SkipList in Java_skiplist_skiplist java

    2. SkipList.java: 这是跳表的主要实现文件,可能包含了一个名为`SkipList`的类,实现了跳表的数据结构和相关的操作方法,如插入、删除、查找等。这个类可能包括了节点结构的设计,以及如何随机决定每个节点的层级等...

    C++实现1-5确定性跳跃表

    在计算机科学领域,跳跃表(Skip List)是一种可以用来替代平衡树的数据结构,尤其是在实现有序映射(Sorted Map)和有序集合(Sorted Set)时被广泛使用。本文将详细介绍一个特殊类型的跳跃表——1-5确定性跳跃表,...

    跳跃表 C++实现

    本篇将详细介绍C++实现跳跃表的原理、步骤以及如何与红黑树进行对比测试。 跳跃表(Skip List)的基本思想是通过在原有有序链表上增加多级索引,使得查找过程可以跳跃性地前进,从而减少查找次数。每条数据记录都有...

    Go-skiplist-Skiplist在Go中的实现

    Skiplist是一种高效、随机化的数据结构,常用于数据库和搜索引擎等场景,它的主要特点是查找、插入和删除操作的时间复杂度平均为O(log N),与平衡二叉搜索树相当,但实现起来更为简单。在Go语言中实现Skiplist,可以...

    skip list算法简介

    ppt文档 详细介绍了skip list的算法和实现

    skiplist模板类

    skiplist模板类

    Redis内部数据结构详解(6)——skiplist1

    skiplist不是传统意义上的平衡树或哈希表,而是基于链表的结构,通过多级跳转实现快速访问。 1. 跳跃列表基础概念: 跳跃列表由一系列节点组成,每个节点包含一个值和多个向前的指针。这些指针按层次排列,底层的...

    SKIP LIST的实现原理1

    跳表是一种高效的数据结构,常用于数据库和搜索引擎中,它以链表为基础并结合了随机化算法,使得在平均情况下查找、插入和删除...在实际应用中,跳表可以根据数据量动态调整层数,以达到更好的性能与空间效率的平衡。

    二叉搜索树 B树 Skiplist跳表 哈希表 大数据哈希表应用

    在详细讲解二叉搜索树、B树、Skiplist跳表和哈希表的过程中,我们首先需要了解数据结构的定义及其特性,然后针对不同数据结构在大数据环境下的应用进行探究。 1. 二叉搜索树(BST): 二叉搜索树是一种特殊的二叉树...

    chapter_10_映射、哈希表和跳跃表.zip

    最后,跳跃表(Skip List)是一种概率型数据结构,它通过构建多层索引来加速查找过程。每个元素在跳跃表中有多个节点,每个节点包含一个值和多个指向相邻节点的指针。较上层的节点跳过的步数更多,这样就可以快速从...

    C# 实现 01背包问题,跳跃表方案

    2. 定义跳跃表类(SkipList),包含头部节点,插入和查找方法。插入方法会根据概率决定节点的层级,查找方法则通过逐层遍历找到目标物品。 3. 在01背包问题的解决过程中,可能会用到跳跃表的查找方法来快速找到当前...

Global site tag (gtag.js) - Google Analytics