跳表.

已于 2023-12-11 11:36:43 修改
阅读量387 收藏 8
点赞数 7
文章标签： java
于 2023-12-06 11:47:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_71299382/article/details/134827955
版权

1.跳表的意义

我们都知道 对于一个有序(指的是元素值是升序或者降序的)的数组而言 二分法查询的最坏时间复杂度是O(logn)
我解释一下logn的由来：
比如现在我们有一个长度为8的数组 最坏情况就是分到最后长度为1的时候查询到元素 其中的过程为8 4 2 1 需要执行3次操作 即为log28 = 3 那么简化成复杂度就是O(logn)
然后对于一个有序的链表来说 我们还是需要从头到尾一个一个查询 那么最坏复杂度还是O(n) 但是跳表的出现优化了链表的查询操作

2.跳表的特点

1.一个跳表由若干层链表组成
2.每一层链表都是有序的
3.跳表最下面一层的链表包含了所有的数据
4.如果一个元素出现在了某一层级 那么该层级下面的所以层级都会包含该元素
5.当前层级的元素和指向下一层级的元素始终相同的
6.跳表最上面一层的头元素为head所指向

3.节点类的实现

private class Node<E>{
    // 私有成员
    private E val;// 节点值
    private Node<E> next;// 水平方向上的下一节点
    private Node<E> down;// 竖直方向上的下一节点
    // 构造方法
    public Node(E val, Node<E> next){
        this.val = val;
        this.next = next;
    }
}

4.层级索引的随机生成

此方法致力于随机生成一个待插入的层级数
保证层级为1的概率为0.5 层级为2的概率为0.25(0.5 x 0.5) 层级为3的概率为0.125(0.5 x 0.5 x 0.5)……每一层级的概率是上一层级生成概率的一半

public int randLevel(){
    int level = 1;
    while(Math.random() < 0.5f && level < MAX_LEVEL)
        level++;
    return level;
}

5.插入方法

跳表插入的总体思路为：第一步 检查一下有无未创建的层级 如若有 那么就先创建 第二步 层级创建完毕以后 跳过无需获取前置节点的层级从待插入层级开始从上往下依次获取待插入节点的前置节点 存放入数组中的相应位置 第三步 从待插入层级开始 从上往下依次执行插入操作 最后需要更新记录总层级数的变量

public void add(E val){
    // 首先随机生成一个待插入的层级数
    int level = randLevel();
    // 接着创建一个数组 用于存放前置节点
    Node[] preNodes = new Node[level];
    if(level > curLevelCounts){
        // 保存一下旧的头结点
        Node<E> beforeHead = head;
        // 更新头结点
        head = new Node<>(null, null);
        // 接着定义一个遍历节点 初始化为头结点
        Node<E> curHead = head;
        for(int i = curLevelCounts; i < level - 1; ++i){
            // 为每一个新层创建头结点
            Node<E> node = new Node<>(null, null);
            // 设置down属性
            curHead.down = node;
            curHead = node;
        }
        // 最后还要连接一下curHead和beforeHead之间的线
        curHead.down = beforeHead;
    }
    // 定义一个遍历节点 用于遍历前置节点
    Node<E> preNode = head;
    // 过滤层级
    for(int i = curLevelCounts; i > level; --i){
        preNode = preNode.down;
    }
    // 获取必要层级的前置节点
    for(int i = level - 1; i >= 0; --i){
        while(preNode.next != null && preNode.next.val.compareTo(val) < 0){
            preNode = preNode.next;
        }
        preNodes[i] = preNode;
        preNode = preNode.down;
    }
    Node<E> topNode = null;
    for(int i = level - 1; i >= 0; --i){
        Node<E> node = new Node<>(val, preNodes[i].next);
        preNodes[i].next = node;
        if(topNode != null){
            topNode.down = node;
        }
        topNode = node;
    }
    if(level > curLevelCounts)
        curLevelCounts = level;
}

6.查询方法

在这里插入图片描述

该方法旨在查找是否存在指定值
总体思路：从跳表的最上层链表开始查询 先在当前层级从前往后查找 如果下一节点为空或者下一节点大于指定值的话 那么就前往下一层级寻找 否则就继续在当前层级查找 如果找到了 就返回true 没找到就返回false
然后确实有可能存在当前节点的节点值为空 然后执行if语句 那么将无法执行if语句中的代码 所以需要或上一个node.val == null才行

public boolean search(int target){
    // 从头结点开始查找
    Node<E> node = head;
    while(node != null){
        if(node.val == null || node.val.compareTo(target) < 0){
            if(node.next == null){
                node = node.down;
            }else{
                node = node.next.val > target ? node.down : node.next;
            }
        }else if(node.val.equals(target)){
            return true;
        }else{
            return false;
        }
    }
    return false;
}

7.删除方法

在这里插入图片描述

总体思路：首先找到待删除节点所处的最高层级 然后从最高层级开始往下一层一层执行待删除节点的删除操作 全部删除完毕以后 需要检查一下哪些是空链表 如若存在空链表 就需要更新总层级数和头结点
删除方法中的删除操作是从topIndex开始删除的 topIndex储存的是层级数-1
node.next.val.equals(val)必须写在node.next != null后面 如果反之就报错了

public boolean remove(E val){
    // 定义一个遍历节点 初始化为头结点
    Node<E> node = head;
    int topIndex = -1;
    for(int i = curLevelCounts - 1; i >= ){
        while(node.next != null && node.next.val.compareTo(val) < 0)
            node = node.next;
        if(node.next != null && node.next.val.equals(val) && topIndex == -1){
            topIndex = i;
            break;
        }
        if(node.down == null) 
            return false;
        node = node.down;   
    }
    if(topIndex == -1)
        return false;
    for(int i = topIndex; i >= 0; --i){
        if(node.next != null)
            node.next = node.next.next;
        // 更新遍历节点为下一层级的前置节点
        node = node.down;
        if(node != null){
            while(node.next != null && !node.next.val.equals(val)){
                node = node.next;
            }
        }
    }
    // 删除那些已被清空的链表
    while(curLevelCounts > 1 && head.next == null){
        curLevelCounts--;
        head = head.down;
    }
    // 执行到此 才算真正的删除成功
    return true;
}

8.整体代码

由于待会需要进行节点值的大小比较 所以说需要让泛型继承自Comparable类才行 这样才能调用该类中的compareTo方法进行泛型的大小比较

public class SkipLinkedList<E extends Comparable<E>>{
    // 私有成员
    private Node<E> head;// 头节点
    private int MAX_LEVEL = 16;// 最大的待插入层级
    private int curLevelCounts;// 当前的总层级数
    // 构造方法
    public SkipLinkedList(){
        // 用于初始化头节点
        head = new Node<>(null, null);
    }



    // 节点类
    private class Node<E>{
        // 私有成员
        private E val;// 节点值
        private Node<E> next;// 水平方向上的下一个节点
        private Node<E> down;// 竖直方向上的下一个节点
        // 构造方法
        public Node(E val, Node<E> next){
            this.val = val;
            this.next = next;
        }
    }
    // 随机获取层级数的方法
    private int randLevel(){
        // 首先设置初始值
        int level = 1;
        // 然后设置每一层的概率是上一层的一半 比如获取层级2的概率是获取层级1概率的一半 获取层级3的概率是获取层级2概率的一半 以此类推
        while(Math.random() < 0.5f && level < MAX_LEVEL){
            level++;
        }
        return level;
    }
    // 用于往跳表增加元素的方法
    public void add(E val){
        // 分成三步 第一步.如果在插入之前有些层级还为创建的话 那么就优先创建这些待创建的层级 第二步.待创建完毕所有的层级以后 从待插入的层级开始至上而下依次获取待插入节点的前置节点 第三步.就是从待插入层级开始自上而下依次将待插入节点插入到指定位置处
        // 首先先获取待插入的层级
        int level = randLevel();
        // 接着创建一个数组 用于存放前置节点
        Node[] preNodes = new Node[level];
        if(level > curLevelCounts){
            Node<E> beforeHead = head;
            head = new Node<>(null, null);
            Node<E> curHead = head;// 这个变量旨在遍历新创建层级的头节点
            for(int i = curLevelCounts; i < level - 1; i++){
                Node<E> node = new Node<>(null, null);
                curHead.down = node;
                curHead = node;
            }
            // 最后设置curHead.down为beforeHead
            curHead.down = beforeHead;
        }
        // 定义一个遍历节点 初始化为头节点
        Node<E> preNode = head;
        // 在执行第二步之前 还需要将那些无需执行前置节点获取的层级跳过才行
        for(int i = curLevelCounts - 1; i >= level; i--){
            preNode = preNode.down;
        }
        for(int i = level - 1; i >= 0; i--){
            while(preNode.next != null && preNode.next.val.compareTo(val) < 0){
                preNode = preNode.next;
            }
            preNodes[i] = preNode;
            preNode = preNode.down;
        }
        // 最后一步就是将待插入节点从待插入层级自上而下逐层进行插入操作 插入其实就是连接三条线 一条是前置节点指向待插入节点的 一条是待插入节点指向后置节点的 一条是上置节点指向待插入节点的
        Node<E> topNode = null;
        for(int i = level - 1; i >= 0; i--){
            Node<E> node = new Node<>(val, preNodes[i].next);
            preNodes[i].next = node;
            if(topNode != null){
                topNode.down = preNodes[i];
            }
            topNode = node;
        }
        // 最后 如果有必要的话 还需要更新一下curLevelCounts的值
        if(level > curLevelCounts)
            curLevelCounts = level;
    }
    // 用于判断是否存在指定值 如果存在的话 那么就返回true 反之则返回false
    public boolean search(E target){
        // 首先定义一个遍历节点 初始化为头节点
        Node<E> node = head;
        while(node != null){
            // 如果当前节点的值小于指定值的话
            if(node.val == null || node.val.compareTo(target) < 0){
                // 如果下一节点的值为空的话 那么就直接更新为down节点
                if(node.next == null){
                    node = node.down;
                }else{
                    node = (node.next.val.compareTo(target) > 0) ? node.down : node.next;
                }
            }else if(node.val.equals(target)){
                return true;
            }else{
                return false;
            }
        }
        // 如果找寻完所有的节点以后 依然没有返回值的话 那么就说明指定值没有找到 所以直接返回false
        return false;
    }
    // 用于删除指定的节点 并且判断是否删除成功
    public boolean remove(E val){
        // 首先找到指定值所处的最高层级
        Node<E> node = head;
        int topIndex = -1;// topIndex记录的是层级数-1
        for(int i = curLevelCounts - 1; i >= 0; i--){
            // 首先一路向右找
            while(node.next != null && node.next.val.compareTo(val) < 0){
                node = node.next;
            }
            // 如果找到的话 那么就更新topIndex 并且退出循环
            if(topIndex == -1  && node.next != null && node.next.val.equals(val)){
                topIndex = i;
                break;
            }
            // 如果当前层没有找到的话 那么就往下一层继续找 先判断一下是否存在下一层 如果不存在的话 说明找不到指定值 直接返回false
            if(node.down == null)
                return false;
            node = node.down;
        }
        // 那既然指定值的最高层级已经找打的话 那么现在就开始执行删除操作
        // 如果找完以后topIndex==-1的话 那么说明没有找到指定值
        if(topIndex == -1)
            return false;
        // 从topIndex层开始往下进行删除操作
        for(int i = topIndex; i >= 0; i--){
            if(node.next != null){
                node.next = node.next.next;
            }
            // 接下来更新node为下一层待删除节点的前置节点
            // 先将node更新为down节点
            node = node.down;
            // 因为这是在移动到down元素以后进行的更新next操作 所以说我们需要对node进行判空操作 然后找到下一层的待删除节点的前置节点
            if(node != null) {
                while (node.next != null && !node.next.val.equals(val)) {
                    node = node.next;
                }
            }
        }
        // 我们要将已经被清空的链表彻底清空 彻底清空靠的是更新head节点和curLevelCounts两个变量 但是需要保证的是最后一层的节点不要被清空就行了
        while(curLevelCounts > 1 && head.next == null){
            head = head.down;
            curLevelCounts--;
        }
        // 执行到最后肯定是说明该删除的元素已经被我们成功删除了
        return true;
    }
    // 用于打印跳表
    @Override
    public String toString(){
        // 用于打印跳表
        StringBuilder sb = new StringBuilder();

        // 首先设置一个遍历节点
        Node<E> cur = head;
        while(cur != null){
            // 接着设置一个tmp节点
            Node<E> tmp = cur.next;
            while(tmp != null){

                sb.append(tmp.val).append(", ");


                tmp = tmp.next;
            }

            cur = cur.down;
            if(cur != null)
                sb.append("\n");
        }

        return sb.toString();
    }
}

9.测试

public static void main(String[] args) {
    SkipLinkedList<Integer> sll = new SkipLinkedList<>();
    sll.add(1);
    sll.add(2);
    sll.add(3);
    sll.add(4);
    sll.add(5);
    System.out.println(sll);
    sll.remove(3);
    System.out.println(sll);
    System.out.println(sll.search(6));
}
axihaihai
关注
算法：跳跃表
chen_jin_sheng的博客
12-14 6312
1、跳跃表的定义 跳跃表(Skip List)：增加了向前指针的链表叫做指针。跳表全称叫做跳跃表，简称跳表。跳表是一个随机化的数据结构，实质是一种可以进行二分查找的有序链表。跳表在原有的有序链表上增加了多级索引，通过索引来实现快速查询。跳表不仅能提高搜索性能，同时也可以提高插入和删除操作的性能。 跳表是一个随机化的数据结构，可以被看做是二叉树的一个变种，它在性能上和红黑树、AVL树不相上下，但是跳表的原理非常简单， 举生活中一个简单例子，例如我们做公交车，有快线和慢线，想起我之前在广州念书，学校距离市中
SkipList 浅析
Just for Fun la
08-20 5075
假设k层节点的数量是k+1层节点的P倍，那么其实这个SkipList可以看成是一棵平衡的P叉树。
数据结构（三）：谈谈跳跃表的原理和实现——Skip List
linjingyg的博客
01-11 304
　　Skip List的原理 　　Java中的LinkedList是一种常见的链表结构，这种结构支持O(1)的随机插入及随机删除, 但它的查找复杂度比较糟糕，为O(n)。 　　假如我们有一个有序链表如下，如果我们想找到值为59的节点，需要查找7次。怎么提高查询效率呢？通常的做法是使用二分法，但LinkedList的随机访问时间复杂度同样为O(n)，因此朴素的二分法并不适用。那怎么办呢？ 　　 　　我们可以在节点中增加额外的跳跃节点，如下： 　　 　　这样我们可以根据跳跃节点查询，只需..
数据映射--跳表(skiplist)
chivalry
10-12 7081
http://blog.sina.com.cn/s/blog_693f08470101n2lv.html 本周我要介绍的数据结构，是我非常非常喜欢的一个数据结构，因为咱也是吃过平衡二叉树的苦的人啊T_T ，神马左旋，右旋，上旋，下旋，看原理的时候就已经晕晕乎乎的了，再看源码，发现比原理还复杂，心理就想，这东西是不是就是为了让我挂科给学校交重修费来拯救学校财政的东西啊？！。。
ArrayList、LinkedList以及SkipList的特性与比较
weixin_44844639的博客
07-31 314
ArrayList 当我们在代码中创建一个Array时，计算机实际上会在内存中开辟一块连续的地址，每个地址都可以直接访问，访问任意一个元素的时间复杂度都是相同的，也就是O(1)。但是如果我们要增加或者删除元素时，因为地址连续的缘故，就需要做比较多的事情了。 假设有个数组长度为10，现在要插入一个元素下标为4，那么则需要将原来index>=4的所有元素都向后移一位，将index=4的地址空间让出来给新增的元素，这样的操作导致时间复杂度上升为O(n)，删除操作也同理。 源码分析 /**
Go 语言中实现SkipList实现跳表.pdf
02-11
跳表（Skip List）是一种高效的有序数据结构，它在Go语言中的实现可以帮助我们高效地进行插入、查询和删除操作。跳表通过在每个节点中存储多个指针，从而创建多层索引，使得查找速度得到显著提升。在Go语言中实现...
面向P2P存储的分布式认证跳表.pdf
08-10
【分布式认证跳表(Distributed Authenticated Skip List, DASL)】 在P2P(Peer-to-Peer)存储系统中，数据的安全性和认证是非常重要的问题。传统的认证数据结构方案可能无法很好地适应P2P环境的特性，如动态性、...
线段跳表——跳表的一个拓展.pdf
01-12
### 线段跳表——跳表的一个拓展 #### 概述 本文主要探讨了一种新的数据结构——线段跳表（Segment Skip Lists, SSL），它是跳表的一种扩展形式。跳表是由William Pugh在1987年提出的，旨在提供一种简单高效的方式...
structure 跳表 vs 红黑树.zip
05-12
structure 跳表 vs 红黑树，对比了两种数据结构的优劣 跳表（Skip List）是一种基于并行链表的数据结构，类似于平衡树，用于在有序的序列中快速查找一个元素。它通过在链表上方增加多级索引，以实现快速查找的目的。...
线段跳表——跳表的一个拓展.ppt
09-17
**线段跳表**是跳表的一种扩展形式，它结合了跳表的高效查询和线段树的数据结构特性，能够支持区间信息的高效维护。跳表本身是一种随机化的数据结构，用于快速查找有序序列中的元素，它通过多层链表实现，每层链表...
Redis和Kafka都用到的SkipList你了解吗？（面试题）
qianshanding0708的博客
03-17 939
跳表被广泛地运用到了各种缓存地实现当中，它的主要优点，就是可以跟红黑树、AVL等平衡树一样，做到比较稳定地插入、查询与删除。理论插入查询删除的算法时间复...
跳表（skip list)的c++实现
fangeqin的博客
12-08 918
首先声明，是转摘别人的代码，本人稍作更改。在microsoft visual studio comunity 2017环境下测试通过。要理解跳表是如何实现的，看懂这个图很重要（摘自维基百科）   A schematic picture of the skip list data structure. Each box with an arrow represents a pointer a...
【数据结构与算法】什么是跳表？通俗易懂来理解跳表
Mind_programmonkey的博客
04-04 1672
跳表 背景 一个有序链表搜索、添加、删除丶平均时间复杂度是多少？ O(n) 那么我们能否利用向数组二分搜索优化有序链表，使其搜索、添加、删除的平均时间复杂度降低至O(logn)? 但很明显的是链表没有像数组那样的高效随机访问(O(1)时间复杂度)，所以不能像有序数组那样直接进行二分搜索优化 那么有没有其他办法让有序链表搜索、添加、删除的平均时间复杂度降低至O(logn)? 答案是使用跳表(SkipList) 跳表(SkipList) 跳表，又叫做跳跃表，在有序链表的基础上增加了“跳跃”的功能； 由Will
什么是跳表 skiplist ?
qq_27198345的博客
09-19 923
什么是跳表 skiplist ? 文章目录什么是跳表 skiplist ?特性实现结构查找插入删除完整代码参考 跳表可以快速地查找、插入、删除。据说可以替代红黑树。Redis中的有序集合就是用调表来实现的。 调表结合了链表和二分查找的思想； 由原始链表和一些通过”跳跃“生成的链表组成； 第0层是原始链表，越上层”跳跃“的越高，元素越少； 上层链表是下层链表的子序列； 查找时从上到下，不断缩小搜索范围。 特性 调表有很多层，如果只看0层的话，就是一个有序链表。那么其他层呢？ 链表查询的时间复杂度为O(n)
关于跳跃表的一点理解
Ryanqy的专栏
12-05 2962
通过前面的总结，我们知道红黑树是一种存在于内存中，可以保证在最坏的情况下，对红黑树进行例如search，insert，以及delete等基本的动态集合操作的时间复杂度为O(lg n)。但是显而易见，红黑树实现起来比较复杂，尤其是对红黑树进行insert和delete操作。并且在红黑树中进行范围查询时需要对红黑树进行中序遍历，这也是比较复杂的操作。那有没有一种能确保对动态集合search，inser...
跳跃表-原理及Java实现
weixin_33949359的博客
04-25 1771
跳跃表-原理及Java实现 引言： 上周现场面试阿里巴巴研发工程师终面，被问到如何让链表的元素查询接近线性时间。笔者苦思良久，缴械投降。面试官告知回去可以看一下跳跃表，遂出此文。 跳跃表的引入 我们知道，普通单链表查询一个元素的时间复杂度为O(n)，即使该单链表是有序的，我们也不能通过2分的方式缩减时间复杂度。 如上图，我们要查询元素为55的...
跳表（skiplist）的理解
热门推荐
DEMI的博客
07-27 3万+
听到跳表（skiplist）这个名字，既然是list，那么应该跟链表有关。 跳表是有序链表，但是我们知道,即使对于排过序的链表,我们对于查找还是需要进行通过链表的指针进行遍历的,时间复杂度很高依然是O(n),这个显然是不能接受的。是否可以像数组那样,通过二分法进行查找呢,但是由于在内存中的存储的不确定性,不能这做。 但是我们可以结合二分法的思想，没错，跳表就是链表与二分法的结合。 1.链表...
Java-网络
最新发布
2301_81543552的博客
09-14 717
Java中的网络编程主要涉及使用Socket类进行网络通信，以及理解各种网络协议。以下是一些关键概念和示例代码，帮助您入门。
自动生成不重复的订单id
ClaireCheney的博客
09-13 305
【代码】自动生成不重复的订单id。
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
发出的红包

打赏作者

axihaihai

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值