【链表】设计跳表

题目描述

设计一个跳表。

跳表是能在O(log(n))时间内完成增加、删除、搜索到数据结构。

解题思路

先准备一个有上限大小的NODE数据结构如下：

    public class SkipListNode {

        int value;
        SkipListNode[] forward;

        public SkipListNode(int value, int level) {
            this.value = value;
            this.forward = new SkipListNode[level];
        }

    }

说明：value就是具体存储的值； forward是下一个节点位置，对应于链表中的next，由于跳表存在多个next，这里用数组表示，这也就要求这个跳表有上限大小。

---

根据上述SkipListNode，来定义一个基本的跳表：

class Skiplist {

    int MAX_LEVEL = 32;
    SkipListNode head;
    int level;
    Random random;

    public Skiplist() {
        this.head = new SkipListNode(-1, MAX_LEVEL);
        this.level = 0;
        this.random = new Random();
    }
}

说明：

MAX_LEVEL为跳表的最大层数量；

head是跳表的初始节点，默认为-1；

level是这个跳表的层数，默认是0；

random是一个随机函数，用于计算每个跳表的节点是否需要添加level。 

---

1. search，指定一个target，查询是否包含在跳表中；

    public boolean search(int target) {
        SkipListNode curr = this.head;
        for (int i = level - 1; i >= 0; i--) {
            while (curr.forward[i] != null && curr.forward[i].value < target) {
                curr = curr.forward[i];
            }

            // 注意点
            if (curr.forward[i] != null && curr.forward[i].value == target) {
                return true;
            }
        }
        return false;
    }

搜索的时候从上往下搜索；

1.先判断当前节点是否存在下一个节点，并且下一个节点的值是否小于target， 如果是则继续循环；

2.在循环完毕后判断，当前节点的下一个节点是否不为NULL，并且等于target，如果等于则直接返回true；

---

2. add，指定一个num，将这个数字添加到跳表中；

    public void add(int num) {
        SkipListNode[] update = new SkipListNode[MAX_LEVEL];

        // 这个地方没有看懂，我理解是为了保证如果是第一个元素也能访问到。
        Arrays.fill(update, head);

        SkipListNode curr = head;
        for (int i = level - 1; i >= 0; i--) {
            while (curr.forward[i] != null && curr.forward[i].value < num) {
                curr = curr.forward[i];
            }
            update[i] = curr;
        }

        int lv = randomLevel();
        level = Math.max(level, lv);

        SkipListNode newNode = new SkipListNode(num, lv);
        for (int i = 0; i < lv; i++) {
            newNode.forward[i] = update[i].forward[i];
            update[i].forward[i] = newNode;
        }
    }

    private int randomLevel() {
        int lv = 1;
        while (random.nextDouble() < 0.25 && lv < MAX_LEVEL) {
            lv++;
        }
        return lv;
    }

参考删除操作，增加一个update记录要添加的层；这个里面最特殊的地方是对update的节点进行了初始化，并且使用的是head节点，主要是考虑在把update添加到第一个节点时不要有数据关系丢失。

使用随机函数来计算level，其实就是在小于MAX_LEVEL的情况下做随机

private int randomLevel() {
    int lv = 1;
    while (random.nextDouble() < 0.25 && lv < MAX_LEVEL) {
        lv++;
    }
    return lv;
}

获得层数后从下往上添加节点，添加操作：

            newNode.forward[i] = update[i].forward[i];
            update[i].forward[i] = newNode;

---

3. erase，指定一个num，将这个数字从跳表中删除； 

    public boolean erase(int num) {
        SkipListNode[] update = new SkipListNode[level];
        SkipListNode curr = head;
        int count = 0;
        for (int i = level - 1; i >= 0; i--) {
            while (curr.forward[i] != null && curr.forward[i].value < num) {
                curr = curr.forward[i];
            }
            if (curr.forward[i] != null && curr.forward[i].value == num) {
                update[i] = curr;
                count++;
            }
        }


        for (int i = 0; i < count; i++) {
            update[i].forward[i] = update[i].forward[i].forward[i];
        }

        for (int i = count - 1; i >= 0; i--) {
            if (update[i].forward == null) {
                level--;
            }
        }

        return count > 0;
    }

这个和搜索很相似，还是从上往下搜索，这里增加一个update数组用于记录要删除节点的父亲节点，增加一个count记录要删除的层数：

1.先判断当前节点是否存在下一个节点，并且下一个节点的值是否小于target， 如果是则继续循环；

2.在循环完毕后判断，当前节点的下一个节点是否不为NULL，并且等于target，将这个节点放到update中；并且将count++。

在全部遍历完成后，执行删除操作，这个时候，从下往上删除（0到count-1）；

update[i].forward[i] = update[i].forward[i].forward[i];

 在删除完成后恢复一下level数，从上往下计算（count-1到0），只要update的下一个节点为NULL则对level进行减一操作；

---

代码实现

整体代码如下：

import java.util.Arrays;
import java.util.Random;

class Skiplist {

    int MAX_LEVEL = 32;
    SkipListNode head;
    int level;
    Random random;

    public Skiplist() {
        this.head = new SkipListNode(-1, MAX_LEVEL);
        this.level = 0;
        this.random = new Random();
    }


    public boolean search(int target) {
        SkipListNode curr = this.head;
        for (int i = level - 1; i >= 0; i--) {
            while (curr.forward[i] != null && curr.forward[i].value < target) {
                curr = curr.forward[i];
            }

            // 注意点
            if (curr.forward[i] != null && curr.forward[i].value == target) {
                return true;
            }
        }
        return false;
    }

    public void add(int num) {
        SkipListNode[] update = new SkipListNode[MAX_LEVEL];

        // 这个地方没有看懂，我理解是为了保证如果是第一个元素也能访问到。
        Arrays.fill(update, head);

        SkipListNode curr = head;
        for (int i = level - 1; i >= 0; i--) {
            while (curr.forward[i] != null && curr.forward[i].value < num) {
                curr = curr.forward[i];
            }
            update[i] = curr;
        }

        int lv = randomLevel();
        level = Math.max(level, lv);

        SkipListNode newNode = new SkipListNode(num, lv);
        for (int i = 0; i < lv; i++) {
            newNode.forward[i] = update[i].forward[i];
            update[i].forward[i] = newNode;
        }
    }

    private int randomLevel() {
        int lv = 1;
        while (random.nextDouble() < 0.25 && lv < MAX_LEVEL) {
            lv++;
        }
        return lv;
    }

    public boolean erase(int num) {
        SkipListNode[] update = new SkipListNode[level];
        SkipListNode curr = head;
        int count = 0;
        for (int i = level - 1; i >= 0; i--) {
            while (curr.forward[i] != null && curr.forward[i].value < num) {
                curr = curr.forward[i];
            }
            if (curr.forward[i] != null && curr.forward[i].value == num) {
                update[i] = curr;
                count++;
            }
        }


        for (int i = 0; i < count; i++) {
            update[i].forward[i] = update[i].forward[i].forward[i];
        }

        for (int i = count - 1; i >= 0; i--) {
            if (update[i].forward == null) {
                level--;
            }
        }

        return count > 0;
    }

    public class SkipListNode {

        int value;
        SkipListNode[] forward;

        public SkipListNode(int value, int level) {
            this.value = value;
            this.forward = new SkipListNode[level];
        }

    }

}

总结

这里的跳表借用了数组，只需要考虑向右查询下一个节点，减轻了向下查询下一个节点的操作；

跳表这个数据结构设计的挺巧妙的，先要理解基本原理，代码实现上，注意细节，搜了一下目前redis中有使用到跳表。