克隆人的利与弊数据结构与算法分析：（⼗）跳表
⼀、前⾔
上⼀篇我们讲了关于数组的⼆分查找算法，。⼆分查找的底层依赖的是数组随机访问的特性，所以只能⽤数组来实现。如果数据存储在链表中，就真的没法⽤⼆分查找算法了吗？
答案是有办法的，我们只需要对链表稍加改造，就可以⽀持⼆分查找算法，改造后的数据结构我们称之为跳表（Skip List）。
我们先说下跳表这个数据结构的优缺点后再来分析详细过程。
对于⼀个需要频繁插⼊、删除的线性有序结构，如何使插⼊、删除的速度提升？
1、优点：
对于单向链表，只能从头到尾遍历，时间复杂度为O(n)。
对于数组，删除、插⼊复杂度太⾼O(n)，还会涉及数组的扩容操作。
平衡⼆叉树查询速度很快，但是需要平衡的操作开销很⼤。
红⿊树的话，性能差不多，但是如果需要多进程同时访问修改的话，红⿊树有个平衡的过程，争锁代价也⽐较⼤。
跳表的线程安全也是通过cas锁实现的，跳表的构建相对简单，同时⽀持范围查找。
2、缺点：
梦想作文600字
相对于红⿊树，空间消耗增加。
我们后端经常⽤的 Redis 中的有序集合就是⽤跳表来实现的。如果你有⼀定基础，应该知道红⿊树也可以实现快速的插⼊、删除和查找操作。那 Redis 为什么会选择⽤跳表来实现有序集合呢？ 为什么不⽤红⿊树呢？这篇讲完后，相信你⼼中会有⼀个答案了。
⼆、如何理解跳表
对于⼀个单链表来讲，即便链表中存储的数据是有序的，如果我们要想在其中查找某个数据，也只能从头到尾遍历链表。这样查找效率就会很低，时间复杂度会很⾼，是 O(n)。
那怎么来提⾼查找效率呢？请看我下⾯画的图，在该链表中，每隔⼀个节点就有⼀个附加的指向它在表中前两个位置上的节点的链，正因为如此，在最坏的情形下，最多考察 n/2 + 1 个节点。⽐如我们要查90这个节点，按照之前单链表的查找的话要8个节点，现在只需5个节点。
我们来将这种想法扩展⼀下，得到下⾯的图，这⾥每隔4个节点就有⼀个链接到该节点前⽅的下⼀个第4节点的链，只有 n/4 + 1 个节点被考察
这⾥我们利⽤数学的思想，针对通⽤性做扩展。每隔第 2^i 个节点就有⼀个链接到这个节点前⽅下⼀
个第 2 ^i 个节点链。链的总个数仅仅是加倍，但现在在⼀次查找中最多只考察 logn 个节点。不难看到⼀次查找的总时间消耗为 O(logn)，这是因为查找由向前到⼀个新的节点或者在同⼀节点下降到低⼀级的链组成。在⼀次查找期间每⼀步总的时间消耗最对为 O(logn)。注意，在这种数据结构中的查找基本上是折半查找（Binary Search）。
我只举了两个例⼦，这⾥你可以⾃⼰想象下⼤量数据也就是链表长度为 n 的时候，查找的效率更加的凸显出来了。
这种链表加多级索引的的结构，就是跳表。接下来我们来定量的分析下，⽤跳表查询到底有多快。
三、跳表的时间复杂度分析
我们知道，在⼀个单链表中查询某个数据的时间复杂度是 O(n)。那在⼀个具有多级索引的跳表中，查询某个数据的时间复杂度是多少呢？我把问题分解⼀下，先来看这样⼀个问题，如果链表⾥有 n 个结点，会有多少级索引呢？
按照我们上⾯讲的，第⼀级索引的链节点个数⼤约就是 n/2 个，第⼆级索引的链节点个数⼤约就是 n/4 个，第三级索引的链节点个数⼤约就是 n/8 个，依次类推，也就是说，第 k 级索引的链节点个数是第 k-1 级索引的链节点个数的 1/2，那第 k 级索引节点的个数就是
n/(2k)。
假设索引有 h 级，最⾼级的索引有 2 个节点。通过上⾯的公式，我们可以得到 n/(2h)=2，从⽽求得 h=log2n-1。如果包含原始链表这⼀层，整个跳表的⾼度就是 log2n。我们在跳表中查询某个数据的时候，如果每⼀层都要遍历 m 个节点，那在跳表中查询⼀个数据的时间复杂度就是 O(m*logn)。
那这个 m 的值是多少呢？按照前⾯这种索引结构，我们每⼀级索引都最多只需要遍历 3 个结点，也就是说 m=3，为什么是 3 呢？我来解释⼀下。
假设我们要查找的数据是 x，在第 k 级索引中，我们遍历到y节点之后，发现 x ⼤于 y，⼩于后⾯的节点 z，所以我们通过 y 的 down 指针，从第 k 级索引下降到第 k-1 级索引。在第 k-1 级索引中，y 和 z 之间只有 3 个节点（包含 y 和 z），所以，我们在 k-1 级索引中最多只需要遍历 3 个结点，依次类推，每⼀级索引都最多只需要遍历 3 个节点。
通过上⾯的分析，我们得到 m=3，所以在跳表中查询任意数据的时间复杂度就是 O(logn)。这个查找的时间复杂度跟⼆分查找是⼀样的。换句话说，我们其实是基于单链表实现了⼆分查找，前提是建⽴了很多级索引，也就是我们讲过的空间换时间的设计思路。
我们的时间复杂度很优秀，那跳表的空间复杂度是多少呢？
实际上，在软件开发中，我们不必太在意索引占⽤的额外空间。在讲数据结构和算法时，我们习惯性地把要处理的数据看成整数，但是在实际的软件开发中，原始链表中存储的有可能是很⼤的对象，⽽索引结点只需要存储关键值和⼏个指针，并不需要存储对象，所以当对象⽐索引结点⼤很多时，那索引占⽤的额外空间就可以忽略了。
四、跳表的插⼊和删除
实际上，跳表这个动态数据结构，不仅⽀持查找操作，还⽀持动态的插⼊、删除操作，⽽且插⼊、删除操作的时间复杂度也是 O(logn)。我们就来看下，如何在跳表中插⼊⼀个数据，以及它是如何做到 O(logn) 的时间复杂度的？
我们知道，在单链表中，⼀旦定位好要插⼊的位置，插⼊节点的时间复杂度是很低的，就是 O(1)。但是，这⾥为了保证原始链表中数据的有序性，我们需要先找到要插⼊的位置，这个查找操作就会⽐较耗时。
对于纯粹的单链表，需要遍历每个结点，来找到插⼊的位置。但是，对于跳表来说，我们讲过查找某个节点的的时间复杂度是 O(logn)，所以这⾥查找某个数据应该插⼊的位置，⽅法也是类似的，时间复杂度也是 O(logn)。
下腹部隐痛的原因
我们再来看删除操作。
如果这个节点在索引中也有出现，我们除了要删除原始链表中的节点，还要删除索引中的。因为单链表中的删除操作需要拿到要删除节点的前驱节点，然后通过指针操作完成删除。所以在查找要删除的节点的时候，⼀定要获取前驱节点。当然，如果我们⽤的是双向链表，就不需要考虑这个问题了。
五、跳表的代码实现
/**
* 跳表代码实现
* 跳表中存储的是正整数，并且存储的是不重复的。
*/
public class SkipList {
private static final int MAX_LEVEL =16;
private int levelCount =1;
// 带头链表
private Node head =new Node(MAX_LEVEL);
private Random random =new Random();
public Node find(int value){
Node cur = head;
// 从最⼤层开始查找，找到前⼀节点，通过--i，移动到下层再开始查找
for(int i = levelCount -1; i >=0; i--){
while(cur.forwards[i]!= null && cur.forwards[i].data < value){
// 找到前⼀节点
cur = cur.forwards[i];
}
}
if(cur.forwards[0]!= null && cur.forwards[0].data == value){
return cur.forwards[0];
}el{
return null;
}
}
/**
* 优化插⼊版本
如何办理离婚
* @param value
*/
public void inrt(int value){
int level = head.forwards[0]== null ?1:randomLevel();
跌倒的反义词// 每次只增加⼀层，如果条件满⾜
if(level > levelCount){
level =++levelCount;
}
Node newNode =new Node(level);
newNode.data = value;
Node cur = head;
/
/ 从最⼤层开始查找，找到前⼀节点，通过--i，移动到下层再开始查找
for(int i = levelCount -1; i >=0;--i){
while(cur.forwards[i]!= null && cur.forwards[i].data < value){
// 找到前⼀节点
cur = cur.forwards[i];
}
// levelCount 会 > level，所以加上判断
if(level > i){
if(cur.forwards[i]== null){
cur.forwards[i]= newNode;
}el{
Node next = cur.forwards[i];
cur.forwards[i]= newNode;
newNode.forwards[i]= next;
}
}
}
}
public void delete(int value){
Node[] update =new Node[levelCount];
Node cur = head;
for(int i = levelCount -1; i >=0;--i){
while(cur.forwards[i]!= null && cur.forwards[i].data < value){
cur = cur.forwards[i];
}
update[i]= cur;
}
if(cur.forwards[0]!= null && cur.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){
Int()%2==1){
level++;
}
}
return level;
}
/**
* 打印每个节点数据和最⼤层数
*/
public void printAll(){
Node cur = head;
while(cur.forwards[0]!= null){
System.out.print(cur.forwards[0]+" ");
cur = cur.forwards[0];
}
System.out.println();
}
/**
葱油虾* 打印所有数据
* 打印所有数据
*/
public void printAll_beautiful(){
Node p = head;
Node[] c = p.forwards;
Node[] d = c;
int maxLevel = c.length;
for(int i = maxLevel -1; i >=0; i--){
do{
System.out.print((d[i]!= null ? d[i].data : null)+":"+ i +"-------");
}while(d[i]!= null &&(d = d[i].forwards)[i]!= null);
System.out.println();
d = c;
}
}
/**
* 跳表的节点，每个节点记录了当前节点数据和所在层数数据
*/
public class Node {
private int data =-1;
/**
* 表⽰当前节点位置的下⼀个节点所有层的数据，从上层切换到下层，就是数组下标-1， * forwards[3]表⽰当前节点在第三层的下⼀个节点。
*/
音乐欣赏pptprivate Node forwards[];
/**
* 这个值其实可以不⽤，看优化inrt()
*/
private int maxLevel =0;
public Node(int level){
forwards =new Node[level];
}
@Override
public String toString(){
StringBuilder builder =new StringBuilder();
builder.append("{ data: ");
builder.append(data);
builder.append("; levels: ");
builder.append(maxLevel);
builder.append(" }");
String();
}
}
public static void main(String[] args){
SkipList list =new SkipList();
list.inrt(1);
list.inrt(2);
list.inrt(6);
list.inrt(7);
list.inrt(8);
list.inrt(3);
list.inrt(4);
list.inrt(5);
System.out.println();
list.printAll_beautiful();
}
}
输出结果：
