跳表 java实现

已于 2022-08-05 19:55:23 修改
阅读量715 收藏 1
点赞数
文章标签： java 数据结构 链表
于 2022-08-05 19:08:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45626529/article/details/126183980
版权

跳表结点类的定义

        /*  定义链表结点  */
        public class SkipNode { 
            public int element;
            public SkipNode next = null;
            //public SkipNode pre = null;
            public SkipNode down = null;
            //public SkipNode up = null;

            public SkipNode( int e ) {
                this.element = e;
            }

            public SkipNode(SkipNode n) {
                this.element = n.element;
            }

        }

跳表中的成员变量

  1. 左上角第一个结点，这里不存储元素，设置值为-1
  2. 索引层数（不包括原始链表，初始为0）
  3. 原始链表的元素数量
  4. 随机数
	    public SkipNode first = new SkipNode( -1 ); // 跳表左上角第一个结点，不存储元素，值设置为-1
        int usedlevel = 0; // 跳表的索引层数
        int size = 0;  // 原始链表中的元素数量
        Random r = new Random(); // 随机数

在跳表中查找元素

遍历跳表，找不到则返回null，思路类似二分查找，时间复杂度O(logn)

        /*查找结点
            输入：key
            返回值：存在时返回最底层对应节点，不存在时返回null
         */
        public SkipNode find(int key) {
            SkipNode p = first;
            while (p != null && p.down != null) {
                if (p.next != null && key >= p.next.element) {
                    p = p.next;    // 比右边大或相等时向右
                } else if (p.next == null || key < p.next.element) {
                    p = p.down;   // 否则向下
                }
            }
            while (p.next != null && key >= p.next.element ) {    // 到达底层后右边可能还有元素
                p = p.next;
            }
            if( p.element != -1 && key == p.element) return p;
            return null;
        }

在跳表中插入元素

由于每增加一个新元素都重新构造链表结构的代价太大，这里采取的是“概率”的思路，即既然标准跳表每一层索引的大小都是其上一层索引大小的二分之一，那么下层索引的每个元素也出现在其上层索引中的概率（即元素向上爬升的概率）也是二分之一。所以理论上，只要构造跳表时，每插入一个元素，都按照这个几率计算这个元素爬升的索引层数，那么当元素数量足够多时，就能构造出标准跳表。
具体插入步骤如下：

  1. 用随机数生成需要爬升的索引数量
  2. 构造完索引后，从最上层索引开始插入元素，对每一层，先在该层插入元素，而后将该层插入的结点与上一层插入的结点相连
    时间复杂度为O(logn)
        /*  插入    */

        /*在链表中插入结点
            输入：key
            返回值：插入的结点
        */
        public SkipNode insert( int key ) {
            if( find(key) != null ) return null;  // 节点已存在不插入
            SkipNode node = new SkipNode( key );
            int level = getLevel();  // 随机数看新插入值是否建立索引，每层索引有1/2机会被建立
            if ( level > usedlevel ) addlevel(level - usedlevel); // 索引不够用时建立新索引
            SkipNode p = first;
            while (usedlevel - level > 0) {
                p = p.down;
                level++;
            }  // 获得最高更新索引层的头结点
            SkipNode oldnode = null;
            while (p != null) {  // 更新索引及结点
                while (p.next != null && p.next.element < key) {//往右搜索
                    p = p.next;
                }
                node.next = p.next;
                p.next = node;   //这一层
                if (oldnode != null) oldnode.down = node;  //上一层
                oldnode = node; // 下一层
                if (p.down != null) node = new SkipNode(node);
                p = p.down;
            }
            size++;//跳表中的元素数量加一
            return node;
        }




        /*增加索引层数
              输入：x，要增加的索引层数
              返回值：无
        */
        public void addlevel(int x) {
            for (int i = 0; i < x; i++) {  // 每层建立一个头结点
                SkipNode newfirst = new SkipNode(-1);
                newfirst.next = null;
                newfirst.down = first;
                first = newfirst;
            }
            usedlevel = x + usedlevel;
        }

        /*获得要爬升的索引层数
              输入：无
              返回值：要爬升的索引层数
        */
        int getLevel() {  // 随机获得爬升索引层
            int level = 0;
            for (int i = 0; i <= usedlevel; i++) { // 每层有1/2几率爬升，这样生成的表，数据越多越接近标准跳表
                if (r.nextInt(2) == 1) level++;
                else break;
            }
            //System.out.println(level);
            return level;
        }

在跳表中删除元素

  1. 寻找指定结点在最高层索引上的前置结点
  2. 从该层开始向下，在每层索引及原始链表上删除对应元素
  3. 删除空索引
    查找过程依然类似二分法，时间复杂度O(logn)
        /*            删除            */

        /* 寻找指定结点（若存在）出现在最高层索引的前置结点
            输入：key
            返回值：指定结点在最高层索引的前置结点
         */
        private SkipNode findPreNode(int key) {
            SkipNode p = first;
            while (p != null && p.down != null) {
                if (p.next != null && key > p.next.element) {
                    p = p.next;    // 比右边大时向右
                } else if (p.next != null && key == p.next.element) {
                    return p;    // 与右边相等时返回自身
                } else if (p.next == null || key < p.next.element) {
                    p = p.down;   // 否则向下
                }
            }
            while (p.next != null) {    // 到达底层后右边可能还有元素
                if (key == p.next.element) {
                    //System.out.println(p.element.value);
                    return p;
                }
                p = p.next;
            }
            return null; // 无前置结点
        }

        /* 删除指定结点及相应索引
            输入：key
            返回值：value 删除结点值
         */
        public int remove(int key) {
            if( first.next == null ) return -1; // 链表为空，返回-1
            SkipNode p = findPreNode(key);//找到待删除元素的最上层的前一个节点
            if (p == null) {  // 结点不存在
                return -1;
            }
            int value = p.next.element; // 记录待删除元素
            while (p != null && p.next != null ) { //找到每层待删除元素的前一个节点，并在该层删除元素
                p.next = p.next.next;
                p = p.down;//往下遍历，直到最底下一层
                while (p != null && p.next.element != key) {
                    p = p.next;
                }
            }
            // 删除仅剩头结点的索引（下面称为空索引）
            p = first;
            int newlevel = usedlevel;  // 计算索引层数减少量
            while (p.down != null && p.next == null) {  // 删除连续空索引
                p = p.down;
                newlevel--;
            }
            first = p;
            usedlevel = newlevel;
            size--;
            return value;
        }

展示跳表中元素

        /*展示跳表中元素
           输入：无
           返回值：无
           输出：跳表中元素
          */
        public void show( ) {
            SkipNode p = first;
            while( p != null ) {
                SkipNode p1 = p;
                while( p1 != null ) {
                    System.out.print( p1.element );
                    System.out.print( " " );
                    p1 = p1.next;
                }
                p = p.down;
                System.out.println();
            }
        }

测试

测试代码：

        public static void main(String[] args) { // Test
            Skiplist l = new Skiplist();
            l.insert(1);
            l.insert(2);
            l.insert(4);
            l.insert(6);
            l.insert(5);
            l.insert(5);
            l.insert(0);
            //System.out.println(l.find(5).element);
            l.show();
            l.remove(5);
            l.remove(1);
            l.remove(4);
            l.show();
        }

输出：

-1 0 6 
-1 0 2 6 
-1 0 1 2 4 5 6 
-1 0 6 
-1 0 2 6 
-1 0 2 6

整体代码

import java.util.Random;

public class Skiplist {
        public SkipNode first = new SkipNode( -1 ); // 跳表左上角第一个结点
        int usedlevel = 0; // 跳表的索引层数
        int size = 0;  // 原始链表中的元素数量
        Random r = new Random(); // 随机数

        public static void main(String[] args) { // Test
            Skiplist l = new Skiplist();
            l.insert(1);
            l.insert(2);
            l.insert(4);
            l.insert(6);
            l.insert(5);
            l.insert(5);
            l.insert(0);
            //System.out.println(l.find(5).element);
            l.show();
            l.remove(5);
            l.remove(1);
            l.remove(4);
            l.show();
        }

        /*获得原数据链表头
            输入：无
            返回值：原数据链表头结点node
         */
        public SkipNode getFirst( ) {
            SkipNode p = first;
            while( p.down != null ) p = p.down;
            return p;
        }


        /*查找结点
            输入：key
            返回值：存在时返回最底层对应节点，不存在时返回null
         */
        public SkipNode find(int key) {
            SkipNode p = first;
            while (p != null && p.down != null) {
                if (p.next != null && key >= p.next.element) {
                    p = p.next;    // 比右边大或相等时向右
                } else if (p.next == null || key < p.next.element) {
                    p = p.down;   // 否则向下
                }
            }
            while (p.next != null && key >= p.next.element ) {    // 到达底层后右边可能还有元素
                p = p.next;
            }
            if( p.element != -1 && key == p.element) return p;
            return null;
        }

        /*            删除            */

        /* 寻找指定结点（若存在）出现在最高层索引的前置结点
            输入：key
            返回值：指定结点在最高层索引的前置结点
         */
        private SkipNode findPreNode(int key) {
            SkipNode p = first;
            while (p != null && p.down != null) {
                if (p.next != null && key > p.next.element) {
                    p = p.next;    // 比右边大时向右
                } else if (p.next != null && key == p.next.element) {
                    return p;    // 与右边相等时返回自身
                } else if (p.next == null || key < p.next.element) {
                    p = p.down;   // 否则向下
                }
            }
            while (p.next != null) {    // 到达底层后右边可能还有元素
                if (key == p.next.element) {
                    //System.out.println(p.element.value);
                    return p;
                }
                p = p.next;
            }
            return null; // 无前置结点
        }

        /* 删除指定结点及相应索引
            输入：key
            返回值：value 删除结点值
         */
        public int remove(int key) {
            if( first.next == null ) return -1; // 链表为空，返回-1
            SkipNode p = findPreNode(key);//找到待删除元素的最上层的前一个节点
            if (p == null) {  // 结点不存在
                return -1;
            }
            int value = p.next.element; // 记录待删除元素
            while (p != null && p.next != null ) {
                p.next = p.next.next;
                p = p.down;//往下遍历，直到最底下一层
                while (p != null && p.next.element != key) {
                    p = p.next;
                }//找到每层待删除元素的前一个节点
            }
            // 删除仅剩头结点的索引（下面称为空索引）
            p = first;
            int newlevel = usedlevel;  // 计算索引层数减少量
            while (p.down != null && p.next == null) {  // 删除连续空索引
                p = p.down;
                newlevel--;
            }
            first = p;
            usedlevel = newlevel;
            size--;
            return value;
        }




        /*  插入    */

        /*在链表中插入结点
            输入：key
            返回值：插入的结点
        */
        public SkipNode insert( int key ) {
            if( find(key) != null ) return null;  // 节点已存在不插入
            SkipNode node = new SkipNode( key );
            int level = getLevel();  // 随机数看新插入值是否建立索引，每层索引有1/2机会被建立
            if ( level > usedlevel ) addlevel(level - usedlevel); // 索引不够用时建立新索引
            SkipNode p = first;
            while (usedlevel - level > 0) {
                p = p.down;
                level++;
            }  // 获得最高更新索引层的头结点
            SkipNode oldnode = null;
            while (p != null) {  // 更新索引及结点
                while (p.next != null && p.next.element < key) {//往右搜索
                    p = p.next;
                }
                node.next = p.next;
                p.next = node;   //这一层
                if (oldnode != null) oldnode.down = node;  //上一层
                oldnode = node; // 下一层
                if (p.down != null) node = new SkipNode(node);
                p = p.down;
            }
            size++;//跳表中的元素数量加一
            return node;
        }




        /*增加索引层数
              输入：x，要增加的索引层数
              返回值：无
        */
        public void addlevel(int x) {
            for (int i = 0; i < x; i++) {  // 每层建立一个头结点
                SkipNode newfirst = new SkipNode(-1);
                newfirst.next = null;
                newfirst.down = first;
                first = newfirst;
            }
            usedlevel = x + usedlevel;
        }

        /*获得要爬升的索引层数
              输入：无
              返回值：要爬升的索引层数
        */
        int getLevel() {  // 随机获得爬升索引层
            int level = 0;
            for (int i = 0; i <= usedlevel; i++) { // 每层有1/2几率爬升，这样生成的表，数据越多越接近标准跳表
                if (r.nextInt(2) == 1) level++;
                else break;
            }
            //System.out.println(level);
            return level;
        }

        /*展示跳表中元素
           输入：无
           返回值：无
           输出：跳表中元素
          */
        public void show( ) {
            SkipNode p = first;
            while( p != null ) {
                SkipNode p1 = p;
                while( p1 != null ) {
                    System.out.print( p1.element );
                    System.out.print( " " );
                    p1 = p1.next;
                }
                p = p.down;
                System.out.println();
            }
        }

        /*  定义链表结点  */
        public class SkipNode { 
            public int element;
            public SkipNode next = null;
            //public SkipNode pre = null;
            public SkipNode down = null;
            //public SkipNode up = null;

            public SkipNode( int e ) {
                this.element = e;
            }

            public SkipNode(SkipNode n) {
                this.element = n.element;
            }

        }

}
爱吃甜粽子
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
java实现跳表
GAVIN12365的博客
10-09 1011
1.跳表的定义 跳表(SkipList)：增加了向前指针的链表叫做指针。跳表全称叫做跳跃表，简称跳表。跳表是一个随机化的数据结构，实质是一种可以进行二分查找的有序链表。跳表在原有的有序链表上增加了多级索引，通过索引来实现快速查询。跳表不仅能提高搜索性能，同时也可以提高插入和删除操作的性能。 跳表是一个随机化的数据结构，可以被看做二叉树的一个变种，它在性能上和红黑树、AVL树不相上下，但是跳表的原理非常简单，目前在Redis和LevelDB中都有用到 2.跳表的详解 对于一个单链表来说，即使链表中的数据是有
跳表(跳跃表，skipList)总结-java版
许诗宇的博客
05-05 924
目录 为什么要有跳表 搜索：从链表到跳表 跳表简介 跳表的实现 节点类 跳表的结构 搜索 插入 删除 打印整个跳表 测试 跳表整个java代码 跳表复杂度 时间 空间 高度 为什么要有跳表 目前经常使用的平衡数据结构有：B树，红黑树，AVL树，Splay Tree, Treep等。 想象一下，给你一张草稿纸，一只笔，一个编辑器，你能立即实现一颗红黑树，或...
跳表详解以及Java实现
最新发布
qq_44957574的博客
04-25 985
redis zset原理——跳表数据结构详解，使用Java代码实现。
Java - 跳表在ConcurrentSkipListMap的运用及其原理
Zong_0915的博客
08-03 1662
我们知道跳表是Redis中的一个重要数据结构，其中Sorted Set这种集合底层就用到了跳表。后来我才知道，原来Java当中也有着跳表的集合实现。而我对此却非常陌生。因此趁此机会学习下。假设我们原跳表如下：上面的步骤分为4个：第一步：寻找插入的位置，假设我们要插入的元素是13。示意图如下：构建Node节点，并在跳表的最底层执行插入：经过计算（随机），计算出新节点所需要插入的层级为3：那么在指定层开始构建索引：将新的索引插入到各个层级链表当中：计算出插入节点的Key。......
Java实现跳表
solo_jm的博客
05-28 654
简介 链表是一种基本的数据结构，而跳表是一种特殊的链表。跳表的每一个节点都有四个指针，上、下、左、右。当进行数据查询时，可以从最顶层开始查找，并可以向下移动，从而提高查询效率。 基本结构 查找数的基本步骤 从最左上角的head开始，假如当前数等于目标数，直接返回；假如当前数右指针的数小于目标数，向右移动；假如当前数右指针的数大于目标数，向下移动。 当down指针为null时，没有找到。 Java节点结构 private class Node<T> { //score不能为负数
Java实现跳跃表
大雄送你走的博客
05-02 2485
Java实现跳跃表
java跳表实现
11-06
总之，Java实现跳表涉及到了链表操作、随机化策略以及动态调整数据结构的高度，理解这些核心概念对于编写高效且稳定的跳表实现至关重要。通过实践，我们可以深入理解这一数据结构，并将其应用于各种实际问题中。
跳表（skiplist）Java实现
11-27
简单得实现跳表相关功能 SkipList<Integer> skipList = new SkipList(maxLevel); 提供insert和seach接口 删除接口可做类似操作
JCrux:关键的java实现
07-06
JCrux作为Java实现的CRUX框架，充分考虑了Java平台的优势，如跨平台兼容性、内存管理以及丰富的库支持。它可能采用了面向对象的设计原则，提供了易于理解和使用的API接口，使得开发人员可以方便地集成到自己的项目中...
algorithms:java的一些算法实现
06-12
: 实现java.util.Set接口，使用位存储的集合。 : 字典树，用于高效存储、查找字符串单词。 : 能够获取大顶堆、小顶堆以及TopK过滤器。 : 给定一个序列，求按字典序的下一个排列。 : 洗牌算法，即把一个列表随机打乱...
Java实现跳跃表(skiplist)的简单实例
08-29
主要介绍了Java编程中跳跃表的概念和实现原理，并简要叙述了它的结构，具有一定参考价值，需要的朋友可以了解下。
跳表的简单原理及Java实现
liinux-Talk is cheap,show me the code.
01-01 646
跳表 跳表是一种简单，高效的快速查找结构，实现起来成本最小，并且速度也很快，只需要一个图就可以完美的解释跳跃表的样子，而且对于编程人员来说，要实现一个跳跃表看着图就能实现，以下就是跳跃表的结构图，没有什么难度。 跳跃表有几个特点，这种特点对于某些类型的查询是有相当的效率提升的。 它是有序的，跳跃表的特点就是有序的，所以对于一些有序类型的数据，比如整数，日期这种，用跳跃表可以进行...
java 实现跳跃表
Sun_Ru的博客
07-15 3736
跳跃链表是一种随机化数据结构，基于并联的链表，其效率可比拟于二叉查找树(对于大多数操作需要O(log n)平均时间)，并且对并发算法友好。 基本上，跳跃列表是对有序的链表增加上附加的前进链接，增加是以随机化的方式进行的，所以在列表中的查找可以快速的跳过部分列表(因此得名)。所有操作都以对数随机化的时间进行。 实现原理： 跳跃表的结构是：假如底层有10个节点， 那么底层的上一层理论上就有5个节
【算法导论33】跳跃表（Skip list）原理与java实现
BrilliantEagle的专栏
08-14 9418
WiKiSkip list是一个用于有序元素序列快速搜索的数据结构，由美国计算机科学家William Pugh发明于1989年。它的效率和红黑树以及 AVL 树不相上下，但实现起来比较容易。作者William Pugh是这样介绍Skip list的： Skip lists are a probabilistic data structure that seem likely to supplant
跳跃表java实现
weixin_59287292的博客
01-21 795
跳表java实现
跳跃表原理与Java实现
fly_miqiqi的博客
02-18 302
文章目录跳跃表总结问题优化思路调表的搜索调表的插入跳跃表的性质对比实现 跳跃表总结 解决了有序链表结构查找特定值困难的问题，查找特定值的时间复杂度为O(logn)，他是一种可以代替平衡树的数据结构 问题 假如我们要用某种数据结构来维护一组有序的int型数据的集合，并且希望这个数据结构在插入、删除、查找等操作上能够尽可能着快速，那么，你会用什么样的数据结构呢？ 数组： 采用二分法可以在0(logn)...
跳跃表-原理及Java实现
weixin_33949359的博客
04-25 1756
跳跃表-原理及Java实现 引言： 上周现场面试阿里巴巴研发工程师终面，被问到如何让链表的元素查询接近线性时间。笔者苦思良久，缴械投降。面试官告知回去可以看一下跳跃表，遂出此文。 跳跃表的引入 我们知道，普通单链表查询一个元素的时间复杂度为O(n)，即使该单链表是有序的，我们也不能通过2分的方式缩减时间复杂度。 如上图，我们要查询元素为55的...
用Java帮我实现一个跳表
03-07
好的，我可以帮您实现一个跳表。跳表是一种基于链表的数据结构，可以快速地进行查找、插入和删除操作。在跳表中，每个节点都有多个指针，可以跳过一些节点，从而加快查找的速度。您需要先定义一个节点类，然后实现跳表的插入、删除和查找操作。如果您需要更详细的实现方法，可以参考一些开源的跳表实现。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值