跳表是一种随机化的数据结构，通过在有序链表基础上建立多层索引来实现高效的查找、插入和删除操作。其时间复杂度与红黑树相当，但实现更为简单。本文详细介绍了跳表的原理，包括插入、删除节点的过程，并提供了一个简单的Java代码实现。跳表在保持数据有序的同时，提供了近似于O(logn)的查找效率，是Redis和LevelDB等数据库中的重要数据结构。
1 什么是跳表？
大黄：给定一个有序数组，如何根据元素的值进行高效率查找？
小蓝：可以使用二分查找。
大黄：如何进行二分查找呢？
小蓝：首先根据数组下标，定位到数组的中间元素，如果要查找的元素大于中间元素，则定位到右半部分的中间元素进行查找，如果要查找的元素小于中间元素，则定位到左半部分进行查找，以此类推，直到查找到目标元素。如果数组的长度是 n ，二分查找的时间复杂度是 O(nlogn) ，比起从左到右逐个遍历元素进行查找的方式，大大提高了查找的性能。
大黄：好的。那么如果给定一个有序链表，如何根据元素的值进行高效率查找呢？
小蓝：是不是也可以用二分，先找中间元素呢？
大黄：链表和数组可不一样！数组能直接用下标快速定位，而链表只能从头结点开始，顺着next指针，逐个访问下一个节点。虽然不能使用二分查找，但是我们可以在链表的基础上做一个升级。让链表拥有自己的索引，即在原始链表的基础上，增加一个索引链表。原始链表的每两个节点中有一个在索引链表中，当我们要查找目标元素时，首先访问它的索引链表，在顺着索引链表的节点向下找，找到原始链表的节点。这样的话索引链表的节点个数就是原始链表的一半，查找节点所需的访问次数也就响应的减少了一半。
小蓝：查找一半的优化效率不明显，有什么办法可以显著提高查找效率呢？
大黄：如果链表的节点数量非常多，我们可以抽出更多的索引层级，每一层索引的节点数都是低层索引的一半，假设原始链表有n个结点，那么索引的层级就是log(n)-1，在每一层的访问次数是常量，因此查找结点的平均时间复杂度是O（logn）。这比起常规的查找方式，也就是线性依次访问链表节点的方式，效率要高得多。但相应的，这种基于链表的优化增加了额外的空间开销。假设原始链表有n个结点，那么各层索引的结点总数是n/2+n/4+n/8+n/16+…2，约等于n。也就是说，优化之后的数据结构所占空间，是原来的2倍。这是典型的以空间换时间的做法。
小蓝：奥。。。
大黄：像这样基于链表改造的数据结构，叫做 跳表。
跳表是一种随机化的数据结构，目前开源软件 Redis 和 LevelDB 都有用到它，它的效率和红黑树以及 AVL 树不相上下，但跳表的原理相当简单，只要你能熟练操作链表，就能轻松实现一个 SkipList。
跳表的性质
- 由很多层结构组成
- 每一层都是一个有序的链表
- 最底层(Level 1)的链表包含所有元素
- 如果一个元素出现在 Level i 的链表中，则它在 Level i 之下的链表也都会出现
- 每个节点包含两个指针，一个指向同一链表中的下一个元素，一个指向下面一层的元素
2 跳表的插入
假设要插入的结点是10，首先按照跳表查找结点的方法，找到待插入结点的前置结点（仅小于待插入结点）：
接下来，按照一般链表的插入方式，把结点10插入到结点9的下一个位置：
但是随着原始链表的新结点越来越多，索引会渐渐变得不够用了，因此索引结点也需要相应作出调整。我们让新插入的结点随机“晋升”，也就是成为索引结点。随机“晋升”满足参数为 p = 1/2 的几何分布，因此新结点晋升成功的几率是50%。假设第一次随机的结果是晋升成功，那么我们把结点10作为索引结点，插入到第1层索引的对应位置，并且向下指向原始链表的结点10：
新结点在成功晋升之后，仍然有机会继续向上一层索引晋升。我们再进行一次随机，假设随机的结果是晋升失败，那么插入操作就结束。如果某个新节点连续晋升成功，甚至超出了最高层索引的范围，这时直接让索引增加一层：
3 跳表的删除
跳表删除节点的过程与插入节点正好相反。
假设我们要从跳表中删除结点10，首先我们按照跳表查找结点的方法，找到待删除的结点：
接下来，按照一般链表的删除方式，把结点10从原始链表当中删除：
这样是不是删除工作就完成了呢？并不是。我们需要顺藤摸瓜，把索引当中的对应结点也一一删除：
如果某一层索引的节点被删光了的话，就直接把失去节点的那一层索引删除。第3层索引的结点已经没有了，因此我们把整个第3层删去：
最终的删除结果如下：
4 跳表的代码实现
上面所画跳表是简化了跳表，和实际代码实现有差别，在实际的代码实现中，跳表采用双向链表进行实现，无论前后结点还是上下结点，都各有两个指针相互指向彼此。而且程序中跳表的每一层首位各有一个空结点，左侧的空节点是负无穷大，右侧的空节点是正无穷大。如下图：
package skipList;
import java.util.Random;
/**
* 跳表的实现
* @author Administrator
*
*/
public class SkipList{
//结点“晋升”的概率
private static final double PROMOTE_RATE = 0.5;
private Node head,tail;
private int maxLevel;
public SkipList() {
head = new Node(Integer.MIN_VALUE);
tail = new Node(Integer.MAX_VALUE);
head.right = tail;
tail.left = head;
}
//查找结点
public Node search(int data){
Node p= findNode(data);
if(p.data == data){
System.out.println("找到结点：" + data);
return p;
}
System.out.println("未找到结点：" + data);
return null;
}
//找到值对应的前置结点
private Node findNode(int data){
Node node = head;
while(true){
while (node.right.data!=Integer.MAX_VALUE && node.right.data<=data) {
node = node.right;
}
if (node.down == null) {
break;
}
node = node.down;
}
return node;
}
//插入结点
public void insert(int data){
Node preNode= findNode(data);
//如果data相同，直接返回
if (preNode.data == data) {
return;
}
Node node=new Node(data);
appendNode(preNode, node);
int currentLevel=0;
//随机决定结点是否“晋升”
Random random = new Random();
while (random.nextDouble() < PROMOTE_RATE) {
//如果当前层已经是最高层，需要增加一层
if (currentLevel == maxLevel) {
addLevel();
}
//找到上一层的前置节点
while (preNode.up==null) {
preNode=preNode.left;
}
preNode=preNode.up;
//把“晋升”的新结点插入到上一层
Node upperNode = new Node(data);
appendNode(preNode, upperNode);
upperNode.down = node;
node.up = upperNode;
node = upperNode;
currentLevel++;
}
}
//在前置结点后面添加新结点
private void appendNode(Node preNode, Node newNode){
newNode.left=preNode;
newNode.right=preNode.right;
preNode.right.left=newNode;
preNode.right=newNode;
}
//增加一层
private void addLevel(){
maxLevel++;
Node p1=new Node(Integer.MIN_VALUE);
Node p2=new Node(Integer.MAX_VALUE);
p1.right=p2;
p2.left=p1;
p1.down=head;
head.up=p1;
p2.down=tail;
tail.up=p2;
head=p1;
tail=p2;
}
//删除结点
public boolean remove(int data){
Node removedNode = search(data);
if(removedNode == null){
return false;
}
int currentLevel=0;
while (removedNode != null){
removedNode.right.left = removedNode.left;
removedNode.left.right = removedNode.right;
//如果不是最底层，且只有无穷小和无穷大结点，删除该层
if(currentLevel != 0 && removedNode.left.data == Integer.MIN_VALUE && removedNode.right.data == Integer.MAX_VALUE){
removeLevel(removedNode.left);
}else {
currentLevel ++;
}
removedNode = removedNode.up;
}
return true;
}
//删除一层
private void removeLevel(Node leftNode){
Node rightNode = leftNode.right;
//如果删除层是最高层
if(leftNode.up == null){
leftNode.down.up = null;
rightNode.down.up = null;
}else {
leftNode.up.down = leftNode.down;
leftNode.down.up = leftNode.up;
rightNode.up.down = rightNode.down;
rightNode.down.up = rightNode.up;
}
maxLevel --;
}
//输出底层链表
public void printList() {
Node node=head;
while (node.down != null) {
node = node.down;
}
while (node.right.data != Integer.MAX_VALUE) {
System.out.print(node.right.data + " ");
node = node.right;
}
System.out.println();
}
//链表结点类
public class Node {
public int data;
//跳表结点的前后和上下都有指针
public Node up, down, left, right;
public Node(int data) {
this.data = data;
}
}
public static void main(String[] args) {
SkipList list=new SkipList();
list.insert(50);
list.insert(15);
list.insert(13);
list.insert(20);
list.insert(100);
list.insert(75);
list.insert(99);
list.insert(76);
list.insert(83);
list.insert(65);
list.printList();
list.search(50);
list.remove(50);
list.search(50);
}
}
5 总结
跳表是基于链表的升级，使一个有序链表获得高效的增删改查，并始终维持有序的能力。跳表在功能和性能上与红黑树相似但比红黑树的实现简单。
577
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
