什么是跳表 skiplist ?

最新推荐文章于 2023-08-08 10:37:32 发布
最新推荐文章于 2023-08-08 10:37:32 发布
阅读量720 收藏 5
点赞数 1
文章标签： 跳表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_27198345/article/details/108675666
版权

什么是跳表 skiplist ?

文章目录


跳表可以快速地查找、插入、删除。据说可以替代红黑树。Redis中的有序集合就是用调表来实现的。

  • 调表结合了链表和二分查找的思想；
  • 由原始链表和一些通过”跳跃“生成的链表组成；
  • 第0层是原始链表，越上层”跳跃“的越高，元素越少；
  • 上层链表是下层链表的子序列；
  • 查找时从上到下，不断缩小搜索范围。

特性

调表有很多层，如果只看0层的话，就是一个有序链表。那么其他层呢？

链表查询的时间复杂度为O(n)
在这里插入图片描述

若果在此基础之上，增加一层”索引“，查找就会快一点点。
之前直接查找单链表，比如查询结点7，要经过6个结点。
在这里插入图片描述
如果加上索引：
在这里插入图片描述

经过4个中间结点，比刚刚在链表中查找快乐一点。

更严谨的结构如下，每一层上的索引都是可以向下走的：
在这里插入图片描述
最左边的是header节点，不存值，上襦中的31，出现在了第0,1,2,3层，其实就是一个结点。不是四个结点（这个要看具体的实现，这里是通过数组实现，可以通过下标访问，也可以通过链式实现）。这些层次信息是通过forwards(ArrayList)保存的。因此可以很快的访问到下一层。

如果元素个数很多的话，通常层数也会相应的增加。比如我们再增加以层：
在这里插入图片描述
再进行上面的查找7的过程的话如下：
在这里插入图片描述
中间只经过了3个结点，比刚刚的查找过程更快乐一点。

这里有必要指出的是，每隔一个结点往上提升一层建立索引只是理想情况，实际上是通过随机层数来实现的。

实现

结构

我们将每个节点及没层上的索引信息封装到一个类中：

private class Node {
    //保存值
    E data;
    //保存了每一层上的节点信息，可能为null
    List<Node> forwards;

    Node(E data) {
        this.data = data;
        forwards = new ArrayList<>();
        //事先把每一层都置为null，虽然空间利用率没那么高，但是简化了实现
        //也可以通过自定义列表(比如B树实现中用到的Vector)来实现，就可以不用下面的操作
        for (int i = 0; i <= maxLevel; i++) {
            forwards.add(null);
        }
    }

    @Override
    public String toString() {
        return data == null ? " " : "" + data;
    }

    /**
     * 得到当前节点level层上的下一个(右边一个)节点
     *
     * @param level
     * @return
     */
    Node next(int level) {
        return this.forwards.get(level);
    }
}

farwards保存了每一层上的索引信息，如下图所示，farwards描述了红框的信息，值31通过data属性来保存；
next()方法永凯访问同层的右边一个节点。
在这里插入图片描述

查找

在这里插入图片描述
查找操作时，从顶层向下，不断缩小搜索范围。

以上图中的查找过程为例：
首先从头节点header开始，并起始于顶层（这里是1）。

第1层： 经由1, 4, 6。由于6的下一个节点（这里指的是右边）是8，二我们要查找的是7，因此小于7的最大节点就是6，我们从此往下到达下一层。

第0层：经由6, 7。从6往右就到了7了。找到。

真个查询的时间复杂度为O(log n)

public Node find(E e) {
    if (empty()) {
        return null;
    }
    return find(e, head, curLevel);
}

private Node find(E e, Node current, int level) {
    while (level >= 0) {
        current = findNext(e, current, level);
        level--;
    }
    return current;
}

//返回给定层数中小于e的最大者
private Node findNext(E e, Node current, int level) {
    Node next = current.next(level);
    while (next != null) {
        if (e.compareTo(next.data) < 0) {
            break;
        }
        //到这说明e >= next.data
        current = next;
        next = current.next(level);
    }
    return current;
}

插入

在这里插入图片描述
给定上述跳表，假设要插入节点2.
首先需要判断节点2是否已经存在，若存在则返回false。
否则，随机生成 待插入的层数。

/**
 * 生成随机层数[0,maxLevel)
 * 生成的值越大，概率越小
 *
 * @return
 */
private int randomLevel() {
    int level = 0;
    while (Math.random() < PROBABILITY && level < maxLevel - 1) {
        ++level;
    }
    return level;
}

这里的PROBABILITY = 0.5。上面的算法的意思是：返回1的概率是1/2；返回2的概率是1/4；返回3的概率是1/8；以此类推。
看成是一个分布的话，第0层包含所有节点，第1层含有1/2的节点，第2层返回1/4的节点，…

主义到这里的最大层数maxLevel，也可以不设置最大层数。

通过这种随机产生层数的方式使得实现起来简单。
假设我们生成的层数是3.
在这里插入图片描述
在1和3之间插入节点2，层数是3，也就是节点2跳跃到了第3层。

public boolean add(E e) {
    if (contains(e)) {
        return false;
    }
    int level = randomLevel();
    if (level > curLevel) {
        curLevel = level;
    }
    Node newNode = new Node(e);
    Node current = head;
    //插入方向由上到下
    while (level >= 0) {
        //找到比e小的最大节点
        current = findNext(e, current, level);
        //将newNode插入到current后面
        //newNode的next指针指向该节点的后继
        newNode.forwards.add(0, current.next(level));
        //该节点的next指向newNode
        current.forwards.set(level, newNode);
        level--;//每层都要插入
    }
    size++;
    return true;
}

示例
假设我们要插入：1, 6, 9, 3, 5, 7, 4, 8

add: 1
Level 0:  1

add: 6
Level 0:  1 6

add: 9
Level 2:      9
Level 1:      9
Level 0:  1 6 9

add: 3
Level 2:    3   9
Level 1:    3   9
Level 0:  1 3 6 9

add: 5
Level 2:    3     9
Level 1:    3 5   9
Level 0:  1 3 5 6 9

add: 7
Level 2:    3       9
Level 1:    3 5     9
Level 0:  1 3 5 6 7 9

add: 4
Level 2:    3         9
Level 1:    3   5     9
Level 0:  1 3 4 5 6 7 9

add: 8
Level 2:    3           9
Level 1:    3   5       9
Level 0:  1 3 4 5 6 7 8 9

删除

跳表的删除相对于平衡二叉树来说是很简单的。

测试代码如下：

public static void main(String[] args) {
    Random random = new Random();
    int[] values = random.ints(2000, 1, 10000).toArray();
    // int[] values = {1, 6, 9, 3, 5, 7, 4, 8};
    SkipList<Integer> list = new SkipList<>();
    for (int value : values) {
        //System.out.println("add: " + value);
        list.add(value);
        //list.print();
        //System.out.println();
    }
    
    for (int value : values) {
        list.remove(value);
        System.out.println("remove: " + value);
        list.print();
        System.out.println();
    }
}

删除的过程可以说是插入过程的逆过程。
在这里插入图片描述
前面插入了节点2，如果要删除节点2，那就将它的前驱节点指向它的后继节点。

/**
 * O(logN)的删除算法
 *
 * @param e
 * @return
 */
public boolean remove(E e) {
    if (empty()) {
        return false;
    }
    boolean removed = false;//记录是否删除
    int level = curLevel;
    //current用于遍历,pre指向待删除节点前一个节点
    Node current = head.next(level), pre = head;
    while (level >= 0) {
        while (current != null) {
            //e < current.data
            if (e.compareTo(current.data) < 0) {
                break;
            }
            //只有e >= current.data才需要继续
            //如果e == current.data
            if (e.compareTo(current.data) == 0) {
                //pre指向它的后继
                pre.forwards.set(level, current.next(level));
                //设置删除标记
                removed = true;
                //跳出循环内层循环
                break;
            }
            pre = current;
            current = current.next(level);
        }
        //继续搜索下一层
        level--;
        if (level < 0) {
            //防止next(-1)
            break;
        }
        //往下一层,从pre开始往下即可，不需要从头(header)开始
        current = pre.next(level);
    }
    if (removed) {
        size--;//不要忘记size--
        return true;
    }
    return false;
}

示例
插入：1, 6, 9, 3, 5, 7, 4, 8 然后删除它：

before remove:
Level 4:            7
Level 3:            7 8
Level 2:      4     7 8
Level 1:      4 5   7 8
Level 0:  1 3 4 5 6 7 8 9

remove: 1
Level 4:          7
Level 3:          7 8
Level 2:    4     7 8
Level 1:    4 5   7 8
Level 0:  3 4 5 6 7 8 9

remove: 6
Level 4:        7
Level 3:        7 8
Level 2:    4   7 8
Level 1:    4 5 7 8
Level 0:  3 4 5 7 8 9

remove: 9
Level 4:        7
Level 3:        7 8
Level 2:    4   7 8
Level 1:    4 5 7 8
Level 0:  3 4 5 7 8

remove: 3
Level 4:      7
Level 3:      7 8
Level 2:  4   7 8
Level 1:  4 5 7 8
Level 0:  4 5 7 8

remove: 5
Level 4:    7
Level 3:    7 8
Level 2:  4 7 8
Level 1:  4 7 8
Level 0:  4 7 8

remove: 7
Level 4: 
Level 3:    8
Level 2:  4 8
Level 1:  4 8
Level 0:  4 8

remove: 4
Level 4: 
Level 3:  8
Level 2:  8
Level 1:  8
Level 0:  8

remove: 8
Level 4: 
Level 3: 
Level 2: 
Level 1: 
Level 0:

完整代码

package com.algorithms.list;


import java.util.*;

/**
 * 跳表
 *
 * @Author: Yinjingwei
 * @Date: 2019/7/9/009 21:36
 * @Description:
 */
public class SkipList<E extends Comparable<? super E>> implements Iterable<E> {
    //当前层数
    private int curLevel;
    //头结点，不保存值
    private Node head;
    //跳表中元素个数
    private int size;
    //用于生成随机层数
    private static final double PROBABILITY = 0.5;
    //最大层数,也可以写成通过构造函数注入的方式动态设置
    private static final int maxLevel = 8;

    public SkipList() {
        size = 0;
        curLevel = 0;
        head = new Node(null);
    }

    public int size() {
        return size;
    }

    public boolean add(E e) {
        if (contains(e)) {
            return false;
        }
        int level = randomLevel();
        if (level > curLevel) {
            curLevel = level;
        }
        Node newNode = new Node(e);
        Node current = head;
        //插入方向由上到下
        while (level >= 0) {
            //找到比e小的最大节点
            current = findNext(e, current, level);
            //将newNode插入到current后面
            //newNode的next指针指向该节点的后继
            newNode.forwards.add(0, current.next(level));
            //该节点的next指向newNode
            current.forwards.set(level, newNode);
            level--;//每层都要插入
        }
        size++;
        return true;
    }

    //返回给定层数中小于e的最大者
    private Node findNext(E e, Node current, int level) {
        Node next = current.next(level);
        while (next != null) {
            if (e.compareTo(next.data) < 0) {
                break;
            }
            //到这说明e >= next.data
            current = next;
            next = current.next(level);
        }
        return current;
    }

    public Node find(E e) {
        if (empty()) {
            return null;
        }
        return find(e, head, curLevel);
    }

    private Node find(E e, Node current, int level) {
        while (level >= 0) {
            current = findNext(e, current, level);
            level--;
        }
        return current;
    }

    public boolean empty() {
        return size == 0;
    }

    /**
     * O(logN)的删除算法
     *
     * @param e
     * @return
     */
    public boolean remove(E e) {
        if (empty()) {
            return false;
        }
        boolean removed = false;//记录是否删除
        int level = curLevel;
        //current用于遍历,pre指向待删除节点前一个节点
        Node current = head.next(level), pre = head;
        while (level >= 0) {
            while (current != null) {
                //e < current.data
                if (e.compareTo(current.data) < 0) {
                    break;
                }
                //只有e >= current.data才需要继续
                //如果e == current.data
                if (e.compareTo(current.data) == 0) {
                    //pre指向它的后继
                    pre.forwards.set(level, current.next(level));
                    //设置删除标记
                    removed = true;
                    //跳出循环内层循环
                    break;
                }
                pre = current;
                current = current.next(level);
            }
            //继续搜索下一层
            level--;
            if (level < 0) {
                //防止next(-1)
                break;
            }
            //往下一层,从pre开始往下即可，不需要从头(header)开始
            current = pre.next(level);
        }
        if (removed) {
            size--;//不要忘记size--
            return true;
        }
        return false;
    }

    /**
     * 生成随机层数[0,maxLevel)
     * 生成的值越大，概率越小
     *
     * @return
     */
    private int randomLevel() {
        int level = 0;
        while (Math.random() < PROBABILITY && level < maxLevel - 1) {
            ++level;
        }
        return level;
    }

    public boolean contains(E e) {
        Node node = find(e);
        return node != null && node.data != null && node.data.compareTo(e) == 0;
    }

    @Override
    public Iterator<E> iterator() {
        return new SkipListIterator();
    }

    private class SkipListIterator implements Iterator<E> {
        Node current = head;

        @Override
        public boolean hasNext() {
            return current.next(0) != null;
        }

        @Override
        public E next() {
            current = current.next(0);
            return current.data;
        }
    }

    private class Node {
        //保存值
        E data;
        //保存了每一层上的节点信息，可能为null
        List<Node> forwards;

        Node(E data) {
            this.data = data;
            forwards = new ArrayList<>();
            //事先把每一层都置为null，虽然空间利用率没那么高，但是简化了实现
            //也可以通过自定义列表(比如B树实现中用到的Vector)来实现，就可以不用下面的操作
            for (int i = 0; i <= maxLevel; i++) {
                forwards.add(null);
            }
        }

        @Override
        public String toString() {
            return data == null ? " " : "" + data;
        }

        /**
         * 得到当前节点level层上的下一个(右边一个)节点
         *
         * @param level
         * @return
         */
        Node next(int level) {
            return this.forwards.get(level);
        }

    }

    public void print() {
        //记录了第0层值对应的索引，从1开始
        Map<E, Integer> indexMap = new HashMap<>();
        Node current = head.next(0);
        int index = 1;
        int maxWidth = 1;//值的最大宽度，为了格式化好看一点
        while (current != null) {
            int curWidth = current.data.toString().length();
            if (curWidth > maxWidth) {
                maxWidth = curWidth;//得到最大宽度
            }
            indexMap.put(current.data, index++);
            current = current.next(0);
        }
        print(indexMap, maxWidth);
    }

    private void print(int level, Node current, Map<E, Integer> indexMap, int width) {
        System.out.print("Level " + level + ": ");
        int preIndex = 0;//该层前一个元素的索引
        while (current != null) {
            //当前元素的索引
            int curIndex = indexMap.get(current.data);
            if (level == 0) {
                //第0层直接打印即可
                printSpace(curIndex - preIndex);
            } else {
                //其他层稍微复杂一点
                //计算空格数
                //相差的元素个数 + 相差的元素个数乘以宽度
                int num = (curIndex - preIndex) + (curIndex - preIndex - 1) * width;
                printSpace(num);
            }
            System.out.printf("%" + width + "s", current.data);
            preIndex = curIndex;
            current = current.next(level);
        }
        System.out.println();
    }

    /**
     * 打印num个空格
     *
     * @param num
     */
    private void printSpace(int num) {
        for (int i = 0; i < num; i++) {
            System.out.print(' ');
        }
    }

    private void print(Map<E, Integer> map, int width) {
        //从顶层开始打印
        int level = curLevel;
        while (level >= 0) {
            print(level, head.next(level), map, width);
            level--;
        }
    }

    public static void main(String[] args) {
        //Random random = new Random();
        //int[] values = random.ints(2000, 1, 10000).toArray();
        int[] values = {1, 6, 9, 3, 5, 7, 4, 8};
        SkipList<Integer> list = new SkipList<>();
        for (int value : values) {
            //System.out.println("add: " + value);
            list.add(value);
            //list.print();
            //System.out.println();
        }

        System.out.println("before remove:");
        list.print();
        System.out.println();


        for (int value : values) {
            list.remove(value);
            System.out.println("remove: " + value);
            list.print();
            System.out.println();
        }

    }
}

参考

https://blog.csdn.net/yjw123456/article/details/105159817/
Kant101
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
算法——跳表
weixin_44548225的博客
08-20 643
跳表算法介绍
【数据结构与算法】跳表
joy.728的博客
02-04 1798
skiplist 本质上也是一种查找结构，用于解决算法中的查找问题，跟平衡搜索树和哈希表的价值是一样的，可以作为 key 或者 key / value 的查找模型。本篇博客主要讲解了什么是跳表，如何保证跳表的效率，跳表的实现以及跳表跟平衡搜索树和哈希表的对比等。
数据结构---跳表
最新发布
qq_68695298的博客
08-08 775
跳表的原理和模拟实现
数据结构-跳表
qq_29899535的博客
12-06 4689
一、跳表的基本概念 1、跳表的定义 跳表(SkipList)：增加了向前指针的链表叫做指针。跳表全称叫做跳跃表，简称跳表。跳表是一个随机化的数据结构，实质是一种可以进行二分查找的有序链表。跳表在原有的有序链表上增加了多级索引，通过索引来实现快速查询。跳表不仅能提高搜索性能，同时也可以提高插入和删除操作的性能。 跳表是一个随机化的数据结构，可以被看做二叉树的一个变种，它在性能上和红黑树、AVL树不相上下，但是跳表的原理非常简单，目前在Redis和LevelDB中都有用到。 2、跳表的详解 .
Redis-跳跃表（skip List）
养歌的博客
12-13 8468
什么是跳跃表（skip list） 跳表全称叫做跳跃表，简称跳表。跳表是一个随机化的数据结构， 跳跃表（skiplist）是一个用于有序元素序列快速搜索的随机化的数据结构，由美国计算机科学家William Pugh发明于1989年，论文《Skip lists: a probabilistic alternative to balanced trees》中提出。 它的效率和红黑树以及 AVL 树不相上下，但实现起来比较容易。是一种可以于平衡树媲美的层次化链表结构——查找、删除、添加等操作都可以在对数期望时间下
跳表SkipList的原理及实现
07-02
跳表是由William Pugh发明。他在 Communications of the ACM June 1990, 33(6) 668-676 发表了Skip lists: a probabilistic alternative to balanced trees，在该论文中详 细解释了跳表的数据结构和插入删除操作。
Go 语言中实现SkipList实现跳表.pdf
02-11
2. **定义跳表结构体**：接着，定义一个`SkipList`结构体，它包含一个指向第一个节点的指针（Head）以及一个随机数生成器，用于确定跳表的高度。 ```go type SkipList struct { Head *Node Level int } ``` 3. *...
skiplist跳表C++实现
03-04
SkipList skipList; // 插入测试数据 for (int i = 1; i ; ++i) { skipList.insert(i); } // 查找测试 for (int i = 1; i ; ++i) { assert(skipList.search(i) != nullptr); } // 删除测试 for (int i ...
跳表（skiplist）Java实现
11-27
简单得实现跳表相关功能 SkipList<Integer> skipList = new SkipList(maxLevel); 提供insert和seach接口 删除接口可做类似操作
c++如何实现跳表（skiplist）
12-17
跳表是一种高效的数据结构，主要用于有序数据的快速查找、插入和删除操作。它的设计灵感来源于二分查找，但不局限于数组，而是适用于链表。在传统链表的基础上，跳表通过增加多级索引来实现近似的二分查找，从而提高...
跳表分析与实现
Sunnylunch-blog
07-11 6696
一、什么是跳表 跳表全称叫做跳跃表，简称跳表。跳表是一个随机化的数据结构，可以被看做二叉树的一个变种，它在性能上和红黑树，AVL树不相上下，但是跳表的原理非常简单，目前在Redis和LeveIDB中都有用到。 在对有序顺序表进行搜索时，使用二分查找时间复杂度是O(logn)，但是有序顺序表的插入和删除却是O(n)的算法。 在对有序链表进行搜索时，时间复
什么是跳跃表？
夏季版
04-03 308
引用如下： https://mp.weixin.qq.com/s/COBdoHWDhlw4rmG_fGFhSA
【Redis】跳表
火山君的博客
03-22 279
一、跳表定义： 跳表，是一种有序数据结构，它通过在每个节点中维持多个指向其他节点的指针，从而达到快速访问节点的目的。 二、使用场景： 1、实现有序集合键； 2、在集群节点中用作内部数据结构。 三、与平衡树相比的优点： 1、插入快速，无需旋转操作来维护平衡性； 2、容易实现 3、支持无锁操作 参考文献： 1、Redis设计与实现 黄键宏 ...
SkipList 跳表
The time is passing
10-09 1226
为什么选择跳表 目前经常使用的平衡数据结构有：B树，红黑树，AVL树，Splay Tree, Treep等。   想象一下，给你一张草稿纸，一只笔，一个编辑器，你能立即实现一颗红黑树，或者AVL树 出来吗？ 很难吧，这需要时间，要考虑很多细节，要参考一堆算法与数据结构之类的树， 还要参考网上的代码，相当麻烦。   用跳表吧，跳表是一种随机化的数据结构，目前开源软件 Redis 和 L...
什么是跳表？Redis为什么使用跳表来实现有序集合？
ChaunceyChen的博客
04-18 3928
为什么选择跳表 目前经常使用的平衡数据结构有：B树，红黑树，AVL树，Splay Tree, Treep等。 想象一下，给你一张草稿纸，一只笔，一个编辑器，你能立即实现一颗红黑树，或者AVL树 出来吗？ 很难吧，这需要时间，要考虑很多细节，要参考一堆算法与数据结构之类的树， 还要参考网上的代码，相当麻烦。 用跳表吧，跳表是一种随机化的数据结构，目前开源软件 Redis 和 L...
你真的了解跳跃表吗
weixin_34162401的博客
05-24 201
最近换了工作，因为工作的需要，也正好自己想好好研究一下Java这门牛逼的语言，看了一下ElasticSearch和Lucene的源码，之前从来没有写过也没有看过Java的东西，所以也算是恶补了一下Java吧，由于是从C程序员开始的，所以对这种带虚拟机的语言总有一些偏见，老觉得内存不好控制，所以一直以来都没有怎么碰过Java，最近静下心来好...
跳表（SkipList）
一席之地
08-14 155
跳表（SkipList）1 什么是跳表？2 跳表的插入3 跳表的删除4 跳表的代码实现 1 什么是跳表？ 大黄：给定一个有序数组，如何根据元素的值进行高效率查找？ 小蓝：可以使用二分查找。 大黄：如何进行二分查找呢？ 小蓝：首先根据数组下标，定位到数组的中间元素，如果要查找的元素大于中间元素，则定位到右半部分的中间元素进行查找，如果要查找的元素小于中间元素，则定位到左半部分进行查找，以此类推，直到查找到目标元素。如果数组的长度是 n ，二分查找的时间复杂度是 O(nlogn) ，比起从左到右
跳跃表以及C++实现
热门推荐
yinlili2010的专栏
09-24 1万+
首先为了方便，我介绍的大概采用 跳跃链表简介             二叉树是一种常见的数据结构。它支持包括查找、插入、删除等一系列操作。但它有一个致命的弱点，就是当数据的随机性不够时，会导致其树形结构的不平衡，从而直接影响算法的效率。               跳跃链表（Skip List）是1987年才诞生的一种崭新的数据结构，它在进行查找、插入、删除等操作时的期望时间
跳跃表(SkipList)详解与Python实现
"这是一个关于跳跃表(Skip List)的技术分享，主要涵盖了跳跃表的基本概念、工作原理、操作方法以及实际应用。此外，还提及了在Python中实现跳跃表的示例。" 跳跃表是一种高效的数据结构，它在有序数据的检索上提供...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值