文章目录

• topic
• answer

topic

不使用任何库函数，设计一个 跳表 。

跳表 是在 O(log(n)) 时间内完成增加、删除、搜索操作的数据结构。跳表相比于树堆与红黑树，其功能与性能相当，并且跳表的代码长度相较下更短，其设计思想与链表相似。

例如，一个跳表包含 [30, 40, 50, 60, 70, 90] ，然后增加 80、45 到跳表中，以下图的方式操作：

Artyom Kalinin [CC BY-SA 3.0], via Wikimedia Commons

跳表中有很多层，每一层是一个短的链表。在第一层的作用下，增加、删除和搜索操作的时间复杂度不超过 O(n)。跳表的每一个操作的平均时间复杂度是 O(log(n))，空间复杂度是 O(n)。

了解更多 : https://en.wikipedia.org/wiki/Skip_list

在本题中，你的设计应该要包含这些函数：

bool search(int target) : 返回target是否存在于跳表中。
void add(int num): 插入一个元素到跳表。
bool erase(int num): 在跳表中删除一个值，如果 num 不存在，直接返回false. 如果存在多个 num ，删除其中任意一个即可。
注意，跳表中可能存在多个相同的值，你的代码需要处理这种情况。

示例 1:

输入
[“Skiplist”, “add”, “add”, “add”, “search”, “add”, “search”, “erase”, “erase”, “search”]
[[], [1], [2], [3], [0], [4], [1], [0], [1], [1]]
输出
[null, null, null, null, false, null, true, false, true, false]

解释
Skiplist skiplist = new Skiplist();
skiplist.add(1);
skiplist.add(2);
skiplist.add(3);
skiplist.search(0); // 返回 false
skiplist.add(4);
skiplist.search(1); // 返回 true
skiplist.erase(0); // 返回 false，0 不在跳表中
skiplist.erase(1); // 返回 true
skiplist.search(1); // 返回 false，1 已被擦除

提示:

0 <= num, target <= 2 * 104
调用search, add, erase操作次数不大于 5 * 104

answer

import java.util.ArrayList;
import java.util.List;

public class Skiplist {

    private List<Node> heads;
    // 使用 ArrayList 保存每层链表的表头，表头不存储元素，值为 -i ， i为层数，从 1 开始。

    private class Node{
        int val;
        // 使用双链表方便操作
        Node left,right,down;

        public Node(int val) {
            this.val = val;
            this.left = null;
            this.down = null;
            this.right = null;
        }
    }

    public Skiplist() {
        Node head0 = new Node(-1);
        heads = new ArrayList<>();
        heads.add(head0);
    }

    public boolean search(int target){
        int level = heads.size()-1;
        Node searchingStart = heads.get(level);
        while(level != -1){
            boolean jump = false;
            while(searchingStart.right!=null){
                searchingStart = searchingStart.right;
                if(searchingStart.val==target)
                    return true;
                else if(searchingStart.val>target){
                    if(level == 0)
                        return false;
                    else {
                        level --;
                        searchingStart = searchingStart.left.down;
                        jump = true;
                        break;
                    }
                }
            }
            if(jump)
                continue;
            level --;
            searchingStart = searchingStart.down;
        }
        return false;
    }

    public void add(int num){
        // 在底层添加元素
        Node n0 = new Node( num);
        Node[] jumpingNodes = searchNodes(num);
        Node lefter = jumpingNodes[0];
        n0.right = lefter.right;
        n0.left = lefter;
        if(lefter.right!=null)
            lefter.right.left=n0;
        lefter.right = n0;

        // 添加索引
        int levelToAddIndex = 1;
        while(throwCoin()){
            Node hi;
            if(jumpingNodes.length <= levelToAddIndex){
                hi= new Node(-levelToAddIndex-1);
                heads.add(hi);
                hi.down = heads.get(levelToAddIndex-1);
            }
            else
                hi = jumpingNodes[levelToAddIndex];
            Node ni = new Node(num);
            // 连接上下层相同的元素，用于跳
            ni.down = n0;
            ni.right = hi.right;
            ni.left = hi;
            if(hi.right!=null)
                hi.right.left = ni;
            hi.right = ni;
            n0 = ni;
            levelToAddIndex++;
        }
    }

    public boolean erase(int num) {
        Node[] jmpt = searchNodes(num);
        boolean exist = false;
        for (Node n:jmpt)
            if(n.val==num){
                exist = true;
                del(n);
            }
        return exist;
    }

    private Node[] searchNodes(int target){
        // 本函数也能实现 public boolean search(int target)的功能，但是由于是直到底层才停止的，效果不如在中间层找到就直接返回 true 的好。
        Node[] jumps = new Node[heads.size()];
        int level = heads.size()-1;
        Node searchingStart = heads.get(level);
        while(level!=-1){
            boolean jump = false;
            while(searchingStart.right!=null){
                searchingStart = searchingStart.right;
                if(searchingStart.val==target) {
                    while(level!=-1){
                        jumps[level] = searchingStart;
                        searchingStart=searchingStart.down;
                        level --;
                    }
                    return jumps;
                }
                else if(searchingStart.val>target){
                    jumps[level] = searchingStart.left;
                    level --;
                    searchingStart = searchingStart.left.down;
                    jump = true;
                    break;
                }
            }
            if(jump)
                continue;
            jumps[level] = searchingStart;
            level --;
            searchingStart = searchingStart.down;
        }
        return jumps;
    }

    private void del(Node n){
        n.left.right = n.right;
        if(n.right != null ) {
            n.right.left = n.left;
        }
    }

    private boolean throwCoin(){
        // 抛硬币， 50% 概率
        return Math.random()<0.5f;
    }

}