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

构建有序链表

的一个跳跃表如下: 

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
阅读更多
换一批

没有更多推荐了,返回首页