30-跳表(Skip List)

首先来思考一个问题。

一个有序链表(下图),搜索,添加,删除的平均时间复杂度是多少?

通过对链表这种数据结构的了解可以知道

  1. 搜索必须要从表头节点开始,依次往后搜索,直到搜索到为止。所以链表搜索的时间复杂度为O(n)
  2. 添加也是一样的,需要从左往右依次搜索,直到找到合适的插入位置为止,所以时间复杂度为O(n)
  3. 删除依然是从左往右依次搜索,找到需要被删除的元素后,将元素删除掉,因此时间复杂度为O(n)

那么,能否通过二分搜索来优化有序链表,将搜索,添加,删除的平均时间复杂度降低至O(logn)?

答案是不能,因为链表没有像数组一样的高效随机访问(O(1)时间复杂度),所以不能像有序数组一样,直接进行二分搜索优化, 只能从头开始,或者从尾开始依次搜索,直到找到需要找的元素。因此不能通过二分搜索来进行优化。

既然不能通过二分搜索对链表进行优化,那么,是否有其他办法,让有序链表的搜索,添加,删除的平均时间复杂度降低至O(logn),有的,跳表就可以实现。

跳表(Skip List)

跳表,又叫做跳跃表,跳跃列表,在有序链表的基础上增加的“跳跃”的功能,是由William Pugh于1990年发布,设置的初衷是为了取代平衡树(比如红黑树)

跳表对比平衡树,有以下特点:

  1. 跳表的实现和维护更加简单。相信大家都知道,红黑树的实现确实太复杂了,需要考虑很多的情况
  2. 跳表的搜索,删除,添加的平均时间复杂度是O(long)
使用跳表优化链表

例如,下图是一个非常普通的链表,而且该链表是有序的

那怎么来对链表进行优化呢?

现在,可以将链表中的每一个节点想象成为一个公交车站,其中数组为公交站的名字,现在如果想从最左边开始,到达25这个公交站,按照现在的公交路线,经过公交站的顺序是从左往右的,最终到达25公交站

那如何才能办到,减少经过中间公交站的次数呢?是否可以办到从3公交站直接到达25公交站呢?是可以的,如果现在开通一条快速公交,可以从3公交站直接到达25公交站的话,就不用经过中间的这些公交站,直接就到达25公交站了,这样就可以更快的到达最终想要达到的站,这就是对链表进行优化的基本思路。

所以对上图的链表进行初步优化的话,结果如下

这样,就在原来公交线路的基础上,增设了一条快速公交,减少了中间经过的站点,所以如果现在想要达到某个站的话,就可以优先选择快速路线,如此一来,就可以节省时间。

那么,能否再更快一点呢?更快一点则就是再增设一条经过站点更少的公交线路,这样从起点到达终点经过的站点更少,可以进一步节省时间,所以可以在原来快速路线的基础上,再提升一层,组成一个新的途径站点。重复压缩经过的站点,直到更优为止。所以上面的公交线路,经过优化后的结果如下

所以,上面的流程,就是链表的优化思路,其实就是在有序链表的基础上,增加了一个跳跃的功能

跳表的搜索

搜索流程如下:

  1. 从顶层链表的首元素开始,从左往右搜索,直到找到一个大于或等于目标的元素,或者到达当前层链表的尾部
  2. 如果该元素等于目标元素,则表明该元素已被找到
  3. 如果该元素大于目标元素或已经到达链表的尾部,则退回到当前层的前一个元素,然后转入下一层进行搜索

所以跳表的搜索实现如下:

public V remove(K key) {
    keyCheck(key);
    Node<K,V> node = first;
    Node<K,V>[] prevs = new Node[level];
    boolean exist = false;
    for (int i = level - 1; i >= 0 ; i--) {
        int cmp = -1;
        while (node.nexts[i] != null && (cmp = compare(node.nexts[i].key,key)) < 0 ) {
            node = node.nexts[i];
        }
        prevs[i] = node;
        if (cmp == 0) exist = true;
    }
    if (!exist) return null;//说明不存在
    Node<K,V> removedNode = node.nexts[0];
    for (int i = 0; i < removedNode.nexts.length; i++) {
        prevs[i].nexts[i] = removedNode.nexts[i];
    }
    size--;
    //更新跳表的层数
    int newLevel = level;
    while (--newLevel >0 && first.nexts[newLevel] == null ) {
        level = newLevel;
    }
    return removedNode.value;
}
跳表的添加

假设现在要往下面的链表中插入一个新的节点17(红色节点)

分析:

  1. 通过搜索,找到插入节点17的合适位置
  2. 随机确定节点的层数
  3. 更新对应层节点的next

根据思路,实现如下:

public V put(K key, V value) {
    keyCheck(key);
    Node<K,V> node = first;
    Node<K,V>[] prevs = new Node[level];//用来存放插入节点的前驱节点
    for (int i = level - 1; i >= 0 ; i--) {
        int cmp = -1;
        while (node.nexts[i] != null && (cmp = compare(node.nexts[i].key,key)) < 0) {
            node = node.nexts[i];//更新node
        }

        if (cmp == 0) {
            //节点本来就存在,覆盖key对应的value
            V oldValue = node.nexts[i].value;
            node.nexts[i].value = value;
            return oldValue;
        }

        //保存前驱节点
        prevs[i] = node;
    }
    //说明当前key 不存在,并且确定前驱节点为node
    int newLevel = randomLevel();
    Node<K,V> newNode = new Node<>(key,value,newLevel);
    //遍历所有的前驱节点,更新每一层的连线
    for (int i = 0; i < newLevel; i++) {
        if (i >= level) {//说明新节点的层数大于原来节点的最大层数,直接从头节点连线到当前节点
            first.nexts[i] = newNode;
        } else {
            newNode.nexts[i] =  prevs[i].nexts[i];
            prevs[i].nexts[i] = newNode;
        }
    }
    //更新跳表的层数
    level = Math.max(level,newLevel);
    size++;
    return null;
}
跳表的删除

流程如下:

  1. 搜索对应的节点
  2. 如果没搜索到,直接返回
  3. 如果搜索到了,更新对应层节点的next

根据思路,实现如下:

public V get(K key) {
    keyCheck(key);
    Node<K,V> node = first;
    //nexts的索引是0 - (level - 1)
    for (int i = level - 1; i >= 0 ; i--) {
        int cmp = -1;
        while (node.nexts[i] != null && (cmp = compare(node.nexts[i].key,key)) < 0 ) {
            //当前节点的key,小于要找的节点的ke||说明找到当前层的最后了,所以应该会退到上一个节点,然后往下一层继续找
            node = node.nexts[i];//更新node
        }

        if (cmp == 0) {
            //说明找到了
            return node.nexts[i].value;
        }
        //当前节点的key,大于要找的节点的key,进入下一层进行查找
        //返回到上一个节点,进入下一层继续查找
    }
    //直到最后,还没找到,说明不存在
    return null;
}
跳表的层数

关于跳表层数的相关结论

  • 跳表是按层构造的,底层是一个普通的有序链表,高层相当于是底层的“快速通道”
    • 在第i层中的元素按某个固定的概率P(通常为1/2或1/4)出现在第i + 1 层中,产生越高的层数,概率越低
      所以有以下结论
      1. 元素层数恰好等于1的概率为1 - P
      2. 元素层数大于等于2的概率为P,而元素层数恰好等于2的概率为P* (1 - P)
      3. 元素层数大于等于3的概率为P2,而元素层数恰好等于3的概率为P2* (1 - P)
      4. 元素层数大于等于4的概率为P3,而元素层数恰好等于4的概率为P3* (1 - P)
      5. ...
      6. 一个元素的平均层数是1 / (1- P)
  • 当P = 1 / 2时,每个元素所包含的平均指针数量是2
  • 当P = 1 / 4时,每个元素所包含的平均指针数量是1.33(从指针数量来看,跳表会比红黑树更节省内存,因为红黑树每个节点都有至少2个指针)
跳表复杂度分

通过前面的分析,可以计算出跳表每一层的元素数量

  1. 第一层(最底层)链表固定有n个元素
  2. 第二层链表平均有n * p个元素
  3. 第三层链表平均有n * p ^ 2个元素
  4. 第K层链表平均有n * p ^ K个元素

所以有以下结论:

  1. 最高层的层数为log(1/p) n,平均有1 / p个元素
  2. 在搜索时,每一层链表的预期查找步数最多是1 / P ,所以总的查找步数是 -(log(1/p) n),所以,时间复杂度为O(logn)

demo下载地址

完!

推荐阅读更多精彩内容