跳跃列表

public class SkipList {

    /**
     * 结点晋升概率
     */
    private static final double PROMOTE_RATE = 0.25;

    /**
     * 头结点和尾结点
     */
    private Node head, tail;

    /**
     * 最大层级
     */
    private int maxLevel;

    public static void main(String[] args) {
        SkipList list=new SkipList();
        list.insert(50);
        list.insert(15);
        list.insert(13);
        list.insert(20);
        list.insert(100);
        list.insert(75);
        list.insert(99);
        list.insert(76);
        list.insert(83);
        list.insert(65);
        list.printList();
        list.search(50);
        list.remove(50);
        list.search(50);

        list.search(30);
    }

    /**
     * 初始化列表结构
     */
    public SkipList() {
        head = new Node(Integer.MIN_VALUE);
        tail = new Node(Integer.MAX_VALUE);
        head.right = tail;
        tail.left = head;
    }

    /**
     * 查找结点
     *
     * @param data
     * @return
     */
    public Node search(int data) {
        Node node = findNode(data);
        if (node.data == data) {
            System.out.println("找到结点:" + data);
            return node;
        }
        System.out.println("未找到结点:" + data);
        return null;
    }

    /**
     * 找到对应值的前置结点
     *
     * @param data
     * @return
     */
    public Node findNode(int data) {
        Node node = head;
        while (true) {
            while (node.right.data != Integer.MAX_VALUE && node.right.data <= data) {
                node = node.right;
            }
            if (node.down == null) {
                break;
            }
            node = node.down;
        }
        return node;
    }

    public void insert(int data) {
        Node preNode = findNode(data);
        //如果data相同则直接返回
        if (preNode.data == data) {
            return;
        }
        Node node = new Node(data);
        appendNode(preNode, node);
        int currentLevel = 0;
        //随机决定是否晋升
        Random random = new Random();
        while (random.nextDouble() < PROMOTE_RATE) {
            //如果当前的层级是最高,则需要增加一层
            if (currentLevel == maxLevel) {
                addLevel();
            }
            while (preNode.up == null) {
                preNode = preNode.left;
            }
            preNode = preNode.up;
            Node upperNode = new Node(data);
            appendNode(preNode, upperNode);
            upperNode.down = node;
            node.up = upperNode;
            node = upperNode;
            currentLevel++;
        }
    }

    /**
     * 插入结点
     *
     * @param preNode
     * @param newNode
     */
    private void appendNode(Node preNode, Node newNode) {
        newNode.left = preNode;
        newNode.right = preNode.right;
        preNode.right.left = newNode;
        preNode.right = newNode;
    }

    /**
     * 增加一层
     */
    private void addLevel() {
        maxLevel++;
        Node p1 = new Node(Integer.MIN_VALUE);
        Node p2 = new Node(Integer.MAX_VALUE);
        p1.right = p2;
        p2.left = p1;

        p1.down = head;
        head.up = p1;

        p2.down = tail;
        tail.up = p2;

        head = p1;
        tail = p2;
    }

    /**
     * 移除元素
     *
     * @param data
     * @return
     */
    public boolean remove(int data) {
        Node removeNode = search(data);
        if (removeNode == null) {
            return false;
        }

        int currentLevel = 0;
        while (removeNode != null) {
            removeNode.right.left = removeNode.left;
            removeNode.left.right = removeNode.right;

            //如果不是在最底层，且只有无穷大和无穷大结点，删除该层
            if (currentLevel != 0 && removeNode.left.data == Integer.MIN_VALUE && removeNode.right.data == Integer.MAX_VALUE) {
                removeLevel(removeNode.left);
            } else {
                currentLevel++;
            }
            removeNode = removeNode.up;
        }
        return true;
    }

    public void printList() {
        Node node = head;
        while (node.down != null) {
            node = node.down;
        }
        while (node.right.data != Integer.MAX_VALUE) {
            System.out.println(node.right.data + " ");
            node = node.right;
        }
        System.out.println();
    }

    /**
     * 删除一层
     *
     * @param leftNode
     */
    private void removeLevel(Node leftNode) {
        Node rightNode = leftNode.right;
        //判断删除的层数是否是最高层
        if (leftNode.up == null) {
            leftNode.down.up = null;
            rightNode.down.up = null;
        } else {
            leftNode.up.down = leftNode.down;
            leftNode.down.up = leftNode.up;

            rightNode.up.down = rightNode.down;
            rightNode.down.up = rightNode.up;
        }
        maxLevel--;
    }

    /**
     * 列表结构
     */
    public class Node {
        public int data;

        public Node up, down, left, right;

        public Node(int data) {
            this.data = data;
        }
    }
}