1. 快速了解跳表

跳跃表(简称跳表)由美国计算机科学家William Pugh发明于1989年。他在论文《Skip lists: a probabilistic alternative to balanced trees》中详细介绍了跳表的数据结构和插入删除等操作。

跳表(SkipList，全称跳跃表)是用于有序元素序列快速搜索查找的一个数据结构，跳表是一个随机化的数据结构，实质就是一种可以进行二分查找的有序链表。跳表在原有的有序链表上面增加了多级索引，通过索引来实现快速查找。跳表不仅能提高搜索性能，同时也可以提高插入和删除操作的性能。它在性能上和红黑树，AVL树不相上下，但是跳表的原理非常简单，实现也比红黑树简单很多。

回顾链表，我们知道链表和顺序表(数组)通常都是相爱相杀，成对出现，各有优劣。而链表的优势就是更高效的插入、删除。痛点就是查询很慢很慢！每次查询都是一种O(n)复杂度的操作。

image.png
这是一个带头结点的链表(头结点相当于一个固定的入口，不存储有意义的值)，每次查找都需要一个个枚举，相当的慢，我们能不能稍微优化一下，让它稍微跳一跳呢？
答案是可以的，我们知道很多算法和数据结构以空间换时间，我们在上面加一层索引，让部分节点在上层能够直接定位到，这样链表的查询时间近乎减少一半。
image.png
这样，在查询某个节点的时候，首先会从上一层快速定位节点所在的一个范围，如果找到具体范围向下然后查找代价很小，当然在表的结构设计上会增加一个向下的索引(指针)用来查找确定底层节点。平均查找速度平均为O(n/2)。但是当节点数量很大的时候，它依旧很慢很慢。我们都知道二分查找是每次都能折半的去压缩查找范围，要是有序链表也能这么跳起来那就太完美了。没错跳表就能让链表拥有近乎的接近二分查找的效率的一种数据结构，其原理依然是给上面加若干层索引，优化查找速度。
image.png
通过上图你可以看到，通过这样的一个数据结构对有序链表进行查找都能近乎二分的性能。就是在上面维护那么多层的索引，首先在最高级索引上查找最后一个小于当前查找元素的位置，然后再跳到次高级索引继续查找，直到跳到最底层为止，这时候以及十分接近要查找的元素的位置了(如果查找元素存在的话)。由于根据索引可以一次跳过多个元素，所以跳查找的查找速度也就变快了。

对于理想的跳表，每向上一层索引节点数量都是下一层的1/2。那么如果n个节点增加的节点数量(1/2+1/4…) < n。并且层数较低，对查找效果影响不大。但是对于这么一个结构，你可能会疑惑，这样完美的结构真的存在吗？
大概率不存在的，因为作为一个链表，少不了增删该查的一些操作。而删除和插入可能会改变整个结构，所以上面的这些都是理想的结构，在插入的时候是否添加上层索引是个概率问题(1/2的概率)，在后面会具体讲解。

2. 跳表的增删改查

在实现本跳表的过程为了便于操作，我们将跳表的头结点(head)的key设为int的最小值(一定满足左小右大方便比较)。

对于每个节点的设置，设置成SkipNode类，为了防止初学者将**_next_**向下还是向右搞混，直接设置right，down两个指针。

  1. class SkipNode<T>
  2. {
  3.     int key;
  4.     T value;
  5.     SkipNode right,down;//右下个方向的指针
  6.     public SkipNode (int key,T value) {
  7.         this.key=key;
  8.         this.value=value;
  9.     }
  10. }

跳表的结构和初始化也很重要，其主要参数和初始化方法为：

  1. public class SkipList <T> {
  3.     SkipNode headNode;//头节点，入口
  4.     int highLevel;//当前跳表索引层数
  5.     Random random;// 用于投掷硬币
  6.     final int MAX_LEVEL = 32;//最大的层
  8.     SkipList(){
  9.         random=new Random();
  10.         headNode=new SkipNode(Integer.MIN_VALUE,null);
  11.         highLevel=0;
  12.     }
  13.     //其他方法
  14. }

3. 查询操作

很多时候链表也可能这样相连仅仅是某个元素或者key作为有序的标准。所以有可能链表内部存在一些value。不过修改和查询其实都是一个操作，找到关键数字(key)。并且查找的流程也很简单，设置一个临时节点team=head。
例如下图查询12节点，当**team**不为**null**其流程大致如下：

  1. 从_team_节点出发，如果当前节点的_key_与查询的_key_相等，那么返回当前节点(如果是修改操作那么一直向下进行修改值即可)。
  2. 如果_key_不相等，且右侧为**_null_**，那么证明只能向下(结果可能出现在下右方向)，此时_team=team.down_
  3. 如果_key_不相等，且右侧不为_null_，且右侧节点_key_小于待查询的_key_。那么说明同级还可向右，此时_team=team.right_
  4. 如果key不相等，且右侧不为null，且右侧节点key大于待查询的key。此时team=team.down。说明如果有结果的话就在这个索引和下个索引之间

    如果有 prev指针的话，team=team.prev，例如在7处，查找6，可以prev回头去4处

最终将按照这个步骤返回正确的节点或者null(说明没查到)。
image.png
而这块的代码也非常容易：

  1. public SkipNode search(int key) {
  2.     SkipNode team = headNode;
  3.     while (team != null) {
  4.         if(team.key == key)
  5.         {
  6.             return team;
  7.         }
  8.         else if(team.right == null)//右侧没有了，只能下降
  9.         {
  10.             team = team.down;
  11.         }
  12.         else if(team.right.key > key)//需要下降去寻找
  13.         {
  14.             team = team.down;
  15.         }
  16.         else //右侧比较小向右
  17.         {
  18.             team = team.right;
  19.         }
  20.     }
  21.     return null;
  22. }

4. 删除操作

删除操作比起查询稍微复杂一丢丢，但是比插入简单。删除需要改变链表结构所以需要处理好节点之间的联系。对于删除操作你需要谨记以下几点：

  1. 删除当前节点和这个节点的前后节点都有关系
  2. 删除当前层节点之后，下一层该_key_的节点也要删除，一直删除到最底层

根据这两点分析一下：如果找到当前节点了，它的前面一个节点怎么查找呢？

这个总不能再遍历一遍吧！有的使用四个方向的指针(上下左右)用来找到左侧节点。是可以的，但是这里可以特殊处理一下 ，不直接判断和操作节点，先找到待删除节点的左侧节点。通过这个节点即可完成删除，然后这个节点直接向下去找下一层待删除的左侧节点。

下图删除10的流程，设置一个临时节点team=head，当**team**不为**null**具体循环流程为：

  1. 如果**team**右侧为**null**，那么team=team.down(之所以敢直接这么判断是因为左侧有头结点在左侧，不用担心特殊情况)
  2. 如果team右侧不 为null，并且右侧的**key**等于待删除的**key**，那么先删除节点，再team向下team=team.down为了删除下层节点。
  3. 如果team右侧不 为null，并且右侧**key**小于待删除的**key**，那么team向右team=team.right。
  4. 如果team右侧不 为null，并且右侧**key**大于待删除的**key**，那么team向下team=team.down，在下层继续查找删除节点。

image.png
删除操作实现的代码如下：

  1. public void delete(int key)//删除不需要考虑层数
  2. {
  3.     SkipNode team=headNode;
  4.     while (team!=null) {
  5.         if (team.right == null) {//右侧没有了，说明这一层找到，没有只能下降
  6.             team=team.down;
  7.         }
  8.         else if(team.right.key==key)//找到节点，右侧即为待删除节点
  9.         {
  10.             team.right=team.right.right;//删除右侧节点
  11.             team=team.down;//向下继续查找删除
  12.         }
  13.         else if(team.right.key>key)//右侧已经不可能了，向下
  14.         {
  15.             team=team.down;
  16.         }
  17.         else { //节点还在右侧
  18.             team=team.right;
  19.         }
  20.     }
  21. }

5. 插入操作

插入操作在实现起来是最麻烦的，需要的考虑的东西最多。回顾查询，不需要动索引；回顾删除，每层索引如果有删除就是了。但是插入不一样了，插入需要考虑是否插入索引，插入几层等问题。由于需要插入删除所以我们肯定无法维护一个完全理想的索引结构，因为它耗费的代价太高。所以我们使用随机化的方法去判断是否向上层插入索引。即产生一个[0-1]的随机数如果小于0.5就向上插入索引，插入完毕后再次使用随机数判断是否向上插入索引。运气好这个值可能是多层索引，运气不好只插入最底层(这是100%插入的)。但是索引也不能不限制高度，我们一般会设置索引最高值如果大于这个值就不往上继续添加索引了。

我们一步步剖析该怎么做，其流程为：

  1. 首先通过上面查找的方式，找到待插入的左节点。插入的话最底层肯定是需要插入的，所以通过链表插入节点(需要考虑是否为末尾节点)
  2. 插入完这一层，需要考虑上一层是否插入，首先判断当前索引层级，如果大于最大值那么就停止(比如已经到最高索引层了)。否则设置一个随机数1/2的概率向上插入一层索引(因为理想状态下的就是每2个向上建一个索引节点)。
  3. 继续第二步的操作，直到概率退出或者索引层数大于最大索引层。

在具体向上插入的时候，实质上还有非常重要的细节需要考虑。首先如何找到上层的待插入节点 ？

这个各个实现方法可能不同，如果有左、上指向的指针那么可以向左向上找到上层需要插入的节点，但是如果只有右指向和下指向的我们也可以巧妙的借助查询过程中记录下降的节点。因为曾经下降的节点倒序就是需要插入的节点，最底层也不例外(因为没有匹配值会下降为null结束循环)。在这里我使用栈这个数据结构进行存储，当然使用List也可以。下图就是给了一个插入示意图。
image.png
其次如果该层是目前的最高层索引，需要继续向上建立索引应该怎么办？

首先跳表最初肯定是没索引的，然后慢慢添加节点才有一层、二层索引，但是如果这个节点添加的索引突破当前最高层，该怎么办呢？

这时候需要注意了，跳表的head需要改变了，新建一个ListNode节点作为新的head，将它的down指向老head，将这个head节点加入栈中(也就是这个节点作为下次后面要插入的节点)，就比如上面的9节点如果运气够好在往上建立一层节点，会是这样的。
image.png
插入上层的时候注意所有节点要新建(拷贝)，除了right的指向，down的指向也不能忘记，down指向上一个节点可以用一个临时节点作为前驱节点。如果层数突破当前最高层，头head节点(入口)需要改变。

这部分更多的细节在代码中注释解释了，详细代码为：

  1. public void add(SkipNode node)
  2. {
  4.     int key=node.key;
  5.     SkipNode findNode=search(key);
  6.     if(findNode!=null)//如果存在这个key的节点
  7.     {
  8.         findNode.value=node.value;
  9.         return;
  10.     }
  11.     Stack<SkipNode>stack=new Stack<SkipNode>();//存储向下的节点，这些节点可能在右侧插入节点
  12.     SkipNode team=headNode;//查找待插入的节点   找到最底层的哪个节点。
  13.     while (team!=null) {//进行查找操作 
  14.         if(team.right==null)//右侧没有了，只能下降
  15.         {
  16.             stack.add(team);//将曾经向下的节点记录一下
  17.             team=team.down;
  18.         }
  19.         else if(team.right.key>key)//需要下降去寻找
  20.         {
  21.             stack.add(team);//将曾经向下的节点记录一下
  22.             team=team.down;
  23.         }
  24.         else //向右
  25.         {
  26.             team=team.right;
  27.         }
  28.     }
  29.     int level=1;//当前层数，从第一层添加(第一层必须添加，先添加再判断)
  30.     SkipNode downNode=null;//保持前驱节点(即down的指向，初始为null)
  31.     while (!stack.isEmpty()) {
  32.         //在该层插入node
  33.         team=stack.pop();//抛出待插入的左侧节点
  34.         SkipNode nodeTeam=new SkipNode(node.key, node.value);//节点需要重新创建
  35.         nodeTeam.down=downNode;//处理竖方向
  36.         downNode=nodeTeam;//标记新的节点下次使用
  37.         if(team.right==null) {//右侧为null 说明插入在末尾
  38.             team.right=nodeTeam;
  39.         }
  40.         //水平方向处理
  41.         else {//右侧还有节点，插入在两者之间
  42.             nodeTeam.right=team.right;
  43.             team.right=nodeTeam;
  44.         }
  45.         //考虑是否需要向上
  46.         if(level>MAX_LEVEL)//已经到达最高级的节点啦
  47.             break;
  48.         double num=random.nextDouble();//[0-1]随机数
  49.         if(num>0.5)//运气不好结束
  50.             break;
  51.         level++;
  52.         if(level>highLevel)//比当前最大高度要高但是依然在允许范围内 需要改变head节点
  53.         {
  54.             highLevel=level;
  55.             //需要创建一个新的节点
  56.             SkipNode highHeadNode=new SkipNode(Integer.MIN_VALUE, null);
  57.             highHeadNode.down=headNode;
  58.             headNode=highHeadNode;//改变head
  59.             stack.add(headNode);//下次抛出head
  60.         }
  61.     }
  62. }

6. 总结

对于上面，跳表完整分析就结束啦，当然，你可能看到不同品种跳表的实现，还有的用数组方式表示上下层的关系这样也可以，但本文只定义right和down两个方向的链表更纯正化的讲解跳表。

对于跳表以及跳表的同类竞争产品：红黑树，为啥Redis的有序集合(zset) 使用跳表呢？

因为跳表除了查找插入维护和红黑树有着差不多的效率，它是个链表，能确定范围区间，而区间问题在树上可能就没那么方便查询啦。而JDK中跳跃表ConcurrentSkipListSet和ConcurrentSkipListMap。 有兴趣的也可以查阅一下源码。

对于学习，完整的代码是非常重要的，这里我把完整代码贴出来，需要的自取。

  1. import java.util.Random;
  2. import java.util.Stack;
  3. class SkipNode<T>
  4. {
  5.     int key;
  6.     T value;
  7.     SkipNode right,down;//左右上下四个方向的指针
  8.     public SkipNode (int key,T value) {
  9.         this.key=key;
  10.         this.value=value;
  11.     }
  13. }
  14. public class SkipList <T> {
  16.     SkipNode headNode;//头节点，入口
  17.     int highLevel;//层数
  18.     Random random;// 用于投掷硬币
  19.     final int MAX_LEVEL = 32;//最大的层
  20.     SkipList(){
  21.         random=new Random();
  22.         headNode=new SkipNode(Integer.MIN_VALUE,null);
  23.         highLevel=0;
  24.     }
  25.     public SkipNode search(int key) {
  26.         SkipNode team=headNode;
  27.         while (team!=null) {
  28.             if(team.key==key)
  29.             {
  30.                 return  team;
  31.             }
  32.             else if(team.right==null)//右侧没有了，只能下降
  33.             {
  34.                 team=team.down;
  35.             }
  36.             else if(team.right.key>key)//需要下降去寻找
  37.             {
  38.                 team=team.down;
  39.             }
  40.             else //右侧比较小向右
  41.             {
  42.                 team=team.right;
  43.             }
  44.         }
  45.         return null;
  46.     }
  48.     public void delete(int key)//删除不需要考虑层数
  49.     {
  50.         SkipNode team=headNode;
  51.         while (team!=null) {
  52.             if (team.right == null) {//右侧没有了，说明这一层找到，没有只能下降
  53.                 team=team.down;
  54.             }
  55.             else if(team.right.key==key)//找到节点，右侧即为待删除节点
  56.             {
  57.                 team.right=team.right.right;//删除右侧节点
  58.                 team=team.down;//向下继续查找删除
  59.             }
  60.             else if(team.right.key>key)//右侧已经不可能了，向下
  61.             {
  62.                 team=team.down;
  63.             }
  64.             else { //节点还在右侧
  65.                 team=team.right;
  66.             }
  67.         }
  68.     }
  69.     public void add(SkipNode node)
  70.     {
  71.         int key=node.key;
  72.         SkipNode findNode=search(key);
  73.         if(findNode!=null)//如果存在这个key的节点
  74.         {
  75.             findNode.value=node.value;
  76.             return;
  77.         }
  79.         Stack<SkipNode>stack=new Stack<SkipNode>();//存储向下的节点，这些节点可能在右侧插入节点
  80.         SkipNode team=headNode;//查找待插入的节点   找到最底层的哪个节点。
  81.         while (team!=null) {//进行查找操作
  82.             if(team.right==null)//右侧没有了，只能下降
  83.             {
  84.                 stack.add(team);//将曾经向下的节点记录一下
  85.                 team=team.down;
  86.             }
  87.             else if(team.right.key>key)//需要下降去寻找
  88.             {
  89.                 stack.add(team);//将曾经向下的节点记录一下
  90.                 team=team.down;
  91.             }
  92.             else //向右
  93.             {
  94.                 team=team.right;
  95.             }
  96.         }
  98.         int level=1;//当前层数，从第一层添加(第一层必须添加，先添加再判断)
  99.         SkipNode downNode=null;//保持前驱节点(即down的指向，初始为null)
  100.         while (!stack.isEmpty()) {
  101.             //在该层插入node
  102.             team=stack.pop();//抛出待插入的左侧节点
  103.             SkipNode nodeTeam=new SkipNode(node.key, node.value);//节点需要重新创建
  104.             nodeTeam.down=downNode;//处理竖方向
  105.             downNode=nodeTeam;//标记新的节点下次使用
  106.             if(team.right==null) {//右侧为null 说明插入在末尾
  107.                 team.right=nodeTeam;
  108.             }
  109.             //水平方向处理
  110.             else {//右侧还有节点，插入在两者之间
  111.                 nodeTeam.right=team.right;
  112.                 team.right=nodeTeam;
  113.             }
  114.             //考虑是否需要向上
  115.             if(level>MAX_LEVEL)//已经到达最高级的节点啦
  116.                 break;
  117.             double num=random.nextDouble();//[0-1]随机数
  118.             if(num>0.5)//运气不好结束
  119.                 break;
  120.             level++;
  121.             if(level>highLevel)//比当前最大高度要高但是依然在允许范围内 需要改变head节点
  122.             {
  123.                 highLevel=level;
  124.                 //需要创建一个新的节点
  125.                 SkipNode highHeadNode=new SkipNode(Integer.MIN_VALUE, null);
  126.                 highHeadNode.down=headNode;
  127.                 headNode=highHeadNode;//改变head
  128.                 stack.add(headNode);//下次抛出head
  129.             }
  130.         }
  132.     }
  133.     public void printList() {
  134.         SkipNode teamNode=headNode;
  135.         int index=1;
  136.         SkipNode last=teamNode;
  137.         while (last.down!=null){
  138.             last=last.down;
  139.         }
  140.         while (teamNode!=null) {
  141.             SkipNode enumNode=teamNode.right;
  142.             SkipNode enumLast=last.right;
  143.             System.out.printf("%-8s","head->");
  144.             while (enumLast!=null&&enumNode!=null) {
  145.                 if(enumLast.key==enumNode.key)
  146.                 {
  147.                     System.out.printf("%-5s",enumLast.key+"->");
  148.                     enumLast=enumLast.right;
  149.                     enumNode=enumNode.right;
  150.                 }
  151.                 else{
  152.                     enumLast=enumLast.right;
  153.                     System.out.printf("%-5s","");
  154.                 }
  156.             }
  157.             teamNode=teamNode.down;
  158.             index++;
  159.             System.out.println();
  160.         }
  161.     }
  162.     public static void main(String[] args) {
  163.         SkipList<Integer>list=new SkipList<Integer>();
  164.         for(int i=1;i<20;i++)
  165.         {
  166.             list.add(new SkipNode(i,666));
  167.         }
  168.         list.printList();
  169.         list.delete(4);
  170.         list.delete(8);
  171.         list.printList();
  172.     }
  173. }