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

60 阅读 0 评论 40 点赞

我是靠谱客的博主落后龙猫，最近开发中收集的这篇文章主要介绍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定义

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

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

一个跳表应该有几个层（level）组成；
跳表的第一层包含所有的元素；
每一层都是一个有序的链表；
如果元素x出现在第i层，则所有比i小的层都包含x；
第i层的元素通过一个down指针指向下一层拥有相同值的元素；
在每一层中，-1和1两个元素都出现(分别表示INT_MIN和INT_MAX)；
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=%dn",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

最后

以上就是落后龙猫为你收集整理的Skip List（跳跃表）原理详解与实现的全部内容，希望文章能够帮你解决Skip List（跳跃表）原理详解与实现所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。

本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。

本文分类：数据结构和算法学习
浏览次数：60 次浏览
发布日期：2023-12-30 11:40:44
本文链接：https://www.kaopuke.com/article/k-p-k_13_u_23_ocfz_12__7__14_2.html

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