一文搞懂跳表原理及实现

已于 2024-03-21 09:32:41 修改
阅读量586 收藏 22
点赞数 25
文章标签： 红黑树 java
于 2024-03-21 09:31:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012613251/article/details/136896973
版权

前言

跳表可以达到和红黑树一样的时间复杂度O(logN)，且实现简单，Redis中的有序集合对象的底层数据结构就使用了跳表。本篇文章将对跳表的实现进行学习。

正文

一. 跳表的基础概念

跳表，即跳跃表（Skip List），是基于并联的链表数据结构，操作效率可以达到**O(logN)**，对并发友好。跳表的示意图如下所示。

图片

跳表的特点，可以概括如下。

  • 跳表是多层（level）链表结构；

  • 跳表中的每一层都是一个有序链表，并且按照元素升序（默认）排列；

  • 跳表中的元素会在哪一层出现是随机决定的，但是只要元素出现在了第k层，那么k层以下的链表也会出现这个元素；

  • 跳表的底层的链表包含所有元素；

  • 跳表头节点和尾节点不存储元素，且头节点和尾节点的层数就是跳表的最大层数；

  • 跳表中的节点包含两个指针，一个指针指向同层链表的后一节点，一个指针指向下层链表的同元素节点。

以上图中的跳表为例，如果要查找元素71，那么查找流程如下图所示。

图片

从顶层链表的头节点开始查找，查找到元素71的节点时，一共遍历了4个节点，但是如果按照传统链表的方式（即从跳表的底层链表的头节点开始向后查找），那么就需要遍历7个节点，所以跳表以空间换时间，缩短了操作跳表所需要花费的时间。

二. 跳表的节点

已知跳表中的节点，需要有指向当前层链表后一节点的指针，和指向下层链表的同元素节点的指针，所以跳表中的节点，定义如下。

public class SkiplistNode {

    public int data;
    public SkiplistNode next;
    public SkiplistNode down;
    public int level;

    public SkiplistNode(int data, int level) {
        this.data = data;
        this.level = level;
    }

}

上述是跳表中的节点的最简单的定义方式，存储的元素data为整数，节点之间进行比较时直接比较元素data的大小。

三. 跳表的初始化

跳表初始化时，将每一层链表的头尾节点创建出来并使用集合将头尾节点进行存储，头尾节点的层数随机指定，且头尾节点的层数就代表当前跳表的层数。初始化后，跳表结构如下所示。

图片

跳表初始化的相关代码如下所示。

public LinkedList<SkiplistNode> headNodes;
public LinkedList<SkiplistNode> tailNodes;

public int curLevel;

public Random random;

public Skiplist() {
    random = new Random();

    
    headNodes = new LinkedList<>();
    
    tailNodes = new LinkedList<>();

    
    curLevel = getRandomLevel();
    
    SkiplistNode head = new SkiplistNode(Integer.MIN_VALUE, 0);
    SkiplistNode tail = new SkiplistNode(Integer.MAX_VALUE, 0);
    for (int i = 0; i <= curLevel; i++) {
        head.next = tail;
        headNodes.addFirst(head);
        tailNodes.addFirst(tail);

        SkiplistNode headNew = new SkiplistNode(Integer.MIN_VALUE, head.level + 1);
        SkiplistNode tailNew = new SkiplistNode(Integer.MAX_VALUE, tail.level + 1);
        headNew.down = head;
        tailNew.down = tail;

        head = headNew;
        tail = tailNew;
    }
}

四. 跳表的添加方法

每一个元素添加到跳表中时，首先需要随机指定这个元素在跳表中的层数，如果随机指定的层数大于了跳表的层数，则在将元素添加到跳表中之前，还需要扩大跳表的层数，而扩大跳表的层数就是将头尾节点的层数扩大。下面给出需要扩大跳表层数的一次添加的过程。

初始状态时，跳表的层数为2，如下图所示。

图片

现在要往跳表中添加元素120，并且随机指定的层数为3，大于了当前跳表的层数2，此时需要先扩大跳表的层数，如下图所示。

图片

将元素120插入到跳表中时，从顶层开始，逐层向下插入，如下图所示。

图片

跳表的添加方法的代码如下所示。

public void add(int num) {
    
    int level = getRandomLevel();
    
    
    if (level > curLevel) {
        expanLevel(level - curLevel);
    }

    
    SkiplistNode curNode = new SkiplistNode(num, level);
    
    SkiplistNode preNode = headNodes.get(curLevel - level);
    for (int i = 0; i <= level; i++) {
        
        
        while (preNode.next.data < num) {
            preNode = preNode.next;
        }

        
        curNode.next = preNode.next;
        preNode.next = curNode;

        
        if (curNode.level > 0) {
            SkiplistNode downNode = new SkiplistNode(num, curNode.level - 1);
            
            curNode.down = downNode;
            
            curNode = downNode;
        }
        
        preNode = preNode.down;
    }
}

private void expanLevel(int expanCount) {
    SkiplistNode head = headNodes.getFirst();
    SkiplistNode tail = tailNodes.getFirst();
    for (int i = 0; i < expanCount; i++) {
        SkiplistNode headNew = new SkiplistNode(Integer.MIN_VALUE, head.level + 1);
        SkiplistNode tailNew = new SkiplistNode(Integer.MAX_VALUE, tail.level + 1);
        headNew.down = head;
        tailNew.down = tail;

        head = headNew;
        tail = tailNew;

        headNodes.addFirst(head);
        tailNodes.addFirst(tail);
    }
}

五. 跳表的搜索方法

在跳表中搜索一个元素时，需要从顶层开始，逐层向下搜索。搜索时遵循如下规则。

  • 目标值大于当前节点的后一节点值时，继续在本层链表上向后搜索；

  • 目标值大于当前节点值，小于当前节点的后一节点值时，向下移动一层，从下层链表的同节点位置向后搜索；

  • 目标值等于当前节点值，搜索结束。

下图是一个搜索过程的示意图。

图片

跳表的搜索的代码如下所示。

public boolean search(int target) {
    
    SkiplistNode curNode = headNodes.getFirst();
    while (curNode != null) {
        if (curNode.next.data == target) {
            
            return true;
        } else if (curNode.next.data > target) {
            
            
            
            curNode = curNode.down;
        } else {
            
            
            
            curNode = curNode.next;
        }
    }
    return false;
}

六. 跳表的删除方法

当在跳表中需要删除某一个元素时，则需要将这个元素在所有层的节点都删除，具体的删除规则如下所示。

  • 首先按照跳表的搜索的方式，搜索待删除节点，如果能够搜索到，此时搜索到的待删除节点位于该节点层数的最高层；

  • 从待删除节点的最高层往下，将每一层的待删除节点都删除掉，删除方式就是让待删除节点的前一节点直接指向待删除节点的后一节点。

下图是一个删除过程的示意图。

图片

跳表的删除的代码如下所示。

public boolean erase(int num) {
    
    
    SkiplistNode curNode = headNodes.getFirst();
    while (curNode != null) {
        if (curNode.next.data == num) {
            
            SkiplistNode preDeleteNode = curNode;
            while (true) {
                
                preDeleteNode.next = curNode.next.next;
                
                
                
                preDeleteNode = preDeleteNode.down;

                
                
                if (preDeleteNode == null) {
                    return true;
                }

                
                
                
                while (preDeleteNode.next.data != num) {
                    preDeleteNode = preDeleteNode.next;
                }
            }
        } else if (curNode.next.data > num) {
            curNode = curNode.down;
        } else {
            curNode = curNode.next;
        }
    }
    return false;
}

七. 跳表完整代码

跳表完整代码如下所示。

public class Skiplist {

    public LinkedList<SkiplistNode> headNodes;
    public LinkedList<SkiplistNode> tailNodes;

    public int curLevel;

    public Random random;

    public Skiplist() {
        random = new Random();

        
        headNodes = new LinkedList<>();
        
        tailNodes = new LinkedList<>();

        
        curLevel = getRandomLevel();
        
        SkiplistNode head = new SkiplistNode(Integer.MIN_VALUE, 0);
        SkiplistNode tail = new SkiplistNode(Integer.MAX_VALUE, 0);
        for (int i = 0; i <= curLevel; i++) {
            head.next = tail;
            headNodes.addFirst(head);
            tailNodes.addFirst(tail);

            SkiplistNode headNew = new SkiplistNode(Integer.MIN_VALUE, head.level + 1);
            SkiplistNode tailNew = new SkiplistNode(Integer.MAX_VALUE, tail.level + 1);
            headNew.down = head;
            tailNew.down = tail;

            head = headNew;
            tail = tailNew;
        }
    }

    public boolean search(int target) {
        
        SkiplistNode curNode = headNodes.getFirst();
        while (curNode != null) {
            if (curNode.next.data == target) {
                
                return true;
            } else if (curNode.next.data > target) {
                
                
                
                curNode = curNode.down;
            } else {
                
                
                
                curNode = curNode.next;
            }
        }
        return false;
    }

    public void add(int num) {
        
        int level = getRandomLevel();
        
        
        if (level > curLevel) {
            expanLevel(level - curLevel);
        }

        
        SkiplistNode curNode = new SkiplistNode(num, level);
        
        SkiplistNode preNode = headNodes.get(curLevel - level);
        for (int i = 0; i <= level; i++) {
            
            
            while (preNode.next.data < num) {
                preNode = preNode.next;
            }

            
            curNode.next = preNode.next;
            preNode.next = curNode;

            
            if (curNode.level > 0) {
                SkiplistNode downNode = new SkiplistNode(num, curNode.level - 1);
                
                curNode.down = downNode;
                
                curNode = downNode;
            }
            
            preNode = preNode.down;
        }
    }

    public boolean erase(int num) {
        
        
        SkiplistNode curNode = headNodes.getFirst();
        while (curNode != null) {
            if (curNode.next.data == num) {
                
                SkiplistNode preDeleteNode = curNode;
                while (true) {
                    
                    preDeleteNode.next = curNode.next.next;
                    
                    
                    
                    preDeleteNode = preDeleteNode.down;

                    
                    
                    if (preDeleteNode == null) {
                        return true;
                    }

                    
                    
                    
                    while (preDeleteNode.next.data != num) {
                        preDeleteNode = preDeleteNode.next;
                    }
                }
            } else if (curNode.next.data > num) {
                curNode = curNode.down;
            } else {
                curNode = curNode.next;
            }
        }
        return false;
    }

    private void expanLevel(int expanCount) {
        SkiplistNode head = headNodes.getFirst();
        SkiplistNode tail = tailNodes.getFirst();
        for (int i = 0; i < expanCount; i++) {
            SkiplistNode headNew = new SkiplistNode(Integer.MIN_VALUE, head.level + 1);
            SkiplistNode tailNew = new SkiplistNode(Integer.MAX_VALUE, tail.level + 1);
            headNew.down = head;
            tailNew.down = tail;

            head = headNew;
            tail = tailNew;

            headNodes.addFirst(head);
            tailNodes.addFirst(tail);
        }
    }

    private int getRandomLevel() {
        int level = 0;
        while (random.nextInt(2) > 1) {
            level++;
        }
        return level;
    }

}

总结

跳表的时间复杂度与AVL树和红黑树相同，可以达到O(logN)，但是AVL树要维持高度的平衡，红黑树要维持高度的近似平衡，这都会导致插入或者删除节点时的一些时间开销，所以跳表相较于AVL树和红黑树来说，省去了维持高度的平衡的时间开销，但是相应的也付出了更多的空间来存储多个层的节点，所以跳表是用空间换时间的数据结构。

原文地址：一文搞懂跳表原理及实现

攻城狮不是猫
关注
  • 25
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
跳表SkipList的原理及实现
07-02
跳表是由William Pugh发明。他在 Communications of the ACM June 1990, 33(6) 668-676 发表了Skip lists: a probabilistic alternative to balanced trees，在该论文中详 细解释了跳表的数据结构和插入删除操作。
c++如何实现跳表
08-18
主要介绍了c++如何实现跳表，帮助大家更好的理解和学习，感兴趣的朋友可以了解下
Go 语言中实现SkipList实现跳表.pdf
02-11
这份资源里面包含完整代码，有完整注解，也有跳表测试使用语句，是一份不可多得的好资源。 跳表 (Skip List) 是一种有序的链表数据结构，它通过在每个节点中存储多个指针，来提高查询效率。它的特点如下： 有序性：跳表中的元素是按照键值排序的，查询时可以利用这种有序性来加速查询速度。 动态的高度：跳表的高度是随机的，这使得每次查询的复杂度都不同，但是它的期望复杂度为O(logn)。 快速插入和删除：跳表支持快速的插入和删除，时间复杂度与链表类似，也是O(n)。 空间效率：跳表比平衡树等其他数据结构更加空间效率，因为它只需要维护每个节点的多个指针。 支持快速的查询：跳表可以快速的定位到指定的元素，查询时间复杂度为O(logn)。 总的来说，跳表是一种高效的有序数据结构，它提高了查询效率，同时又保证了插入和删除的效率。
跳表 java实现
01-29
跳表 java实现版本，内含两个java文件。原文讲解链接：https://blog.csdn.net/weixin_38073885/article/details/86690517
java跳表实现
11-06
用java语言实现跳表。包括跳表节点定义，跳表的建立，插入，删除。
跳跃表原理及实现
热门推荐
fengchengwu2012的博客
12-28 1万+
C语言 跳跃表
跳跃表及底层实现原理解析
Slayer_Zhao的博客
03-10 1873
目录 一、跳跃表简介 为什么使用跳跃表 本质是解决查找问题 更进一步的跳跃表 二、跳跃表的实现 随机层数 创建跳跃表 插入节点实现 第一部分：声明需要存储的变量 第二部分：搜索当前节点插入位置 第三部分：生成插入节点 第四部分：重排前向指针 第五部分：重排后向指针并返回 节点删除实现 节点更新实现 元素排名的实现 一、跳跃表简介 跳跃表（skiplist）...
跳表的原理与实现 [图解]
Appleeatingboy的博客
09-02 1万+
针对有序链表为了实现高效的查找，可以使用跳表这种数据结构。 其根本思想是 二分查找 的思想。 跳表的前提条件是针对有序的单链表 ，实现高效地查找，插入，删除。
跳跃表基本实现原理
qq_34679704的博客
04-16 1508
跳表作为 Redis 有序集合底层的数据结构之一，拥有较高的读写性能，且实现相较于红黑树，平衡树也更为简单。
跳跃表-原理及Java实现
weixin_33949359的博客
04-25 1745
跳跃表-原理及Java实现 引言： 上周现场面试阿里巴巴研发工程师终面，被问到如何让链表的元素查询接近线性时间。笔者苦思良久，缴械投降。面试官告知回去可以看一下跳跃表，遂出此文。 跳跃表的引入 我们知道，普通单链表查询一个元素的时间复杂度为O(n)，即使该单链表是有序的，我们也不能通过2分的方式缩减时间复杂度。 如上图，我们要查询元素为55的...
『数据结构』跳跃表
叄拾叄画生
12-09 1152
什么是跳跃表？跳跃表的原理。跳跃表的时间复杂度。跳跃表的实现分析。跳跃表的插入分析。跳跃表的删除分析。代码实现。
【Redis】之 Redis 简介与高性能原理
王廷云的博客
09-17 1508
什么是 Redis Redis(Remote Dictionary Server) 是一个使用 C 语言编写的，开源的（BSD许可）高性能非关系型（NoSQL）的键值对数据库。 Redis 可以存储键和五种不同类型的值之间的映射。键的类型只能为字符串，值支持五种数据类型：字符串、列表、集合、散列表、有序集合。 与传统数据库不同的是 Redis 的数据是存在内存中的，所以读写速度非常快，因此 redis 被广泛应用于缓存方向，每秒可以处理超过 10万次读写操作，是已知性能最快的Key-Value DB。另
数据结构与算法05：跳表和散列表
浮尘笔记
05-29 1074
对有序链表增加“索引”，改造后的数据结构就叫做 跳表（跳跃表），跳表的空间复杂度是 O(n)，在跳表中查询任意数据的时间复杂度是O(logn)，跳表中插入和删除操作的时间复杂度也是 O(logn)。散列表的本质是一个数组，可以在O(1)的时间复杂度查找元素。常用的散列冲突解决方法有两类，分别是：开放寻址法 和 链表法。散列表中装载因子越大，说明空闲位置越少，也就是冲突越多，散列表的性能会下降。
「 Redis 」 SkipList 跳表底层实现及应用
frozenpenguin的博客
12-09 2068
跳表（SkipList，全称跳跃表）是用于有序元素序列快速搜索查找的一个数据结构，跳表是一个随机化的数据结构，实质就是一种可以进行二分查找的有序链表。跳表在原有的有序链表上面增加了多级索引，通过索引来实现快速查找。
Redis的跳跃表底层原理
weixin_42146366的博客
05-08 3585
一、前言     跳跃表（skiplist）是一种有序数据结构，它通过在每个节点中维持多个指向其他节点的指针，从而达到快速访问节点的目的。跳跃表支持平均O（logN）、最坏O（N）复杂度的节点查找，还可以通过顺序性操作来批量处理节点。     在大部分情况下，跳跃表的效率可以和平衡树相媲美，并且因为跳跃表的实现比平衡树...
Redis SkipList(跳表)底层原理详解
爱意时刻减淡，玫瑰不再浪漫
07-07 532
SkipList(跳表)是一种有序的数据结构，它通过在每个节点中维持多个指向其他节点的指针，然后达到快速访问节点的目的，它的节点查找的复杂度为平均 O(logN)、最坏O(N)，还能通过顺序性的操作来批量处理节点。SkipList的本质还是链表，但是它与传统的链表还是有区别的。跳表元素是按照升序排列存储的跳表查询性能要比链表好： 链表：当元素很多时并且要访问中间某个元素，那么查询效率会非常慢，因为链表它的指针跨度为1，查询是一个一个往后查询的 跳表：节点中可能包含多个指针，指针跨度比链表大，这样查询效率就快
mybatisPlus使用MetaObjectHandler对字段进行更新
最新发布
m0_56356631的博客
04-23 484
都是符合我们的预期的。
string模拟实现
m0_73969414的博客
04-23 1561
c++中string的模拟实现，面试必会知识点
redis 跳表原理
08-12
Redis 跳表（Skip List）是一种有序数据结构，用于实现有序集合（Sorted Set）的数据存储和快速查找。 跳表的核心思想是在链表的基础上增加多级索引，通过索引来加速查找。每一级索引包含一部分节点，这些节点按照某种规则连接起来，形成一个类似于二叉树的结构。每一级索引的节点数逐级减少，最高级索引只有两个节点，分别指向整个跳表的头节点和尾节点。 在跳表中，每个节点除了保存值之外，还保存了指向同一层级或下一层级的节点的指针。通过这样的结构，跳表可以在不需要遍历所有节点的情况下，快速定位到目标节点。 Redis 使用跳表实现有序集合的数据结构，具体实现步骤如下： 1. 创建一个带有头节点和尾节点的空跳表。 2. 向跳表中插入新的元素时，从最高级索引开始，逐级向下查找插入位置。 3. 在每一级索引中，找到插入位置后，将新节点插入到该位置后面。 4. 根据概率随机算法，决定是否在更高级索引中插入新节点的指针。 5. 删除元素时，从最高级索引开始，逐级向下查找并删除节点。 6. 如果删除节点后某一级索引只剩下头节点和尾节点，则删除该级索引。 通过使用跳表，Redis 在有序集合中执行插入、删除、查找等操作的时间复杂度可以达到 O(logN)，相比于传统的有序数组或平衡二叉树，跳表具有更高的效率和简单的实现方式。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值