跳表：为什么Redis一定要用跳表来实现有序集合

文章来源于极客时间前google工程师−王争专栏。

二分查找底层依赖的是数组随机访问的特性，所以只能用数组来实现。如果数据存储在链表中，就真的没法使用二分查找算法了吗？

我们可以对链表稍加改造，就可以支持类似“二分”的查找算法。改造之后的数据结构叫作“跳表（Skip list）”

跳表是各方面性能都比较优秀的动态数据结构，可以支持快速的插入、删除、查找操作，写起来不复杂，甚至可以替代红黑树（Red-black tree）。

问题：Redis为什么会选择用跳表来实现有序集合呢？

如何理解跳表？

对于一个单链表来讲，即便链表中存储的数据是有序的，查找某个数据，也只能从头到尾遍历链表。时间复杂度是O(n)。

如何提高查找效率呢？

像图中那样，对链表建立一级“索引”，每两个结点提取一个结点到上一级，我们把抽出来的那一级叫作索引或索引层。down表示down指针，指向下一级结点。

加一层索引之后，查找一个结点需要遍历的结点个数减少了，也就是说查找效率提高了。如果再加一级索引呢？效率会不会提升更多呢？

在第一级结点的基础上，每两个结点就抽出一个结点到第二级索引。现在我们来查找16，只需要遍历6个结点就可以了。

如下图模拟数据量大的过程，建立5级索引，包含64个结点的链表。

从图中可以看出，原来没有索引的时候，查找62需要遍历62个结点，现在只需要遍历11个结点。所以当链表长度n比较大时，比如1000、10000的时候，在构建索引之后，查找效率的提升会非常明显。

这种链表加多级索引的结构，就是跳表。

用跳表查询到底有多快？

用时间复杂度衡量。在一个单链表中查询某个数据的时间复杂度是O(n)。那在一个具有多级索引的跳表中，查询某个数据的时间复杂度是多少呢？

假设链表有n个结点，每两个结点作为上一级索引的结点，第一级索引的结点个数大约是n/2，第二级n/4，第k级索引的结点个数就是n/(2^k)。

假设索引有h级，最高级的索引有2个结点。通过公式可以得到n/(2^h)=2，从而求得h=log2n-1。如果包含原始链表这一层，整个跳表的高度就是log2n。我们在跳表中查询某个数据的时候，如果每一层都要遍历m个结点，那么在跳表中查询一个数据的时间复杂度就是O(m*logn)。

那么这个m值是多少呢？按照前面这种索引结构，我们每一级索引都最多只需要遍历3个结点，也就是说m=3，为什么呢？如下图所示

因为m=3，所以在跳表中查询任意数据的时间复杂度就是O(logn)。这个查找的时间复杂度跟二分查找是一样的。换句话说，我们其实是基于单链表实现了二分查找。这种查询效率的提升，前提是建立了很多级索引，也是空间换时间思想的体现。

跳表是不是很浪费内存？

分析跳表的空间复杂度。

索引的结点总和就是等比数列求和，n/2+n/4+n/8+…+8+4+2=n-2，所以跳表的空间复杂度是O(n)

也就是说，如果将包含n个结点的单链表构成跳表，我们需要额外再用接近n个结点的存储空间。那我们有没有办法降低索引占用的内存空间呢？

如果我们每三个结点或者五个结点，抽一个结点到上级索引，是不是就不用那么多索引结点了呢？

总的索引结点大约就是 n/3+n/9+n/27+…+9+3+1=n/2。尽管空间复杂度还是O(n)，但比上面的每两个结点抽一个结点的索引构建方法，要减少一半的索引结点存储空间。

在软件开发中，我们不必太在意索引占用的额外空间。在讲数据结构与算法时，我们习惯性地把要处理的数据看成整数，但是在实际的软件开发中，原始链表中存储的有可能是很大的对象，而索引结点只需要存储关键值和几个指针，并不需要存储对象，所以当对象比索引结点大很多时，那索引占用的额外空间就可以忽略了。

高效的动态插入和删除

插入

跳表不仅支持查找操作，还支持动态地插入、删除操作，插入删除操作的时间复杂度也是O(logn)

单链表，一旦定位好要插入的位置，插入结点的时间复杂度很低，就是O(1)。但是，查找操作比较耗时。

对于纯粹的单链表，需要遍历每个结点，来找到插入的位置。但是，对于跳表来说，查找某个结点的时间复杂度是O(logn)，所以查找某个数据应该插入的位置，方法也是类似的，时间复杂度也是O(logn)。

删除

如果这个结点在索引中也有出现，我们除了要删除原始链表中的结点，还要删除索引中的。

单链表中的删除操作需要拿到要删除结点的前驱结点，然后通过指针操作完成删除。如果是双向链表，就不需要考虑。

跳表索引动态更新

当我们不停地往跳表中插入数据时，如果我们不更新索引，就可以出现某2个索引结点之间数据非常多的情况。极端情况下，跳表还会退化成单链表。

**作为一种动态数据结构，我们需要某种手段来维护索引与原始链表大小之间的平衡。**避免复杂度退化，查找、插入、删除操作性能下降。

跳表通过随机函数来维护“平衡性”。

当我们往跳表中插入数据时，我们可以选择同时将这个数据插入到部分索引层中。如果选择加入哪些索引层呢？

我们通过一个随机函数，来决定将这个结点插入到哪几级索引中，比如随机函数生成了值k，那么我们就将这个结点添加到第一级到第k级这k级索引中。

随机函数的选择很有讲究，从概率上来讲，能保证跳表的索引大小和数据大小平衡性，不至于性能过度退化。

跳表java实现见Github

解答开篇

Redis中的有序集合是通过跳表实现的，还用到了散列表。Redis中的有序集合支持的核心操作主要有下面几个：

插入一个数据
删除一个数据
查找一个数据
按照区间查找数据（比如查找值在[100,356]之间的数据）
迭代输出有序序列

按照区间查找数据，红黑树的效率没有跳表高。跳表可以做到O(logn)的时间复杂度定位区间的起点，然后在原始链表中顺序往后遍历就可以了。这样做非常高效。

Redis之所以用跳表来实现有序集合，还有以下几个原因：

跳表更容易代码实现，可读性好，不容易出错
跳表更加灵活，可以通过改变索引构建策略，有效平衡执行效率和内存消耗

跳表也不能完全代替红黑树。红黑树出现的早，很多语言的Map类型都是通过红黑树来实现的。做业务开发可以直接拿来用，如果要使用跳表，必须要自己实现。

思考

如果每三个或者五个结点提取一个结点作为上级索引，对应的在跳表中查询数据的时间复杂度是多少呢？

跳表java实现

/**
 * 跳表的一种实现方法。
 * 跳表中存储的是正整数，并且存储的是不重复的。
 *
 * Author：ZHENG
 */
public class SkipList {

  private static final int MAX_LEVEL = 16;

  private int levelCount = 1;

  private Node head = new Node();  // 带头链表

  private Random r = new Random();

  public Node find(int value) {
    Node p = head;
    for (int i = levelCount - 1; i >= 0; --i) {
      while (p.forwards[i] != null && p.forwards[i].data < value) {
        p = p.forwards[i];
      }
    }

    if (p.forwards[0] != null && p.forwards[0].data == value) {
      return p.forwards[0];
    } else {
      return null;
    }
  }

  public void insert(int value) {
    int level = randomLevel();
    Node newNode = new Node();
    newNode.data = value;
    newNode.maxLevel = level;
    Node update[] = new Node[level];
    for (int i = 0; i < level; ++i) {
      update[i] = head;
    }

    // record every level largest value which smaller than insert value in update[]
    Node p = head;
    for (int i = level - 1; i >= 0; --i) {
      while (p.forwards[i] != null && p.forwards[i].data < value) {
        p = p.forwards[i];
      }
      update[i] = p;// use update save node in search path
    }

    // in search path node next node become new node forwords(next)
    for (int i = 0; i < level; ++i) {
      newNode.forwards[i] = update[i].forwards[i];
      update[i].forwards[i] = newNode;
    }

    // update node hight
    if (levelCount < level) levelCount = level;
  }

  public void delete(int value) {
    Node[] update = new Node[levelCount];
    Node p = head;
    for (int i = levelCount - 1; i >= 0; --i) {
      while (p.forwards[i] != null && p.forwards[i].data < value) {
        p = p.forwards[i];
      }
      update[i] = p;
    }

    if (p.forwards[0] != null && p.forwards[0].data == value) {
      for (int i = levelCount - 1; i >= 0; --i) {
        if (update[i].forwards[i] != null && update[i].forwards[i].data == value) {
          update[i].forwards[i] = update[i].forwards[i].forwards[i];
        }
      }
    }
  }

  // 随机 level 次，如果是奇数层数 +1，防止伪随机
 private int randomLevel() {
    int level = 1;
    for (int i = 1; i < MAX_LEVEL; ++i) {
      if (r.nextInt() % 2 == 1) {
        level++;
      }
    }

    return level;
  }

  public void printAll() {
    Node p = head;
    while (p.forwards[0] != null) {
      System.out.print(p.forwards[0] + " ");
      p = p.forwards[0];
    }
    System.out.println();
  }

  public class Node {
    private int data = -1;
    private Node forwards[] = new Node[MAX_LEVEL];
    private int maxLevel = 0;

    @Override
    public String toString() {
      StringBuilder builder = new StringBuilder();
      builder.append("{ data: ");
      builder.append(data);
      builder.append("; levels: ");
      builder.append(maxLevel);
      builder.append(" }");

      return builder.toString();
    }
  }

}