class Node {
    //當(dāng)前節(jié)點值
    private Integer value;
    //當(dāng)前節(jié)點所屬鏈表下一個節(jié)點
    private Node next;
    //當(dāng)前節(jié)點所屬鏈表上一個節(jié)點
    private Node prev;
    //當(dāng)前節(jié)點指向的另一個索引鏈表/原始值鏈表節(jié)點
    private Node nodeValue;
    Node(Integer value) {
        this.value = value;
    }
}

/**
 * 原始數(shù)據(jù)鏈表
 */
private Node head ;
/**
 * 最終的跳表結(jié)構(gòu)：保存索引鏈表及原始鏈表
 */
private List<Node> indexList;
/**
 * 跳表層數(shù)
 */
private int level;

/**
* 初始化
*/
public void init() {
    //帶頭節(jié)點的鏈表，便于操作
    head = new Node(-1);
    head.next = head;
    indexList = new ArrayList<>();
    level = 0;
}
/**
 * 初始化跳表
 * @param k 間隔
 * @param nums 原始數(shù)據(jù)（已排序）
 */
public void init(int k, int[] nums) {
    //初始化數(shù)據(jù)鏈表
    Node temp = head;
    for (int num : nums) {
        Node cur = new Node(num);
        cur.prev = temp;
        temp.next = cur;
        temp = temp.next;
    }
    //新節(jié)點保存（最底層）
    indexList.add(head);

    //循環(huán)生成索引結(jié)構(gòu)，結(jié)束條件，當(dāng)層僅一個元素
    temp = head.next;
    while (true) {
        //當(dāng)前鏈表第幾個元素
        int i = 0;
        //生成另一條鏈表長度
        int size = 0;
        Node indexNode = new Node(-1);
        indexNode.next = indexNode;
        Node indexNodeTemp = indexNode;
        while (null != temp) {
            //間隔k生成節(jié)點
            if (i % k == 0) {
                Node curNode = new Node(temp.value);
                curNode.nodeValue = temp;
                curNode.prev = indexNodeTemp;
                indexNodeTemp.next = curNode;
                indexNodeTemp = indexNodeTemp.next;
                ++ size;
            }
            ++ i;
            temp = temp.next;
        }
        indexList.add(indexNode);
        temp = indexNode.next;
        //當(dāng)生成的索引鏈表僅1時不需要再繼續(xù)生成
        if (size == 1) {
            break;
        }
    }
    level = indexList.size();
}

/**
 * 是否存在num
 * @param num
 * @return
 */
public boolean hasNum(int num) {
    Node result = this.findNum(num);
    return null != result;
}
/**
 * 查找num（返回的可能是索引，也可能是原始數(shù)據(jù)，根據(jù)nodeValue可以判斷，也可以找到原始數(shù)據(jù)）
 * @param num
 */
public Node findNum(int num) {
    //跳表結(jié)構(gòu)indexList是數(shù)據(jù)-》第一層索引-》第二層索引-》。。。。
    //1.直接匹配到
    //2.找到第一個大于當(dāng)前元素的數(shù)，找前一個
    Node node = indexList.get(indexList.size() - 1).next;
    Node last = null;
    while (null != node) {
        if (node.value == num) {
            //已經(jīng)找到元素
            return node;
        }
        if (node.value > num) {
            if (null == last) {
                //比最小值還小
                return null;
            }
            //找到了第一個大于num的索引node
            //到下一層去繼續(xù)找
            node = last.nodeValue;
            last = null;
            continue;
        }
        last = node;
        node = null != node.next ? node.next : node.nodeValue;
    }
    return null;
}

/**
 * 構(gòu)建索引時：自底向上逐層構(gòu)建，如果索引需要刪除（當(dāng)兩個索引之間沒有任何數(shù)據(jù)時候，刪除）
 * @param num
 * @return
 */
public boolean remove(int num) {
    Node node = this.findNum(num);
    if (null == node) {
        //不需要移除
        return false;
    }
    if (null == node.nodeValue) {
        //數(shù)據(jù)鏈表，可以直接移除
        //是否最后一個節(jié)點
        if (null == node.next) {
            node.prev.next = null;
            return true;
        }
        node.next.prev = node.prev;
        node.prev.next = node.next;
        return true;
    }
    //當(dāng)前在索引上，自上而下刪除索引及數(shù)據(jù)
    while (null != node) {
        Node cur = node.nodeValue;
        if (null == node.next) {
            node.prev.next = null;
        } else {
            node.next.prev = node.prev;
            node.prev.next = node.next;
        }
        node = cur;
    }
    return true;
}

/**
 * 首先需要查找插入位置，如果比最小的還小，直接在前面插入
 * 否則需要從最頂級一直查找到數(shù)據(jù)鏈表，找到插入位置，插入，在查找的過程中，就可以開始插入索引節(jié)點，
 * 從上往下進(jìn)行插入
 * @param num
 */
public void add(int num) {
    int k = this.generatorLevelK();
    //尋找插入點的過程和查找過程基本一致
    //頂級索引鏈表
    Node node = indexList.get(indexList.size() - 1).next;
    int index = 1;
    while (null != node) {
        //找到第一個node.value >= num的元素，在前面插入
        if (node.value >= num) {
            //已經(jīng)找到,前插
            if (index >= k) {
                Node newNode = new Node(num);
                Node temp = node.prev;
                newNode.next = temp.next;
                temp.next.prev = newNode;
                newNode.prev = temp;
                temp.next = newNode;
            }
            //找的時候往后面找的，但是當(dāng)前已經(jīng)先于num了，下一次再往后面找，就出現(xiàn)問題
            if (null == node.prev.prev) {
                //第一個節(jié)點就符合條件
                node = node.nodeValue;
                continue;
            }
            node = node.prev.nodeValue;
            ++ index;
            continue;
        }

        //沒有找到，但是當(dāng)前已經(jīng)是鏈表最后一個元素了
        if (null == node.next) {
            if (index >= k) {
                Node newNode = new Node(num);
                newNode.prev = node;
                node.next = newNode;
            }
            if (null == node.prev.prev) {
                //第一個節(jié)點就符合條件
                node = node.nodeValue;
                continue;
            }
            node = node.prev.nodeValue;
            ++ index;
            continue;
        }

        node = node.next;
    }

}

private int generatorLevelK() {
    Random random = new Random();
    return random.nextInt(level);
}