Java实现跳跃表

已于 2022-05-04 21:26:27 修改
阅读量2.4k 收藏 4
点赞数 1
文章标签： java 开发语言
于 2022-05-02 23:45:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BigBear_2020/article/details/124548992
版权
目录
概要

本文提供可复用的跳跃表（下称 SkipList）实现，所用语言为 Java，使用场景为单机单线程。

跳跃表的特点为：数据有序、不可重复。查询的时间复杂度为 O(logN)。

读者可以从 源码 直接复制使用，或者从 gitee 下载使用。

返回目录

运行性能

由下表可知，SkipList 的插入性能是 TreeSet 的 56%~70%。

TreeSet 是 Java Collection 集合中的一员，该数据结构的特点是：数据有序、不可重复，查询的时间复杂度为 O(logN)。

为了测试 SkipList 的运行性能，将其与 TreeSet 进行比较，统计了两者连续插入随机数，所耗费的时间。读者可以从 性能测试 获取测试代码。

数据量分别为 10万条、100万条、1000万条，数据提前准备，不计入时间。

每个数据量下，重复测试 10 次，得到 10 个运行时间，去除最大值和最小值后，取平均值。

数据量/万条101001000
SkipList 平均运行时间/毫秒58.71389.021726.5
TreeSet 平均运行时间/毫秒34.0783.315336.5
运行时间比 SkipList / TreeSet1.731.771.42
性能比（运行时间比值的倒数）58%56%70%

返回目录

源码

跳跃表抽象类

声明需要实现的方法。

import java.util.Collection;

public abstract class AbstractSkipList<E> {

    public abstract int size();

    public abstract boolean isEmpty();

    public abstract boolean contains(E e);

    public abstract boolean add(E e);

    public abstract boolean remove(E e);

    public abstract void clear();

    public abstract boolean addAll(Collection<? extends E> c);

    public abstract E first();

    public abstract E last();

}

跳跃表实现类

实现跳跃表。

import java.util.Collection;
import java.util.Comparator;
import java.util.Random;

public class SkipList<E> extends AbstractSkipList<E> {

    private int topLevel = 0;

    private int size = 0;

    private Node<E> head;

    private Random random;

    private final Comparator<? super E> comparator;

    public SkipList() {
        this(null);
    }

    public SkipList(Comparator<? super E> c) {
        head = new Node<>(null, 3);
        this.comparator = c;
    }

    @Override
    public int size() {
        return this.size;
    }

    @Override
    public boolean isEmpty() {
        return this.size == 0;
    }

    @Override
    public boolean contains(E e) {
        return find(e) != null;
    }

    @Override
    public boolean add(E e) {
        if (e == null) {
            throw new NullPointerException();
        }

        int level = randomLevel();
        Node<E> newNode;
        if (level > topLevel) {
            topLevel++;
            resize();
            newNode = new Node<>(e, topLevel);
        } else {
            newNode = new Node<>(e, level);
        }
        Node<E>[] preNodes = getPreNodes(e, newNode.getLevel());
        for (int i = 0; i < preNodes.length; i++) {
            Node<E> pre = preNodes[i];
            newNode.setNextNode(i, pre.getNextNode(i));
            pre.setNextNode(i, newNode);
        }
        size++;
        return true;
    }

    @Override
    public boolean remove(E e) {
        Node<E> del = find(e);
        if (del == null) {
            return false;
        }
        Node<E>[] preNodes = getPreNodes(e, del.getLevel());
        for (int i = 0; i < preNodes.length; i++) {
            Node<E> pre = preNodes[i];
            pre.setNextNode(i, del.getNextNode(i));
            del.setNextNode(i, null);
        }
        while (topLevel > 0) {
            if (head.getNextNode(topLevel) == null) {
                topLevel--;
            } else {
                break;
            }
        }
        size--;
        return true;
    }

    @Override
    public void clear() {
        for (int i = 0; i <= topLevel; i++) {
            head.setNextNode(i, null);
        }
        topLevel = 0;
        size = 0;
    }

    @Override
    public boolean addAll(Collection<? extends E> c) {
        boolean modified = false;
        for (E e : c) {
            if (add(e)) modified = true;
        }
        return modified;
    }

    @Override
    public E first() {
        if (head.getNextNode(0) != null) {
            return head.getNextNode(0).getValue();
        }
        return null;
    }

    @Override
    public E last() {
        Node<E> temp = head;
        for (int i = topLevel; i >= 0; i--) {
            while (temp.getNextNode(i) != null) {
                temp = temp.getNextNode(i);
            }
        }
        return temp.getValue();
    }

    @Override
    public String toString() {
        if (isEmpty()) return "[]";

        StringBuilder b = new StringBuilder();
        b.append('[');

        Node temp = head;
        while (temp.getNextNode(0) != null) {
            b.append(temp.getNextNode(0).getValue());
            temp = temp.getNextNode(0);
            if (temp.getNextNode(0) == null) {
                b.append(']');
                break;
            }
            b.append(", ");
        }
        return b.toString();
    }

    private int randomLevel() {
        if (random == null) {
            random = new Random();
        }
        int level = 0;
        int times = topLevel + 1;
        while (times-- > 0) {
            if (!random.nextBoolean()) {
                break;
            }
            level++;
        }
        return level;
    }

    private Node<E>[] getPreNodes(E e, int level) {
        if (e == null) {
            return null;
        }
        Node<E>[] preNodes = new Node[level + 1];
        Node<E> temp = head;
        Comparator<? super E> cpr = comparator;
        Node<E> next;
        if (cpr != null) {
            for (int i = topLevel; i >= 0; i--) {
                while ((next = temp.getNextNode(i)) != null && cpr.compare(next.getValue(), e) < 0) {
                    temp = next;
                }
                if (i <= level) {
                    preNodes[i] = temp;
                }
            }
        } else {
            for (int i = topLevel; i >= 0; i--) {
                while ((next = temp.getNextNode(i)) != null && ((Comparable<? super E>) next.getValue()).compareTo(e) < 0) {
                    temp = next;
                }
                if (i <= level) {
                    preNodes[i] = temp;
                }
            }
        }
        return preNodes;
    }

    private void resize() {
        if (topLevel > head.getLevel()) {
            Node<E> newHead = new Node(null, topLevel);
            for (int i = 0; i <= head.getLevel(); i++) {
                newHead.setNextNode(i, head.getNextNode(i));
                head.setNextNode(i, null);
            }
            head = newHead;
        }
    }

    private Node<E> find(E e) {
        if (e == null) {
            throw new NullPointerException();
        }
        Node<E> temp = head;
        for (int i = topLevel; i >= 0; i--) {
            if (comparator != null) {
                while (temp.getNextNode(i) != null) {
                    int c = comparator.compare(temp.getNextNode(i).getValue(), e);
                    if (c < 0) {
                        temp = temp.getNextNode(i);
                    } else if (c == 0) {
                        return temp.getNextNode(i);
                    } else {
                        break;
                    }
                }
            } else {
                while (temp.getNextNode(i) != null) {
                    Comparable<? super E> v = (Comparable<? super E>) temp.getNextNode(i).getValue();
                    int c = v.compareTo(e);
                    if (c < 0) {
                        temp = temp.getNextNode(i);
                    } else if (c == 0) {
                        return temp.getNextNode(i);
                    } else {
                        break;
                    }
                }
            }
        }
        return null;
    }

    static final class Node<E> {
        E value;
        int level;
        Node<E>[] nextNode;

        public Node(E value, int level) {
            this.value = value;
            this.level = level;
            this.nextNode = new Node[level + 1];
        }

        public E getValue() {
            return value;
        }

        public void setValue(E value) {
            this.value = value;
        }

        public int getLevel() {
            return level;
        }

        public void setLevel(int level) {
            this.level = level;
        }

        public Node<E> getNextNode(int level) {
            return this.nextNode[level];
        }

        public void setNextNode(int level, Node<E> node) {
            this.nextNode[level] = node;
        }

    }

}
性能测试
import org.junit.Test;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Random;
import java.util.TreeSet;

public class performanceTest {

    public Random random = new Random();
    public final int size = 1000_0000;
    public final int time = 10;

    @Test
    public void SkipListTest() {
        long[] res = new long[time];
        long begin, end;
        for (int i = 0; i < time; i++) {
            int[] nums = getRandomArray(size);
            SkipList<Integer> skipList = new SkipList<>();
            begin = System.currentTimeMillis();
            for (Integer num : nums) {
                skipList.add(num);
            }
            end = System.currentTimeMillis();
            res[i] = end - begin;
        }
        Arrays.sort(res);
        long sum = 0;
        for (int i = 1; i < time - 1; i++) {
            sum += res[i];
        }
        double average = sum / 6.0;
        System.out.println("max: " + res[res.length -1]);
        System.out.println("min: " + res[0]);
        System.out.println("average: " + average);
        System.out.println(Arrays.toString(res));
    }

    @Test
    public void TreeSetTest() {
        long[] res = new long[time];
        long begin, end;
        for (int i = 0; i < time; i++) {
            int[] nums = getRandomArray(size);
            TreeSet<Integer> treeSet = new TreeSet<>();
            begin = System.currentTimeMillis();
            for (Integer num : nums) {
                treeSet.add(num);
            }
            end = System.currentTimeMillis();
            res[i] = end - begin;
        }
        Arrays.sort(res);
        long sum = 0;
        for (int i = 1; i < time - 1; i++) {
            sum += res[i];
        }
        double average = sum / 6.0;
        System.out.println("max: " + res[res.length -1]);
        System.out.println("min: " + res[0]);
        System.out.println("average: " + average);
        System.out.println(Arrays.toString(res));
    }

    public int[] getRandomArray(int size) {
        int[] nums = new int[size];
        for (int i = 0; i < size; i++) {
            nums[i] = random.nextInt();
        }
        return nums;
    }

    public List<Integer> getRandomList(int size) {
        List<Integer> list = new ArrayList<>(size);
        for (int i = 0; i < size; i++) {
            list.add(random.nextInt());
        }
        return list;
    }
}

返回目录

单元测试

import org.junit.Assert;
import org.junit.Test;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.TreeSet;

public class SkipListImplTest{

    public final Random random = new Random();

    @Test
    public void sizeTest() {
        int size = 10000;
        List<Integer> nums = getRandomList(size);

        SkipList<Integer> skipList = new SkipList<>();
        TreeSet<Integer> treeSet = new TreeSet<>();
        skipList.addAll(nums);
        treeSet.addAll(nums);
        Assert.assertEquals(treeSet.size(), skipList.size());
    }

    @Test
    public void isEmptyTest() {
        SkipList<Integer> skipList = new SkipList<>();
        Assert.assertTrue(skipList.isEmpty());
        skipList.add(1);
        Assert.assertFalse(skipList.isEmpty());
        skipList.remove(1);
        Assert.assertTrue(skipList.isEmpty());
    }

    @Test
    public void containsTest() {
        SkipList<Integer> skipList = new SkipList<>();
        int[] nums = new int[]{-99, -56, 1, 78, 265, Integer.MAX_VALUE};
        for (Integer num : nums) {
            skipList.add(num);
        }
        Assert.assertFalse(skipList.contains(Integer.MIN_VALUE));
        Assert.assertFalse(skipList.contains(-987867));
        Assert.assertFalse(skipList.contains(-98));
        Assert.assertFalse(skipList.contains(0));
        Assert.assertFalse(skipList.contains(264));
        Assert.assertFalse(skipList.contains(578676786));

        Assert.assertTrue(skipList.contains(-99));
        Assert.assertTrue(skipList.contains(-56));
        Assert.assertTrue(skipList.contains(1));
        Assert.assertTrue(skipList.contains(78));
        Assert.assertTrue(skipList.contains(265));
        Assert.assertTrue(skipList.contains(Integer.MAX_VALUE));
    }

    @Test
    public void addTest() {
        int size = 10000;
        int[] nums = getRandomArray(size);
        SkipList<Integer> skipList = new SkipList<>();
        TreeSet<Integer> set = new TreeSet<>();
        for (int num : nums) {
            skipList.add(num);
            set.add(num);
        }
        Assert.assertEquals(set.toString(), skipList.toString());
    }

    @Test
    public void removeTest() {
        int size = 10000;
        List<Integer> nums = getRandomList(size);
        SkipList<Integer> skipList = new SkipList<>();
        skipList.addAll(nums);
        for (Integer num : nums) {
            skipList.remove(num);
        }
        Assert.assertTrue(skipList.isEmpty());
    }

    @Test
    public void clearTest() {
        int size = 10000;
        List<Integer> nums = getRandomList(size);
        SkipList<Integer> skipList = new SkipList<>();
        skipList.addAll(nums);
        Assert.assertFalse(skipList.isEmpty());
        skipList.clear();
        Assert.assertTrue(skipList.isEmpty());
    }

    @Test
    public void addAllTest() {
        int size = 10000;
        List<Integer> nums = getRandomList(size);
        SkipList<Integer> skipList = new SkipList<>();
        TreeSet<Integer> set = new TreeSet<>();
        skipList.addAll(nums);
        set.addAll(nums);
        Assert.assertEquals(set.toString(), skipList.toString());
    }

    @Test
    public void firstTest() {
        int size = 1000;
        List<Integer> nums = getRandomList(size);
        SkipList<Integer> skipList = new SkipList<>();
        TreeSet<Integer> set = new TreeSet<>();
        skipList.addAll(nums);
        set.addAll(nums);
        Assert.assertEquals(set.first(), skipList.first());
    }

    @Test
    public void lastTest() {
        int size = 1000;
        List<Integer> nums = getRandomList(size);
        SkipList<Integer> skipList = new SkipList<>();
        TreeSet<Integer> set = new TreeSet<>();
        skipList.addAll(nums);
        set.addAll(nums);
        Assert.assertEquals(set.last(), skipList.last());
    }

    public int[] getRandomArray(int size) {
        int[] nums = new int[size];
        for (int i = 0; i < size; i++) {
            nums[i] = random.nextInt();
        }
        return nums;
    }

    public List<Integer> getRandomList(int size) {
        List<Integer> list = new ArrayList<>(size);
        for (int i = 0; i < size; i++) {
            list.add(random.nextInt());
        }
        return list;
    }
}

返回目录

致谢

感谢 ExRoc 的指导与反馈。

返回目录

参考

《C++ 实现BigInteger 类》

《以后有面试官问你「跳跃表」，你就把这篇文章扔给他》

返回目录

陈新雄
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java实现跳跃表(skiplist)的简单实例
08-29
主要介绍了Java编程中跳跃表的概念和实现原理，并简要叙述了它的结构，具有一定参考价值，需要的朋友可以了解下。
数据结构-跳表（基于JAVA的实现）
Wengy的博客
12-19 998
数据结构-跳表（基于JAVA的实现）跳表的原理与特点跳跃表应用场景分析跳跃表的JAVA应用使用样例源码分析ConcurrentSkipListMapConcurrentSkipListSet 跳表的原理与特点 跳表实质就是一种可以进行二分查找的有序链表，跳表在原有的有序链表上面增加了多级索引，通过索引来实现快速查找。解决了链表查询慢的问题，但会占有更多的内存，是一种以空间换内存的数据结构。 查询...
什么是跳表，Java如何实现跳表？
weixin_74783792的博客
01-28 1016
如图：每个链表存在一个指向下一节点的指针，如果我们要对其任一节点进行增删改，都需要先使用迭代器进行查询，找到指定节点进行修改，复杂度较高。
跳跃表的原理和实现（Java）
最新发布
chuixue24的博客
02-21 63
/ data// links可以看到节点模型主要分为2个部分。data 部分包含具体的存储数据，这里为了不引入其他杂乱的问题，使用 Integer 作为 key 的类型，Object 作为value 的类型。links 部分包含4个指针，分别是 up、down、left、right，单从名字上就能够明白它们的作用。
java实现跳表
GAVIN12365的博客
10-09 995
1.跳表的定义 跳表(SkipList)：增加了向前指针的链表叫做指针。跳表全称叫做跳跃表，简称跳表。跳表是一个随机化的数据结构，实质是一种可以进行二分查找的有序链表。跳表在原有的有序链表上增加了多级索引，通过索引来实现快速查询。跳表不仅能提高搜索性能，同时也可以提高插入和删除操作的性能。 跳表是一个随机化的数据结构，可以被看做二叉树的一个变种，它在性能上和红黑树、AVL树不相上下，但是跳表的原理非常简单，目前在Redis和LevelDB中都有用到 2.跳表的详解 对于一个单链表来说，即使链表中的数据是有
Java 跳跃表的实现
qq_37312720的博客
03-08 291
目录 跳跃表的引入 容易实现的跳跃表 Java实现 我们知道，普通单链表查询一个元素的时间复杂度为O(n)，即使该单链表是有序的，我们也不能通过2分的方式缩减时间复杂度。 如上图，我们要查询元素为55的结点，必须从头结点，循环遍历到最后一个节点，不算-INF(负无穷)一共查询8次。那么用什么办法能够用更少的次数访问55呢？最直观的，当然是新开辟一条捷径去访问55。 如上图，我们...
跳表及其JAVA实现
u014775579的博客
06-01 1200
跳表（Skip List）是一种基于链表的数据结构，它可以支持快速的查找、插入、删除操作，并且具有较好的平均时间复杂度，可以替代平衡树等复杂数据结构。/**数组存储每层索引的下一个节点。比如下标0表示链表本身，下标1表示第一层索引，依次类推。} }/**maxLevel 索引最大高度currentLevel 当前索引高度head 跳表头节点，从head查起} }i >= 0;} /**
确定性跳跃表java实现
06-26
确定性跳跃表，java语言实现，实现了详细的跳跃表操作和功能
leetcode跳跃-leetcode:LeetCode题记，Java语言
06-30
跳跃 目录 LeetCode 题解 链表 相关代码 # Title 002 ★★☆ 019 ★★☆ 双指针 021 排序链表的合并 023 排序链表的合并 024 ★★☆ 两两交换链表中的节点 递归 086 链表划分 092 ★★☆ 链表逆序 138 复杂的链表的...
java 图形界面小时钟
05-04
3、三线程（如果用一个线程秒针会跳跃多格，也就是还会延迟）。 4、如果运行期间更改系统时间，不会马上改变时钟指针（秒针是1秒钟更新，分针15秒更新，时针两分钟更新），请高手指点怎么优化。 5、指针图片因为...
leetcode分类-JavaStudy:Java学习
06-29
leetcode 分类 Introduction 本项目用于学习java各种知识 记录下学习过程中的demo 目前已经有的功能 Java基础 ...跳跃表的实现 (做了部分优化 代码看起来没有那么复杂) 红黑树的实现 (看了很多篇，这
java hmget 返回nil_java 实现跳表（skiplist）及论文解读
weixin_32795125的博客
02-01 315
什么是跳跃表跳表由William Pugh发明。他在论文 《Skip lists: a probabilistic alternative to balanced trees》中详细介绍了跳表的数据结构和插入删除等操作。跳表是一种可以用来代替平衡树的数据结构，跳表使用概率平衡而不是严格执行的平衡，因此，与等效树的等效算法相比，跳表中插入和删除的算法要简单得多，并且速度要快得多。Skip_list....
跳表在Java中的实现
javaYY_的博客
07-07 1199
跳表是一种数据结构，用于借助连接到元素子序列的链表层次结构来存储元素的排序列表。跳表允许以有效的方式处理项目查找。跳表是一种概率数据结构，这意味着它跳过整个列表中的几个元素，因此称为跳表。我们可以将跳表作为链表的扩展版本。与链表允许插入、删除和搜索元素的方式类似，跳表也允许搜索元素、从列表中删除元素和插入元素。它将包含一个基本列表，其中包含一组元素，这些元素将维护后续元素的链接层次结构。跳表没有特定的语法，但它有一个算法。在研究算法之前，我们需要检查基本跳表操作的类型。让我们看看跳表是如何以算法的方式工作的
跳跃表java实现
weixin_59287292的博客
01-21 791
跳表java实现
跳跃表之java实现
Haonan的博客
01-21 958
跳跃表是一种特殊的单向有序链表，redis中zset在数据量大时就采用了这种数据结构。 添加，删除，查询的时间复杂度都为O(logn) package algorithm.array_linked; import lombok.Data; import java.util.*; /** * @Author: M˚Haonan * @Date: 2022/1/20 10:54 * @Description: 跳表 * 跳跃表是一种特殊的有序链表,利用空间换时间，通过多层索引加快链表的检索速度
跳表 java实现
weixin_45626529的博客
08-05 690
跳表的java实现
JAVA实现跳表
qq_40246487的博客
07-15 180
在这里记录自己查询网上资料后自己实现的JAVA版本跳表的代码，比较简陋 public class SkipList { private Node head, tail; //最左上头结点，最右上尾结点 private Random random = new Random(); //用于生成随机数 private static final double PROMOTE_RATE = 0.5; //结点向上扩展的概率
跳表(java代码实现)
qq_51955445的博客
02-02 876
练手写了一下跳表 一开始自己只看了思路，写了一晚上还是有两个小bug 所以第二次写参考了一下别的博客 跳表的java实现 算是写出了个能用的吧(应该) import java.util.*; /** * @author 20级三班刘宇阳 * @create 2022/2/2 */ /** * 跳表类 * @param <T> 泛型 */ public class SkipList<T>{ /** * 跳表结点 */ private
帮我写一个跳跃表的JAVA实现
05-31
好的，以下是一个简单的跳跃表的 JAVA 实现，供您参考： ```java import java.util.Random; public class SkipList { private static final int MAX_LEVEL = 16; // 最大层数 private int levelCount = 1; // ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值