跳跃表
跳表全称叫做跳跃表，简称跳表。跳表是一个随机化的数据结构，实质是一种可以进行二分查找的有序链表。跳表在原有的有序链表上增加了多级索引，通过索引来实现快速查询。跳表不仅能提高搜索性能，同时也可以提高插入和删除操作的性能。
跳表思路分析
如上图所示，原始链表的节点分别是1、3、4、5、7、8、9、10、13、16、17、18。现在有个需求，想快速的找到节点10，最直接的方式就是依次遍历节点1、3、4、5、7、8、9、10。
为了提高链表的查找效率，我们可以从链表每2个节点提出一个节点，做为索引节点，通过建立索引链表来指向原始的链表。如上图所示，建立的一级索引链表的节点分别是1、4、7、9、13、17。
首先从索引链表开始遍历，直到遍历到索引节点9时，发现9的后继节点是13，比10大，这时就不需要再向后遍历，而是通过索引链表的节点9找到原始链表的节点9，然后再往后遍历就是节点10。添加了一级索引链表后只需遍历节点 1、4、7、9、10。这时遍历的节点相对较少了，若再添加一个二级索引链表，如下图所示：
那么只需要遍历节点 1、7、9、10 找到节点，依次类推。这就是跳表的原理，用空间换时间来提交查找效率。效率还是不够明显。如下图所示，假如有序单链表现在有1万个元素，分别是 0~9999。现在添加了很多级索引，最高级的索引，就两个元素 0、5000，次高级索引四个元素 0、2500、5000、7500，依次类推，当我们查找 7890 这个元素时，查找路径为 0、5000、7500 … 7890，通过最高级索引直接跳过了5000个元素，次高层索引直接跳过了2500个元素，从而使得链表能够实现二分查找。由此可以看出，当元素数量较多时，索引提高的效率比较大，近似于二分查找。
索引链表的维护
当我们不断地往跳表中插入数据时，若不更新索引链表，就有可能出现某2个索引节点之间的数据非常多的情况，在极端情况下，跳表还会退化成单链表，如下图所示：
跳表是通过随机函数来维护索引链表。
当我们往跳表中插入数据时，通过一个随机函数来决定这个结点插入到哪几级索引层中。随机函数代码实现：
/**
* 随机生成 1~MAX_LEVEL 之间的数，且 ：
* 1/2 的概率返回 1
* 1/4 的概率返回 2
* 1/8 的概率返回 3
* 以此类推。
* @return 返回1不建索引、返回2建一级索引、返回3建二级索引、返回4建三级索引依次类推
*/
private int randomLevel(){
int level = 1;
for(int i = 1; i < MAX_LEVEL; ++i){
if(random.nextInt() % 2 == 1){
level+=1;
}
}
return level;
}
插入原理
现在我们要插入数据 6 到跳表中，首先 randomLevel() 返回 3，表示需要建二级索引，即：一级索引和二级索引需要增加元素 6。该跳表目前最高三级索引，首先找到三级索引的 1，发现 6 比 1大比 13小，所以，从 1 下沉到二级索引。
下沉到二级索引后，发现 6 比 1 大比 7 小，此时需要在二级索引中 1 和 7 之间加一个元素6 ，并从元素 1 继续下沉到一级索引。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kRqs0FYX-1617572783152)(C:\Users\10034\AppData\Roaming\Typora\typora-user-images\image-20210405025407486.png)]
下沉到一级索引后，发现 6 比 1 大比 4 大，所以往后查找，发现 6 比 4 大比 7 小，此时需要在一级索引中 4 和 7 之间加一个元素 6 ，并把二级索引的 6 指向 一级索引的 6，最后，从元素 4 继续下沉到原始链表。
下沉到原始链表后，发现 4、5 比 6小，7比6大，所以将6插入到 5 和 7 之间，插入结束。
整个插入过程的路径与查找元素路径类似， 每层索引中插入元素的时间复杂度 O(1)，所以整个插入的时间复杂度是 O(logn)。
删除原理
跳表删除数据时，要把索引中对应节点也要删掉。如下图所示，如果要删除元素 9，需要把原始链表中的 9 和第一级索引的 9 都删除掉。
跳表的删除操作时间复杂度为：O(logn)，支持动态的删除。
代码实现
package leetcode.链表;
import java.util.Random;
public class SkipList<E extends Comparable<? super E>> {
private final int MAX_LEVEL = 32; //跳表层数，定义成32层理论上对于2^32-1个元素的查询最优。
private int level = 0;//当前跳表的有效层
private final SkipNode<E> header = new SkipNode<E>(MAX_LEVEL, null);//头节点
private final Random random = new Random();//随机数
private final double E = Math.E;//自然数e
static class SkipNode<E extends Comparable<? super E>> {
public E val;//节点存储的值Val
public SkipNode<E>[] next;//节点指向第i层的节点next[i]
@SuppressWarnings("unchecked")
public SkipNode(int MAX_LEVEL, E val) {
this.next = new SkipNode[MAX_LEVEL];
this.val = val;
}
}
/**
* 检查跳表中是否包含val节点
*
* @param val 值
* @return
*/
public boolean contains(E val) {
//curr指向跳表头结点
SkipNode<E> curr = header;
/**
* 从顶层开始查找当前层的链表中是否包含节点node，如果包含node节点，直接返回true；否则在下一层中查找是否包含node节点。
* 如果最底层的链表也不包含node节点，则放回false。
*/
for (int i = level; i >= 0; i--) {
while (curr.next != null && curr.next[i].val.compareTo(val) < 0) {
curr = curr.next[i];
}
if (curr.next[i].val.equals(val)) {
return true;
}
}
return false;
}
/**
* 插入节点
*
* @param val
*/
@SuppressWarnings({"unchecked", "rawtypes"})
public void insert(E val) {
SkipNode<E> curr = header;//指向头节点
SkipNode<E>[] pre = new SkipNode[MAX_LEVEL];//保存前继节点
//找出每层中待插入节点的前继节点
for (int i = level; i >= 0; i--) {
curr = header;
while (curr.next[i] != null && curr.next[i].val.compareTo(val) < 0) {
curr = curr.next[i];
}
pre[i] = curr;
}
curr = curr.next[0];
//维护索引链表，返回1不建索引、返回2建一级索引、返回3建二级索引、返回4建三级索引依次类推
int nextLevel = randomLevel();
//如果待插入节点位置是空，或者与node节点值不同，将新节点插入到跳表中
if (curr == null || !curr.val.equals(val)) {
//若新增一层链表
if (nextLevel > level) {
pre[nextLevel] = header;
level = nextLevel;
}
SkipNode<E> node = new SkipNode(MAX_LEVEL, val);
for (int i = level; i >= 0; i--) {
node.next[i] = pre[i].next[i];
pre[i].next[i] = node;
}
}
}
@SuppressWarnings({"unchecked"})
public void delete(E val) {
SkipNode<E> curr = header;
SkipNode<E>[] pre = new SkipNode[MAX_LEVEL];
//寻找待删除元素在不同层上的前继节点
for (int i = level; i >= 0; i--) {
while (curr.next != null && curr.next[i].val.compareTo(val) < 0) {
curr = curr.next[i];
}
pre[i] = curr;
}
curr = curr.next[0];
//若跳表中不含此节点
if (!curr.val.equals(val)) {
return;
}
for (int i = level; i >= 0; i--) {
if (!pre[i].next[i].val.equals(val)) {
continue;
}
pre[i].next[i] = curr.next[i];
}
//若删除元素val后level层元素数目为0，层数减少一层
while (level > 0 && header.next[level] == null) {
level--;
}
}
/**
* 输出跳表中的元素
*/
public String toString() {
StringBuilder sb = new StringBuilder();
SkipNode<E> curr = header.next[0];
sb.append("{");
while (curr.next[0] != null) {
sb.append(curr.val);
sb.append(",");
curr = curr.next[0];
}
sb.append(curr.val);
sb.append("}");
return sb.toString();
}
/**
* 利用随机数发生器来决定是否新增一层
* 随机生成 1~MAX_LEVEL 之间的数，且 ：
* 1/2 的概率返回 1
* 1/4 的概率返回 2
* 1/8 的概率返回 3
* 以此类推。
*
* @return 返回1不建索引、返回2建一级索引、返回3建二级索引、返回4建三级索引依次类推
*/
private int randomLevel() {
double ins = random.nextDouble();
int nextLevel = level;
if (ins > E && level < MAX_LEVEL) {
nextLevel += 1;
}
return nextLevel;
}
}
参考文章：
https://cloud.tencent.com/developer/article/1539038
https://blog.csdn.net/pcwl1206/article/details/83512600
https://blog.csdn.net/gloomysnow/article/details/51510203
扫一扫
3589
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
