来一起写一个跳表吧

　　跳表全称叫做跳跃表，简称跳表，是一个随机化的数据结构，实质就是一种可以进行二分查找的有序链表。跳表在原有的有序列表上面增加多级索引，通过索引来实现快速查找。跳表不仅能提高搜索性能，同时也提高插入和删除的性能，redis中的有序集合set就是用跳表实现的，面试时候也经常会问。 
　

 

 

 　　这里我们原始数据个数n=10，以间隔k=2建立索引，则第一层索引10/2=5个，第二层⌈10/2^2⌉=3个，第三层⌈10/2^3⌉=2个，第四层⌈10/2^4⌉=1个。根据上图我们来分析一下，跳表的结构是一棵树（除原始数据层外），树的左指针指向对应的下一层链表的节点，右指针指向当前链表的下一个节点，且树高为log(n)，对于每一层需要比较的次数最多为k，则时间复杂度为O(k*log(n))，k为常数项，所以跳表查询时间复杂度为O(log(n))。因为需要额外的空间存储索引，是典型的以空间换时间，空间复杂度为O(n)。
　　接下来我们自己实现一个跳表：
　　节点数据结构定义：根据跳表结构，节点首先需要一个value存储当前节点值，需要一个next指针指向同一层的下一个节点，需要一个nodeValue指针指向下一层对应节点，但是这里为了插入删除方便，引入了一个prev指针，指向同一层的上一个节点。

class Node {
//当前节点值
private Integer value;
//当前节点所属链表下一个节点
private Node next;
//当前节点所属链表上一个节点
private Node prev;
//当前节点指向的另一个索引链表/原始值链表节点
private Node nodeValue;
Node(Integer value) {
this.value = value;
}
}

　　初始化一个跳表：跳表的建立需要在数据有序的基础上，然后从下往上在下一层的基础上，间隔k生成当前层的节点，新生成的节点需要与当前层上一个节点连接起来，并且指向生成它的下一层节点。

/**
* 原始数据链表
*/
private Node head ;
/**
* 最终的跳表结构：保存索引链表及原始链表
*/
private List<Node> indexList;
/**
* 跳表层数
*/
private int level;

/**
* 初始化
*/
public void init() {
//带头节点的链表，便于操作
head = new Node(-1);
head.next = head;
indexList = new ArrayList<>();
level = 0;
}
/**
* 初始化跳表
* @param k 间隔
* @param nums 原始数据（已排序）
*/
public void init(int k, int[] nums) {
//初始化数据链表
Node temp = head;
for (int num : nums) {
Node cur = new Node(num);
cur.prev = temp;
temp.next = cur;
temp = temp.next;
}
//新节点保存（最底层）
indexList.add(head);

//循环生成索引结构，结束条件，当层仅一个元素
temp = head.next;
while (true) {
//当前链表第几个元素
int i = 0;
//生成另一条链表长度
int size = 0;
Node indexNode = new Node(-1);
indexNode.next = indexNode;
Node indexNodeTemp = indexNode;
while (null != temp) {
//间隔k生成节点
if (i % k == 0) {
Node curNode = new Node(temp.value);
curNode.nodeValue = temp;
curNode.prev = indexNodeTemp;
indexNodeTemp.next = curNode;
indexNodeTemp = indexNodeTemp.next;
++ size;
}
++ i;
temp = temp.next;
}
indexList.add(indexNode);
temp = indexNode.next;
//当生成的索引链表仅1时不需要再继续生成
if (size == 1) {
break;
}
}
level = indexList.size();
}

 　　从跳表中查找元素：从最顶层索引链表开始查找，找到第一个大于当前节点的元素，则需要查找的元素在当前节点与之前节点之间，则从当前节点的上一个节点prev往下nodevalue继续进行查找，直到当前节点值与查找值相等，则直接返回当前节点，返回的节点可能是索引节点，也可能是原始数据节点，如果需要找到原始数据节点，则通过nodeValue继续往下找。

/**
* 是否存在num
* @param num
* @return
*/
public boolean hasNum(int num) {
Node result = this.findNum(num);
return null != result;
}
/**
* 查找num（返回的可能是索引，也可能是原始数据，根据nodeValue可以判断，也可以找到原始数据）
* @param num
*/
public Node findNum(int num) {
//跳表结构indexList是数据-》第一层索引-》第二层索引-》。。。。
//1.直接匹配到
//2.找到第一个大于当前元素的数，找前一个
Node node = indexList.get(indexList.size() - 1).next;
Node last = null;
while (null != node) {
if (node.value == num) {
//已经找到元素
return node;
}
if (node.value > num) {
if (null == last) {
//比最小值还小
return null;
}
//找到了第一个大于num的索引node
//到下一层去继续找
node = last.nodeValue;
last = null;
continue;
}
last = node;
node = null != node.next ? node.next : node.nodeValue;
}
return null;
}

 　　删除节点：首先通过上面的查找方法找到目标节点，如果目标节点是索引值，则需要从当前索引层，层层往下删除包括原始数据链表，如果是原始数据值，则直接删除，暂不调整。

/**
* 构建索引时：自底向上逐层构建，如果索引需要删除（当两个索引之间没有任何数据时候，删除）
* @param num
* @return
*/
public boolean remove(int num) {
Node node = this.findNum(num);
if (null == node) {
//不需要移除
return false;
}
if (null == node.nodeValue) {
//数据链表，可以直接移除
//是否最后一个节点
if (null == node.next) {
node.prev.next = null;
return true;
}
node.next.prev = node.prev;
node.prev.next = node.next;
return true;
}
//当前在索引上，自上而下删除索引及数据
while (null != node) {
Node cur = node.nodeValue;
if (null == node.next) {
node.prev.next = null;
} else {
node.next.prev = node.prev;
node.prev.next = node.next;
}
node = cur;
}
return true;
}

 　　新增节点：新增节点时候，如果不对索引进行调整，极端情况下，每次新增的节点都在之前第一层两个节点之间，当这之间的链表越变越长，时间复杂度直接退化为O(n)，所以需要同时新增索引，维持跳表的高效性。但是我们如何新增，有一个方法就是，在新增节点时，随机选择k，即第k级索引，从1～k新增索引。

/**
* 首先需要查找插入位置，如果比最小的还小，直接在前面插入
* 否则需要从最顶级一直查找到数据链表，找到插入位置，插入，在查找的过程中，就可以开始插入索引节点，
* 从上往下进行插入
* @param num
*/
public void add(int num) {
int k = this.generatorLevelK();
//寻找插入点的过程和查找过程基本一致
//顶级索引链表
Node node = indexList.get(indexList.size() - 1).next;
int index = 1;
while (null != node) {
//找到第一个node.value >= num的元素，在前面插入
if (node.value >= num) {
//已经找到,前插
if (index >= k) {
Node newNode = new Node(num);
Node temp = node.prev;
newNode.next = temp.next;
temp.next.prev = newNode;
newNode.prev = temp;
temp.next = newNode;
}
//找的时候往后面找的，但是当前已经先于num了，下一次再往后面找，就出现问题
if (null == node.prev.prev) {
//第一个节点就符合条件
node = node.nodeValue;
continue;
}
node = node.prev.nodeValue;
++ index;
continue;
}

//没有找到，但是当前已经是链表最后一个元素了
if (null == node.next) {
if (index >= k) {
Node newNode = new Node(num);
newNode.prev = node;
node.next = newNode;
}
if (null == node.prev.prev) {
//第一个节点就符合条件
node = node.nodeValue;
continue;
}
node = node.prev.nodeValue;
++ index;
continue;
}

node = node.next;
}

}

private int generatorLevelK() {
Random random = new Random();
return random.nextInt(level);
}

　　至此，我们实现了一个跳表的定义，初始化，查找，节点新增与删除。

　　公众号链接：https://mp.weixin.qq.com/s/cRI1COJFOopXVmz8mJL0Iw