跳表

最新推荐文章于 2023-01-07 00:00:00 发布
最新推荐文章于 2023-01-07 00:00:00 发布
阅读量326 收藏 1
点赞数 1
分类专栏： 数据结构 链表 文章标签： 数据结构 性能 链表 结构 数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiao_ren_wu_/article/details/78742801
版权

作用/目的

跳表作为一种数据结构通常用于取代平衡树。

起因

平衡树可以用于表示抽象的数据类型如字典和有序链表，它通过树旋转（Tree Rotation）操作强制使树结构保持平衡来保证节点搜索的效率。在数据为随机插入的情况下，平衡树性能表现良好；但数据为顺序插入或者需要删除节点的情况下，平衡树的性能就会有些糟糕。

跳表可以作为平衡树的一种替代选择。它使用随机的平衡策略取代平衡树严格的强制的树平衡策略。因此它具有更简单有效的插入/删除方法以及更快的搜索速度。

原理

假设有一个链表，我们要查找某个节点，则我们需要逐个的查找链表的每个节点
这里写图片描述
如果链表是有序的，并且每隔一个节点都有一个指向其前面2个位置节点的指针，那我们只需要最多查找⌈N/2⌉个节点（N为链表长度）
这里写图片描述
如果再每隔3个节点就有指向其前面4个位置节点的指针，那么我们就只需要查找不超过⌈N/4⌉+2个节点
这里写图片描述
也即如果每个(2^i)位置的节点都有指向其前面2^i个位置节点的指针，则查找某个节点的次数可以下降到⌈log2^n⌉次（只是指针数会变为之前的双倍）

这种数据结构可以用于快速的查找，只是插入和删除不太容易实现。

如果不再依照节点的位置，而是采取一种随机的策略来决定节点是否具有额外的指向前面节点的指针呢？

假设拥有k个前向指针的节点我们称之为k等级节点，在节点被分配出来的时候，我们通过随机策略（按照一定的概率）来决定节点的等级（也即有几个前向指针），节点的第i个指针也不再指向其前面2^i个位置的节点，而是指向等级i的下个节点。这样，插入和删除节点都只需要做很少的改动，其整体的效果却和上面所描述的类似。
这里写图片描述
由于这种数据结构是一个链表带有额外的指针，在链表的节点间跳跃，因此，原作者称其为跳跃链表（skip lists）。

实现/算法

节点等级

随机生成节点等级的算法有很多种，这里介绍原作者采用的算法：

首先确定一个概率p（1/2、1/4等），用于确定节点是否需要有下一个等级。
就跟投骰子一样，节点有1/2或1/4的概率获得下一个等级，如果是，则节点的等级k=k+1，如果不是，则节点的等级为k，至此结束。
如此重复循环。

但这里会有一个问题，某些节点的等级k可能会很大（一直获得下一个等级，虽然概率极低），这在算法的原理上没有问题（除了有极少的性能损耗），但在工程的实现上会相当麻烦，因此，在实际的实现当中，通常会设置一个最高等级（MAX_LEVEL），并且还会有一个当前链表最大等级，搜索的时候从当前最大等级开始。
这里写图片描述
关于p和MAX_LEVEL取值，原作者推荐的p值是1/4或1/2，MAX_LEVEL可根据所选的p及链表所含的最多元素个数n通过公式logp^n所得。

初始化

初始化的时候，我们会分配一个NIL节点（最终节点）并将其key值设为最大int值，还会分配一个链表初始节点，其header拥有MAX_LEVEL个前向指针，所有的前向指针都初始化成指向NIL节点（表明链表中暂无节点）。

搜索算法

通常，我们从当前链表的最大等级的header开始搜索，如果同一等级节点的key值小于搜索值，则搜索相同等级的后续节点，否则，进入到下一个等级节点继续搜索。直到搜索到相应的值或已到最低等级而后续节点的值又大于当前搜索值（表明搜索已失败）为止。

插入/删除

插入和删除节点只需要在搜索的基础上再进行简单的插入和删除操作，只是需要注意两个操作当中前向指针关系的处理，以及增加和减少链表等级后及时更新当前最大等级的值。插入的过程可见如下示意图：
这里写图片描述
实现：
准备工作：

//宏定义一堆常量
#define MAX_LEVEL 16 //最大的层级不超过16
#define MAX_INT 999999999 //定义最大的值
#define MIN_INT -999999999 //定义最小的整数

//跳表的节点
typedef struct node{
    int key;
    int value;
    struct node *forward[]; //用来存储他指向的所有节点
}Node;


//跳表的头部
typedef struct skip{
    int level;//用来记录跳表的等级
    Node *head;//用来存储跳表的头结点地址
}Skip;

//定义全局变量
Node *MAX_KEY;//相当于岗哨，是跳表的尾节点
Node *MIN_KEY;//相当于岗哨，是跳表的头结点
int RANDOM_BITS;//用来设置level用

//根据传过来的level新建跳表结点
Node* newNodeOfLevel(int level){
    Node *newNode = NULL;
    newNode = (Node*)malloc(sizeof(Node) + level*sizeof(Node*));
    for (int i = 0; i < level; i++){
        newNode->forward[i] = NULL;
    }
    return newNode;
}

//用来计算level
int randomLevel(){
    int level = 0;
    RANDOM_BITS = rand();
    while (RANDOM_BITS){
        if (RANDOM_BITS & 3){//这样可以使产生下一等级的概率为1/4
            level++;
        }
        RANDOM_BITS>>=2;
    }
    return (level > MAX_LEVEL) ? (MAX_LEVEL-1) : level;//如果产生的等级超过了最大的等级，返回最大等级-1
}

初始化一个新的跳表

Skip *newList(){
    //初始化跳表尾部的节点
    MAX_KEY = newNodeOfLevel(16);
    MAX_KEY->key = MAX_INT;
    MAX_KEY->value = MAX_INT;
    MAX_KEY->forward[0] = NULL;


    Skip *l=NULL;
    int i;
    l = (Skip*)malloc(sizeof(Skip));
    l->level = 0;
    l->head = newNodeOfLevel(MAX_LEVEL);
    l->head->key = MIN_INT;
    l->head->value = MIN_INT;
    for (i = 0; i < MAX_LEVEL; i++){
        l->head->forward[i] = MAX_KEY;
    }
    return l;
}

释放跳表

void freeList(Skip *l){
    Node *p = l->head, *q = NULL;
    while (p){
        q = p->forward[0];
        printf("%p,", p);
        //free(p->forward);
        free(p);
        printf("成功\n");
        p = q;
    }
    free(l);
}

向跳表中插入节点

int insert(Skip *l, int key, int value){
    int k;
    Node *update[MAX_LEVEL], *p=NULL, *q=NULL;
    p = l->head;
    k = l->level;
    while (k >= 0){
        while (q = p->forward[k], q->key < key){
            p = q;
        }
        update[k] = p;
        k--;
    }
    //如果原来有key,则新的value将覆盖原来的value
    if (q->key == key){
        q->value = value;
        return 1;
    }
    /*插入新的节点*/

    k = randomLevel();//获取插入的级别

    if (k > l->level){//如果获取插入的级别比原来的最大级别还大，则，获得的插入级别为原来的级别加1，并将原来的最大级别加1
        k = ++(l->level);
        update[k] = l->head;
    }
    //为新插入的节点分配单元
    q = newNodeOfLevel(k);
    //初始化新节点
    q->key = key;
    q->value=value;
    //将新节点插入到跳表的指定位置，
    while (k >= 0){
        p = update[k];
        q->forward[k] = p->forward[k];
        p->forward[k] = q;
        k--;
    }
    return 0;
}

删除跳表中的节点

int insert(Skip *l, int key, int value){
    int k;
    Node *update[MAX_LEVEL], *p=NULL, *q=NULL;
    p = l->head;
    k = l->level;
    while (k >= 0){
        while (q = p->forward[k], q->key < key){
            p = q;
        }
        update[k] = p;
        k--;
    }
    //如果原来有key,则新的value将覆盖原来的value
    if (q->key == key){
        q->value = value;
        return 1;
    }
    /*插入新的节点*/

    k = randomLevel();//获取插入的级别

    if (k > l->level){//如果获取插入的级别比原来的最大级别还大，则，获得的插入级别为原来的级别加1，并将原来的最大级别加1
        k = ++(l->level);
        update[k] = l->head;
    }
    //为新插入的节点分配单元
    q = newNodeOfLevel(k);
    //初始化新节点
    q->key = key;
    q->value=value;
    //将新节点插入到跳表的指定位置，
    while (k >= 0){
        p = update[k];
        q->forward[k] = p->forward[k];
        p->forward[k] = q;
        k--;
    }
    return 0;
}

查找跳表中的节点

int insert(Skip *l, int key, int value){
    int k;
    Node *update[MAX_LEVEL], *p=NULL, *q=NULL;
    p = l->head;
    k = l->level;
    while (k >= 0){
        while (q = p->forward[k], q->key < key){
            p = q;
        }
        update[k] = p;
        k--;
    }
    //如果原来有key,则新的value将覆盖原来的value
    if (q->key == key){
        q->value = value;
        return 1;
    }
    /*插入新的节点*/

    k = randomLevel();//获取插入的级别

    if (k > l->level){//如果获取插入的级别比原来的最大级别还大，则，获得的插入级别为原来的级别加1，并将原来的最大级别加1
        k = ++(l->level);
        update[k] = l->head;
    }
    //为新插入的节点分配单元
    q = newNodeOfLevel(k);
    //初始化新节点
    q->key = key;
    q->value=value;
    //将新节点插入到跳表的指定位置，
    while (k >= 0){
        p = update[k];
        q->forward[k] = p->forward[k];
        p->forward[k] = q;
        k--;
    }
    return 0;
}

测试：

int main(void){
    srand(time(NULL));
    Skip *l;
    int i, k;
    int map[10000][2];
    int v;
    l = newList();
    for (int i = 0; i < 10; i++){
        //随机生成key,value
        map[i][0] = rand()%1000;
        map[i][1] = rand()%1000;
        insert(l, map[i][0], map[i][1]);
    }
    printSkipLink(l);
    printf("\n--------------------------------------------------------------------\n");
    printf("\n\nlevel=%d\n\n",l->level);
    for (int i = 0; i < 10; i++){
        deleteNode(l,map[i][0]);
    }
    //deleteNode(l, map[0][0]);
    printf("删除后：%d ====%d\n\n",map[0][0],search(l,map[0][0]));
    printf("\n--------------------------------------------------------------------\n");
    //printSkipLink(l);
    //freeList(l);
    system("pause");
    return 0;
}

演示效果：
这里写图片描述

xiao-ren-wu
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
跳表的介绍与实现
cll的专栏
07-05 7388
作用/目的 跳表作为一种数据结构通常用于取代平衡树。 起因 平衡树可以用于表示抽象的数据类型如字典和有序链表，它通过树旋转（Tree Rotation）操作强制使树结构保持平衡 来保证节点搜索的效率。在数据为随机插入的情况下，平衡树性能表现良好；但数据为顺序插入或者需要删除节点的 情况下，平衡树的性能就会有些糟糕。 跳表可以作为平衡树的一种替代选择。它使用随机的平衡策略
Redis中的跳跃表
热门推荐
universe_ant的博客
04-12 1万+
跳跃表  跳跃表(skiplist)是一种有序数据结构，它通过在每个节点中维持多个指向其他节点的指针，从而达到快速访问节点的目的。  跳跃表支持平均O(logN)、最坏O(N)复杂度的节点查找，还可以通过顺序性操作来批量处理节点。  在大部分情况下，跳跃表的效率可以和平衡树相媲美，并且因为跳跃表的实现比平衡树要来得更为简单，所以有不少程序都使用跳跃表来代替平衡树。  Redis使用跳跃表作为有序集合
跳表简单介绍
wwxy1995的博客
08-30 164
跳表是为了让链表的查找更快而诞生的一种数据结构 跳表在链表的基础上，向上建立索引 跳表的查找从最上层开始，逐层向下进行查找 跳表的插入： 需要先在链表中插入数据，再去跟新索引。 跳表的上层节点个数一般是下层节点个数的1/2 跳表插入和删除的时间复杂近似为O(logN） ...
跳表介绍和实现
hebtu666
04-18 1万+
想慢慢的给大家自然的引入跳表。 想想，我们 1）在有序数列里搜索一个数 2）或者把一个数插入到正确的位置 都怎么做？ 很简单吧 对于第一个操作，我们可以一个一个比较，在数组中我们可以二分，这样比链表快 对于第二个操作，二分也没什么用，因为找到位置还要在数组中一个一个挪位置，时间复杂度依旧是o(n)。 那我们怎么发明一个查找插入都比较快的结构呢？ 可以打...
跳表介绍
zhangbinalan的专栏
07-17 814
跳表介绍
c++如何实现跳表
08-18
C++实现跳表的知识点 跳表是一种随机化的数据结构，它允许快速查询一个有序连续元素的数据链表。跳跃列表的平均查找和插入时间复杂度都是O(log n)，优于普通队列的O(n)。性能上和红黑树，AVL树不相上下，但跳表的...
跳表 java实现
01-29
跳表 java实现版本，内含两个java文件。原文讲解链接：https://blog.csdn.net/weixin_38073885/article/details/86690517
数据结构之跳表
03-18
数据结构之跳表的完整代码
java跳表实现
11-06
用java语言实现跳表。包括跳表节点定义，跳表的建立，插入，删除。
简单谈谈Mysql索引与redis跳表
09-09
MySQL索引和Redis跳表是两种不同的数据结构，它们在数据库和键值存储系统中用于优化数据检索。这里我们将深入探讨这两种技术，并分析其特点、适用场景和优缺点。 MySQL索引是数据库管理系统中用于加速数据查找的...
跳表SkipList介绍与实现
weixin_61857742的博客
01-07 1011
跳表是一种随机化数据结构，主要用于快速检索数据。实质上是一种可以进行二分查找的有序链表。时间复杂度可以达到O(log^n)。在性能上与红黑树、AVL树相当。当然因为结构具有随机性，最坏情况下时间复杂度为O(n)。跳表结构如下图：与普通链表相比，跳表每个结点有不止一个指向后续的指针，具体数量是随机出来的。这些指针结构上从低到高排列，指向后面与自己同层的指针所在的结点。检索数据时，从head结点开始，按指针从高到低的所指元素大小进行比较，直到找到或走到结尾。
详解高级数据结构之 跳表
小鱼学编程
07-22 7317
今天，我们来详细介绍一个高级数据结构---跳表
什么是跳表 skiplist ?
qq_27198345的博客
09-19 715
什么是跳表 skiplist ? 文章目录什么是跳表 skiplist ?特性实现结构查找插入删除完整代码参考 跳表可以快速地查找、插入、删除。据说可以替代红黑树。Redis中的有序集合就是用调表来实现的。 调表结合了链表和二分查找的思想； 由原始链表和一些通过”跳跃“生成的链表组成； 第0层是原始链表，越上层”跳跃“的越高，元素越少； 上层链表是下层链表的子序列； 查找时从上到下，不断缩小搜索范围。 特性 调表有很多层，如果只看0层的话，就是一个有序链表。那么其他层呢？ 链表查询的时间复杂度为O(n)
跳表简单快速理解
或左的博客
03-19 190
写在前面： 本博文记录下自己的理解，不属于科普类分享 跳表的逻辑 跳跃表是一种随机化数据结构，基于并联的链表，其效率可以比拟平衡二叉树，查找、删除、插入等操作都可以在对数期望时间内完成，对比平衡树，跳跃表的实现要简单直观很多。 跳表，可以理解为跳跃的链表，本质上还是链表 上图的每一列都是一个链表节点，每个节点的层数都是随机的，在插入节点时，层数随机生成（可以采用这样一个逻辑，50%概率0 or 1，如果是0，则继续随机，直到遇到第一个1，一个随机了多少次就是有多少层，所以1层的概率是50%，二层的概率
跳表的原理与实现 [图解]
Appleeatingboy的博客
09-02 1万+
针对有序链表为了实现高效的查找，可以使用跳表这种数据结构。 其根本思想是 二分查找 的思想。 跳表的前提条件是针对有序的单链表 ，实现高效地查找，插入，删除。
跳表的设计与应用场景
zjshuster的博客
06-30 972
skiplist
跳表的设计思路，值得每一个程序员学习
somenzz的博客
01-15 1847
学习《数据结构与算法之美》中的第 17 节 [为什么redis一定要用跳表来实现有序集合]后，觉得很有价值，以自己的理解整理出下文，分享给爱学习的你，希望你可以看懂。 上篇文章二分法解决妹子遇到的难题 介绍了二分查找算法法的强大之处。二分查找算法之所以能达到 O(logn) 这样高效的一个重要原因在于它所依赖的数据结构是数组，数组支持随机访问一个元素，通过下标很容易定位到中间元素。而链表是不支持随...
跳表Skiplist
南国的技术栈
01-29 280
前言 二分查找 一般而言，针对在某个数组中查找等于某个给定值的数组元素的下标问题，我们一般可以想到二分查找(Bianry Search)的方法来实现时间复杂为O(logn)的查询性能。 代码如下所示： while(low&amp;amp;amp;lt;=high){ int mid=low+(high-low)/2; if(s[mid]==n) return mid; esleif(s[mid]&amp;amp;amp;lt;...
20220304-0307es
wujiansheng111的博客
03-07 2721
elasticsearch lucene: 跳表(SkipList)：增加了向前指针的链表叫做指针。跳表全称叫做跳跃表，简称跳表。跳表是一个随机化的数据结构，实质是一种可以进行二分查找的有序链表。跳表在原有的有序链表上增加了多级索引，通过索引来实现快速查询。跳表不仅能提高搜索性能，同时也可以提高插入和删除操作的性能。 AVL树，本质上是带了平衡功能的二叉查找树（二叉排序树，二叉搜索树）. 建立索引：document\field\analyzer\indexwriter\directory 搜索文档
postgres 跳表
最新发布
08-16
在 PostgreSQL 数据库中，并没有内置的跳表（Skip List）索引实现。PostgreSQL 提供了多种索引类型，如B树索引、哈希索引、GiST索引和GIN索引等，但没有直接支持跳表的索引类型。 B树索引是 PostgreSQL 中最常用的索引类型之一。它适用于范围查询和等值查询，并且可以保持数据有序性。B树索引在处理数据块的平衡性和查询效率方面具有很好的性能。 除了B树索引之外，PostgreSQL 还提供了其他类型的索引用于特定的场景。例如，哈希索引适用于等值查询，可以提供快速的哈希查找；GiST 索引（通用搜索树）和 GIN 索引（通用倒排索引）适用于全文搜索和复杂的匹配查询。 虽然 PostgreSQL 不提供内置的跳表索引实现，但是你可以使用扩展或自定义索引实现跳表的功能。通过编写自定义插件或使用第三方扩展，你可以在 PostgreSQL 中实现跳表索引。这需要一定的开发工作，并且需要充分测试和评估性能。 需要注意的是，自定义实现的跳表索引可能会受到 PostgreSQL 内核版本更新的影响，并且可能无法享受到 PostgreSQL 内置索引的一些优化和支持。 总之，PostgreSQL 并没有内置的跳表索引实现，但提供了其他类型的索引，如B树索引、哈希索引、GiST索引和GIN索引等，用于满足不同的查询需求。如果需要使用跳表索引，你可以考虑自定义实现或使用第三方扩展。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值