跳跃表详解-Java实现

引出跳表

什么是跳表？

跳表本质上是一种有序链表，但是其支持二分查找。

跳表在原有的有序链表上面增加了多级索引，通过索引来实现快速查找。

跳表不仅能提高搜索性能，同时也可以提高插入和删除操作的性能。

考虑一个有序链表，我们要查找3、7、17这几个元素，我们只能从头开始遍历链表，直到查找到元素为止。

上述这个链表是有序的，但是不能使用二分查找，又不是数组是吧。

那么，有没有什么方法可以实现有序链表的二分查找呢？

答案是肯定的，那就是我们将要介绍的这种数据结构——跳表。

跳表的功能与红黑树和差不多，效率上也相差不大。但是红黑树代码实现复杂，跳表实现简单，所以再很多时候我们也可以选择使用跳表

跳表的实现

跳表的查询

我们多添加一级索引，形成了下面这样的结构。

现在假设我们想要查找15这个元素是不是就要快很多呢？

我们只要从一级索引往后遍历即可，只需要经过1、6、15、我们就可以找到15了。

那么，我们要查找11这个元素呢？

我们从一级索引的1开始，向右到6，再向右发现是15，它比11大，此路不通，从6往下走，再从下面的6往右走，到7，再到11。

同样地，一级索引也可以往上再提取一层，组成二级索引，如下：

这时候我们再查找17这个元素呢？

只需要经过6、15、17这几个元素就可以找到17了。

这基本上就是跳表的核心思想了，其实这也是一个“空间换时间”的算法，通过向上提取索引增加了查找的效率。

 跳表的插入

比如，我们要向上面这个跳表添加一个元素8。

首先，我们先根据投硬币的方式，决定8这个元素要占据的层数，其实就是一种概率性的问题，这样出来的层数具有其规律性。

这也硬币怎么抛呢？我们设置一个初始值为i=1，代表当前元素所占据的层数为1。我们规定硬币反面的时候，层数i++，正面的时候，当前当前i的值，就是当前这个元素所占的层数，因为层数的值越大的概率越低，所以最终所有元素层数的分布是具有一定的规律性的。大概就是层数每高一层，该层元素的个数就要减少一半。前提是我们是用的概率是0.5。

我们可以利用随机函数生成随机数，如果随机数小于0.5.level++。如果大于0.5，当前的level就是当前插入元素的层数。

假设当前随机出来的层数level=2。

然后，找到8这个元素在下面两层的前置节点。

接着，就是链表的插入元素操作了，比较简单。

最后，就像下面这样：

跳表的删除

删除其实是跟插入类似的

首先，找到各层中包含元素x的节点。

然后，使用标准的链表删除元素的方法删除即可。

比如，要删除17这个元素。

 

跳表的代码实现

public class SkipList<T extends Comparable<T>> {
    // 当前跳表中最高的level，也就是首列的高度。
    private int maxLevel;
    // 首列，其中没有存储数据，其只是作为一个索引列。
    private Node head;
    // 抛硬币的可能性，level增加的可能性
    private static final float threshold = 0.5f;
    private int size;

    // 表示跳表中的每一列，也就是每一个被存储的元素。
    private class Node {
        public T val;

        public List<Node> nodeList;

        public Node(T val) {
            this.val = val;
            this.nodeList = new ArrayList<>();
        }
    }

    public SkipList() {
        head = new Node(null);
        head.nodeList.add(null);
    }

    public boolean add(T t) {
        if (t == null || contain(t)) {
            return false;
        }
        int level = 0;          // 当前柱的高度
        for (; Math.random() < threshold; ) {
            level++;
        }
        // 扩充首列的level，保证其的高度一定是最高之一。
        for (; level > maxLevel; maxLevel++) {
            head.nodeList.add(null);
        }
        Node newNode = new Node(t);
        int curLevel = maxLevel;
        Node curNode = head;
        do {
            // 从curLevel层开始找小于t的元素中最大的元素的位置。findNextLessThan中只会向右移动
            curNode = findNextLessThan(curNode, t, curLevel);
            if (level >= curLevel) {
                newNode.nodeList.add(0, curNode.nodeList.get(curLevel));
                curNode.nodeList.set(curLevel, newNode);
                level--;
            }
        } while (curLevel-- > 0);
        size++;
        return true;
    }


    public boolean delete(T t) {
        if (t == null) {
            return false;
        }
        int curLevel = maxLevel;
        Node curNode = head, next;

        do {
            for (next = curNode.nodeList.get(curLevel); next != null && lessThan(next.val, t);
                 curNode = next, next = curNode.nodeList.get(curLevel)) {
            }
            if (next != null && t.equals(next.val)) {
                for (; curLevel >= 0; curLevel--) {
                    curNode.nodeList.set(curLevel, next.nodeList.get(curLevel));
                }
                size--;
                return true;
            }
        } while (curLevel-- > 0);
        return false;
    }

    public boolean contain(T t) {
        if (t == null) {
            return false;
        }
        int curLevel = maxLevel;
        Node curNode = head;
        do {
            Node next = findNextLessThan(curNode, t, curLevel);
            if (t == next.val || t.equals(next.val)) {
                return true;
            }
        } while (curLevel-- > 0);
        return false;
    }

    public void printf() {
        Node cur = head.nodeList.get(0);
        for (; cur != null; cur = cur.nodeList.get(0)) {
            System.out.print(cur.val + " ");
        }
    }

    public Node findNextLessThan(Node curNode, T t, int level) {
        for (Node next = curNode.nodeList.get(level); next != null; curNode = next, next = curNode.nodeList.get(level)) {
            if (lessThan(t, next.val)) {
                break;
            }
        }
        return curNode;
    }

    public boolean lessThan(T t, T c) {
        return t.compareTo(c) < 0;
    }

    public int size() {
        return size;
    }
}

 

 

 

标准化的跳表

上面举的例子是完全随机的跳表，那么，如果我们每两个元素提取一个元素作为上一级的索引会怎么样呢？

 

这是不是很像平衡二叉树，现在这颗树元素比较少，可能不太明显，我们来看个元素个数多的情况。

 

可以看到，上一级元素的个数是下一级的一半，这样每次减少一半，就很接近平衡二叉树了。

时间复杂度

我们知道单链表查询的时间复杂度为O(n)，而插入、删除操作需要先找到对应的位置，所以插入、删除的时间复杂度也是O(n)。

那么，跳表的时间复杂度是多少呢？

如果按照标准的跳表来看的话，每一级索引减少k/2个元素（k为其下面一级索引的个数），那么整个跳表的高度就是(log n)。

学习过平衡二叉树的同学都知道，它的时间复杂度与树的高度成正比，即O(log n)。

所以，这里跳表的时间复杂度也是O(log n)。（这里不一步步推倒了，只要记住，查询时每次减少一半的元素的时间复杂度都是O(log n)，比如二叉树的查找、二分法查找、归并排序、快速排序）

空间复杂度

我们还是以标准的跳表来分析，每两个元素向上提取一个元素，那么，最后额外需要的空间就是：

n/2 + (n/2)^2 + (n/2)^3 + ... + 8 + 4 + 2 = n - 2

所以，跳表的空间复杂度是O(n)。

总结

（1）跳表是可以实现二分查找的有序链表；

（2）每个元素插入时随机生成它的level；

（3）最低层包含所有的元素；

（4）如果一个元素出现在level(x)，那么它肯定出现在x以下的level中；

（5）每个索引节点包含两个指针，一个向下，一个向右；

（6）跳表查询、插入、删除的时间复杂度为O(log n)，与平衡二叉树接近；

彩蛋

为什么Redis选择使用跳表而不是红黑树来实现有序集合？

首先，我们来分析下Redis的有序集合支持的操作：

1）插入元素

2）删除元素

3）查找元素

4）有序输出所有元素

5）查找区间内所有元素

其中，前4项红黑树都可以完成，且时间复杂度与跳表一致。

但是，最后一项，红黑树的效率就没有跳表高了。

在跳表中，要查找区间的元素，我们只要定位到两个区间端点在最低层级的位置，然后按顺序遍历元素就可以了，非常高效。

而红黑树只能定位到端点后，再从首位置开始每次都要查找后继节点，相对来说是比较耗时的。

部分引用自：https://www.jianshu.com/p/dd01e8dc4d1f