参考资料

https://kenby.iteye.com/blog/1187303
https://time.geekbang.org/column/article/42896
http://www.mathcs.emory.edu/~cheung/Courses/323/Syllabus/Map/skip-list-impl.html

实现SkipList

public class MySkipList {

    private static class Node {
        private Integer value;
        private Node up, down, left, right;

        public Node(Integer value) {
            this.value = value;
        }

        @Override
        public String toString() {
            return "value=" + value;
        }
    }

    private Node head;
    private Node tail;
    private int size;
    private int height;
    private Random random;

    public MySkipList() {
        head = new Node(null);
        tail = new Node(null);
        head.right = tail;
        tail.left = head;
        height = 1;
        random = new Random();
    }

    private Node find(Integer element) {
        Node current = head;
        for (;;) {
            while (current.right.value != null && current.right.value.compareTo(element) <= 0) {
                current = current.right;
            }
            if (current.down != null) {
                current = current.down;
            } else {
                break;
            }
        }
        // current.value(不为null) <= element < current.right.value(不为null)
        return current;
    }

    public void add(Integer element) {
        Node nearNode = this.find(element);
        if (element.equals(nearNode.value)) {
            return;
        }
        Node node = new Node(element);
        node.left = nearNode;
        node.right = nearNode.right;
        nearNode.right.left = node;
        nearNode.right = node;
        int currentLevel = 1;
        while (random.nextDouble() < 0.5d) {
            if (currentLevel >= height) {
                Node newHead = new Node(null);
                Node newTail = new Node(null);
                newHead.right = newTail;
                newTail.left = newHead;
                newHead.down = head;
                newTail.down = tail;
                head.up = newHead;
                tail.up = newTail;
                head = newHead;
                tail = newTail;
                height++;
            }
            while (nearNode.up == null) {
                nearNode = nearNode.left;
            }
            nearNode = nearNode.up;

            Node upNode = new Node(element);
            upNode.left = nearNode;
            upNode.right = nearNode.right;
            upNode.down = node;

            nearNode.right.left = upNode;
            nearNode.right = upNode;
            node.up = upNode;

            node = upNode;

            currentLevel++;
        }
        size++;
    }

    public boolean contains(Integer element) {
        Node node = this.find(element);
        return element.equals(node.value);
    }

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

    public int size() {
        return size;
    }

    public void remove(Integer element) {
        Node node = this.find(element);
        if (!element.equals(node.value)) {
            return;
        }
        do {
            node.left.right = node.right;
            node.right.left = node.left;
            node = node.up;
        } while (node != null);
        // 调整head、tail和height
        while (head.right.value == null && head.down != null) {
            head = head.down;
            tail = tail.down;
            head.up.down = null;
            tail.up.down = null;
            head.up = null;
            tail.up = null;
            height--;
        }
    }

    public void printSkipList() {
        Node temp = head;
        int i = height;
        while (temp != null) {
            System.out.printf("总高度 " + height + " 当前高度 " + i-- + " : ");
            Node node = temp.right;
            while (node.value != null) {
                System.out.printf(node.value + " -> ");
                node = node.right;
            }
            System.out.printf("\r\n");
            temp = temp.down;
        }
        System.out.println("==============================");
    }

}

测试

public class Test {
    
    public static void main(String[] args) {
        MySkipList skipList = new MySkipList();
        Random random = new Random(System.currentTimeMillis());
        for (int i = 0; i < 100; i++) {
            skipList.add(random.nextInt(100));
        }
        skipList.printSkipList();
        for (int i = 0; i < 20; i++) {
            skipList.remove(i);
        }
        skipList.printSkipList();
    }

}

结果

总高度 6 当前高度 6 : 8 -> 
总高度 6 当前高度 5 : 5 -> 8 -> 
总高度 6 当前高度 4 : 5 -> 8 -> 13 -> 16 -> 26 -> 45 -> 48 -> 52 -> 58 -> 78 -> 87 -> 94 -> 
总高度 6 当前高度 3 : 0 -> 2 -> 5 -> 8 -> 13 -> 14 -> 16 -> 20 -> 22 -> 23 -> 26 -> 33 -> 40 -> 45 -> 48 -> 52 -> 58 -> 67 -> 74 -> 78 -> 84 -> 87 -> 91 -> 94 -> 95 -> 
总高度 6 当前高度 2 : 0 -> 2 -> 5 -> 8 -> 13 -> 14 -> 16 -> 17 -> 20 -> 22 -> 23 -> 26 -> 30 -> 31 -> 32 -> 33 -> 34 -> 40 -> 42 -> 45 -> 48 -> 51 -> 52 -> 54 -> 58 -> 61 -> 67 -> 74 -> 76 -> 78 -> 84 -> 87 -> 91 -> 93 -> 94 -> 95 -> 97 -> 
总高度 6 当前高度 1 : 0 -> 2 -> 3 -> 5 -> 6 -> 8 -> 10 -> 13 -> 14 -> 16 -> 17 -> 18 -> 19 -> 20 -> 22 -> 23 -> 24 -> 26 -> 30 -> 31 -> 32 -> 33 -> 34 -> 36 -> 38 -> 39 -> 40 -> 42 -> 43 -> 45 -> 46 -> 48 -> 49 -> 50 -> 51 -> 52 -> 53 -> 54 -> 55 -> 58 -> 59 -> 60 -> 61 -> 63 -> 67 -> 69 -> 70 -> 71 -> 72 -> 73 -> 74 -> 76 -> 78 -> 80 -> 81 -> 82 -> 83 -> 84 -> 85 -> 86 -> 87 -> 91 -> 93 -> 94 -> 95 -> 96 -> 97 -> 98 -> 
==============================
总高度 4 当前高度 4 : 26 -> 45 -> 48 -> 52 -> 58 -> 78 -> 87 -> 94 -> 
总高度 4 当前高度 3 : 20 -> 22 -> 23 -> 26 -> 33 -> 40 -> 45 -> 48 -> 52 -> 58 -> 67 -> 74 -> 78 -> 84 -> 87 -> 91 -> 94 -> 95 -> 
总高度 4 当前高度 2 : 20 -> 22 -> 23 -> 26 -> 30 -> 31 -> 32 -> 33 -> 34 -> 40 -> 42 -> 45 -> 48 -> 51 -> 52 -> 54 -> 58 -> 61 -> 67 -> 74 -> 76 -> 78 -> 84 -> 87 -> 91 -> 93 -> 94 -> 95 -> 97 -> 
总高度 4 当前高度 1 : 20 -> 22 -> 23 -> 24 -> 26 -> 30 -> 31 -> 32 -> 33 -> 34 -> 36 -> 38 -> 39 -> 40 -> 42 -> 43 -> 45 -> 46 -> 48 -> 49 -> 50 -> 51 -> 52 -> 53 -> 54 -> 55 -> 58 -> 59 -> 60 -> 61 -> 63 -> 67 -> 69 -> 70 -> 71 -> 72 -> 73 -> 74 -> 76 -> 78 -> 80 -> 81 -> 82 -> 83 -> 84 -> 85 -> 86 -> 87 -> 91 -> 93 -> 94 -> 95 -> 96 -> 97 -> 98 -> 
==============================