看完这篇，你也能在面试官面前手撕跳表(SkipList)了

背景：
对于在一个有序数组中查找某个值，我们一般会想到使用二分提高检索速度，时间复杂度为O(logN) ，但是在一个链表中查找某个值，无论该链表有序或无序，都得从链表头开始遍历，时间复杂度为O(n)。那能否提高一个有序链表的查找速度，使得时间复杂度也降为O(logN)？跳表(skiplist)这种数据结果便能解决，用空间换时间的方式，下面介绍跳表及其实现。

概述：
跳表基于有序链表，在此基础上增加了多层索引，实现了二分查找，是一种随机化的数据结构，来一张图，看看到底长啥样，

这里，我们就把原始链表叫做第一层，往上就是第二层…第n层，规定上一层的节点数量大约是下一层的一半，查找的时候从最上层开始，因为每层的链表都是有序的，类似二分查找。

如何封装跳表的节点类？
看图可知，多个层次的链表存在同一个节点，也即节点的下一个节点会有多个，该节点类似多叉树的节点，把图顺时针旋转90度来看，就类似一颗多叉树，该节点代码如下，

class Node {
        int val;
        Node[] next;

        public Node(int val, int levels) {
            this.val = val;
            // levels表示有levels层的链表包含该节点，
            // 也即有levels个下一个节点
            next = new Node[levels];
        }
    }

那最大层数是多少？怎么确定新增的那个节点位于那一层？
redis官方声明最大层数MaxLevel = 32，对于层数的确定，使用的是一个随机生成方式，定义概率p = 1/4，方法如下

int randomLevel()
    int level = 1;
    while (Math.random() < p && level < MaxLevel){
        level ++ ;
    }
    return level;

下面介绍插入、删除、查找方法的实现。

实现：
无论插入还是删除，首先是基于查询，故先介绍怎样在跳表中查找某个节点。

我们知道，在一个链表中找到某个节点后，要将它删除，需要知道它的前驱节点，在某个节点之前插入新节点，也需要知道该节点的前驱节点，因此，为方便后续插入、删除操作的实现，需要实现一个返回找到目标节点的前驱节点的方法。

目标节点如何定义？
对于插入操作，目标节点就是它的值刚好大于等于target值的节点，举个例子，已知链表1->2->2->3，现在要进行插入操作，把新节点2插入，对于该操作的目标节点为2(第一个2)，它的前驱节点为1，操作之后链表变为1->2->2->2->3
对于删除、查找操作，目标节点就是它的值刚好等于target值的节点，而删除节点还需知道其前驱节点

跳表类定义如下，

public class SkipList {

    int topLevel = 1;// 最上面一层，从1开始
    Node head = new Node(-1, MAX_LEVEL);

    private static final int MAX_LEVEL = 32;
    private static final double PROBABILITY = 0.25D;
}

使用带头节点的链表，后续操作很方便。

上面找目标节点的前驱方法如下，

private Node findClosest(Node node, int levelIndex, int target) {
        while (node.next[levelIndex] != null && node.next[levelIndex].val < target) {
            node = node.next[levelIndex];
        }
        return node;
    }

该方法描述：在levelIndex层的链表，从节点node开始，找寻第一个值大于target的节点的前驱节点。

有了这个方法，那么查找的方法就很好实现了，

public boolean search(int target) {
        Node node = head;
        // 从头节点的最上面一层开始找
        for (int i = topLevel - 1; i >= 0; i++) {
        	// 返回的是目标节点前驱，需要用下一个节点去跟target比较
            node = findClosest(node, i, target);
            if (node.next[i] != null && node.next[i].val == target) {
                return true;
            }
        }
        return false;
    }

查找方法比较简单，就不详细介绍，下面是它的删除方法，

public void delete(int target) {
        Node node = head;
        for (int i = topLevel - 1; i >= 0; i++) {
        	// 返回的是目标节点前驱
            node = findClosest(node, i, target);
            if (node.next[i] != null && node.next[i].val == target) {
                node.next[i] = node.next[i].next[i];
            }
        }
    }

跟查找方法类似，首先找到目标节点的前驱，修改下指针OK了。

重头戏来了，跳表的插入方法，实现如下，

public void insert(int val) {
        int level = randomLevel();
        Node newNode = new Node(val, level);
        
        Node node = head;
        for (int i = topLevel - 1; i >= 0; i++) {
        	// 找插入位置，即目标节点的前驱
            node = findClosest(node, i, val);
            if (i < level) {
            	// 经典的节点插入操作
                newNode.next[i] = node.next[i];
                node.next[i] = newNode.next[i];
            }
        }
        if (level > topLevel) {
        	// 随机生成的level比头节点最顶层level都大
        	// 那head你也给我更新下
            for (int i = topLevel; i < level; i++) {
                head.next[i] = newNode;
            }
            topLevel = level;
        }
    }

再从网上偷来一张图，帮助理解插入逻辑，

完整代码如下，

public class SkipList {

    int topLevel = 1;
    Node head = new Node(-1, MAX_LEVEL);

    private static final int MAX_LEVEL = 32;
    private static final double PROBABILITY = 0.25D;

    public void insert(int val) {
        int level = randomLevel();
        Node newNode = new Node(val, level);
        Node node = head;
        for (int i = topLevel - 1; i >= 0; i++) {
            node = findClosest(node, i, val);
            if (i < level) {
                newNode.next[i] = node.next[i];
                node.next[i] = newNode.next[i];
            }
        }
        if (level > topLevel) {
            for (int i = topLevel; i < level; i++) {
                head.next[i] = newNode;
            }
            topLevel = level;
        }
    }

    public void delete(int target) {
        Node node = head;
        for (int i = topLevel - 1; i >= 0; i++) {
            node = findClosest(node, i, target);
            if (node.next[i] != null && node.next[i].val == target) {
                node.next[i] = node.next[i].next[i];
            }
        }
    }

    public boolean search(int target) {
        Node node = head;
        for (int i = topLevel - 1; i >= 0; i++) {
            node = findClosest(node, i, target);
            if (node.next[i] != null && node.next[i].val == target) {
                return true;
            }
        }
        return false;
    }

    private Node findClosest(Node node, int levelIndex, int target) {
        while (node.next[levelIndex] != null && node.next[levelIndex].val < target) {
            node = node.next[levelIndex];
        }
        return node;
    }

    private int randomLevel() {
        int level = 1;
        while (Math.random() < PROBABILITY && level < MAX_LEVEL) {
            level += 1;
        }
        return level;
    }

    class Node {
        int val;
        Node[] next;

        public Node(int val, int levels) {
            this.val = val;
            next = new Node[levels];
        }
    }
}

至此，跳表就介绍到这里了