Java版高级数据结构算法 - 跳跃表

知识的学习在于点滴记录，坚持不懈；知识的学习要有深度和广度，不能只流于表面，坐井观天；知识要善于总结，不仅能够理解，更知道如何表达！

跳跃表的实现

红黑树实现了一颗高效的二叉查找树，其增删查的时间复杂度达到了$O(lo{g}_{2}n)$，但是红黑树的增加和删除操作，其代码实现起来，还是稍微有一些复杂的（当然如果你理解透彻其原理，实现起来也很easy），那么跳跃表就是以一种更加便捷的方式实现了和红黑树增删查操作时间复杂度一样的数据结构。

java.util.concurrent并发包里面提供了一个ConcurrentSkipListSet的实现，是一个线程安全的跳跃表，基于CAS实现的线程安全。关于跳跃表的理论，大家可以在网上搜到大量的资料，这里面给出其Java代码的具体实现，如下：

/**
 * 跳跃表节点类型
 * @param <T>
 */
class Node<T extends Comparable<T>>{
    // 节点存储的值
    T data;
    // 节点存储的上下左右四个方向的地址域
    Node<T> up;
    Node<T> down;
    Node<T> left;
    Node<T> right;

    public Node(T data, Node<T> up, Node<T> down, Node<T> left, Node<T> right) {
        this.data = data;
        this.up = up;
        this.down = down;
        this.left = left;
        this.right = right;
    }

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

    public Node<T> getUp() {
        return up;
    }

    public void setUp(Node<T> up) {
        this.up = up;
    }

    public Node<T> getDown() {
        return down;
    }

    public void setDown(Node<T> down) {
        this.down = down;
    }

    public Node<T> getLeft() {
        return left;
    }

    public void setLeft(Node<T> left) {
        this.left = left;
    }

    public Node<T> getRight() {
        return right;
    }

    public void setRight(Node<T> right) {
        this.right = right;
    }
}

/**
 * 跳跃表每一层链表的起始头节点类型，继承自Node，添加了一个记录层数的level变量
 * @param <T>
 */
class HeadNode<T extends Comparable<T>> extends Node<T>{
    int level;

    public HeadNode(T data, Node<T> up, Node<T> down, Node<T> left, Node<T> right, int level) {
        super(data, up, down, left, right);
        this.level = level;
    }

    public int getLevel() {
        return level;
    }

    public void setLevel(int level) {
        this.level = level;
    }
}

/**
 * 跳跃表实现类
 * @param <T>
 */
class SkipList<T extends Comparable<T>>{
    // 跳跃表最上面一层链表的头节点
    private HeadNode<T> head;

    /**
     * 跳跃表的构造函数，初始化一个头节点，层数level初始化为1
     */
    public SkipList() {
        head = new HeadNode<>(null, null, null, null, null, 1);
    }

    /**
     * 跳跃表添加元素
     * @param key
     */
    public void put(T key){
        // 查找key是否存在，存在直接返回，不存在进行插入操作
        Node<T> pre = head;
        Node<T> cur = head.getRight();

        for(;;){
            if(cur != null){
                // 在跳跃表当前层的链表进行搜索
                if(cur.getData().compareTo(key) < 0){
                    pre = cur;
                    cur = cur.getRight();
                    continue;
                } else if(cur.getData().compareTo(key) == 0){
                    return;
                }
            }

            // 判断如果还有下层链表，跳到下层继续进行搜索
            if(pre.getDown() == null){
                break;
            }
            pre = pre.getDown();
            cur = pre.getRight();
        }

        /**
         * 抛硬币决定key放几层，根据正态分布统计结果，每一层大约有一半的元素会被选择添加到
         * 上一层。如果层数过多，只超过当前最高层一层就可以，不用存放过多的层数，插入到pre
         * 的后面，level的每一层都要添加该元素
         */
        int level = getInsertLevel();
        Node<T>[] newNodes = null;
        Node<T> index = null;
        HeadNode<T> h = this.head;
        if(level > h.getLevel()){
            // 如果抛硬币的结果，level层数过高，那么只把当前跳跃表再提高一层即可
            level = h.getLevel() + 1;
            // 给新增加的层生成一个新的头节点，down方向连接原来的头节点HeadNode，设置好层数level
            h = new HeadNode<>(null, null, h, null, null, level);
            this.head.setUp(h);
            // 更新this.head指向当前跳跃表的最高层
            this.head = h;
        }

        // 这个for循环，把值为key的节点全部上下串在一起，并设置所有节点的down域
        newNodes = new Node[level];
        for (int i = level-1; i >= 0; i--) {
            newNodes[i] = index = new Node<>(key, null, index, null, null);
        }
        // 设置所有新插入节点的up域
        for (int i = 1; i < newNodes.length; i++) {
            newNodes[i].setUp(newNodes[i-1]);
        }

        // 把生成的key串插入到跳跃表中
        for (int i = level-1; i >= 0; i--) {
            // 把节点连接到跳跃表当前层的链表当中
            newNodes[i].setLeft(pre);
            newNodes[i].setRight(pre.getRight());
            if(pre.getRight() != null){
                pre.getRight().setLeft(newNodes[i]);
            }
            pre.setRight(newNodes[i]);

            // 如果插完最上面一层链表，直接跳出循环
            if(i == 0){
                break;
            }

            // 当前链表插入完成，转到下一层链表继续插入操作
            while(pre.getUp() == null){
                pre = pre.getLeft();
            }
            pre = pre.getUp();
        }
    }

    /**
     * 跳跃表删除的元素
     * @param key
     */
    public void remove(T key){
        Node<T> pre = this.head;
        Node<T> cur = pre.getRight();

        // 搜索跳跃表，找key元素
        for(;;){
            if(cur != null){
                if(cur.getData().compareTo(key) < 0){
                    pre = cur;
                    cur = cur.getRight();
                    continue;
                }

                if(cur.getData().compareTo(key) == 0){
                    // 找到了待删除的数据
                    break;
                }
            }

            if(pre.getDown() == null){
                break;
            }
            pre = pre.getDown();
            cur = pre.getRight();
        }

        if(cur == null){
            return; // 表示未找到key，直接返回
        }

        // 把从cur开始的垂直的key串从跳跃表中全部删除
        while(cur != null){
            pre = cur.getLeft();
            pre.setRight(cur.getRight());
            if(cur.getRight() != null){
                cur.getRight().setLeft(pre);
            }

            cur = cur.getDown();
        }

        // 删除完成后，从最上面一层开始检查，如果出现层数只剩头节点，那么层数就要缩减
        Node<T> h = this.head;
        while(h.getRight() == null
                && h.getDown() != null){
            h = h.getDown();
        }
        this.head = (HeadNode<T>) h;
    }

    /**
     * 跳跃表的查询操作
     * @param key
     * @return
     */
    public boolean get(T key){
        Node<T> pre = this.head;
        Node<T> cur = pre.getRight();

        for(;;){
            if(cur != null){
                if(cur.getData().compareTo(key) < 0){
                    pre = cur;
                    cur = cur.getRight();
                    continue;
                }

                if(cur.getData().compareTo(key) == 0){
                    return true;
                }
            }

            if(pre.getDown() == null){
                return false;
            }

            pre = pre.getDown();
            cur = pre.getRight();
        }
    }

    /**
     * 抛硬币决定当前元素插入的层数
     * @return
     */
    private int getInsertLevel() {
        int level = 1;
        while(Math.random() >= 0.5){
            level++;
        }
        return level;
    }

    /**
     * 按层数打印跳跃表结构
     */
    public void show(){
        System.out.println("跳跃表共:" + this.head.getLevel() + "层");
        Node<T> h = this.head;
        while(h != null){
            Node<T> cur = h.getRight();
            while(cur != null){
                System.out.printf(cur.getData() + " ");
                cur = cur.getRight();
            }
            System.out.println();
            h = h.getDown();
        }
        System.out.println();
    }
}

测试代码如下：

public class SkipListTestUnit {
    public static void main(String[] args) {
        SkipList<Integer> sl = new SkipList<>();
        for (int i = 0; i < 100; i++) {
            sl.put(i);
        }
        sl.show();

        sl.remove(5);
        sl.remove(4);
        sl.show();

        System.out.println(sl.get(4));

        sl.put(4);
        sl.show();

        System.out.println(sl.get(4));
    }
}