跳表
一个有序链表的搜索、添加、删除的平均时间复杂度都为O(n),那么能否利用二分搜索优化有序链表,将搜索、添加、删除的平均时间复杂度降低至O(logn)呢?
链表没有像数组那样的高效随机访问(O(1)时间复杂度),所以不能像有序数组那样直接进行二分搜索优化。
那有没有其他办法让有序链表的搜索、添加、删除的平均时间复杂度降低至O(logn)?答案是使用跳表。
跳表的介绍
跳表(SkipList),又叫做跳跃表、跳跃列表,在有序链表的基础上增加了“跳跃”的功能,由William Pugh于1990年发布,设计的初衷是为了取代平衡树(比如红黑树)。
Redis中的SortedSet、LevelDB中的MemTable都用到了跳表。
与平衡二叉树的对比
- 跳表的实现和维护会更加简单
- 跳表的搜索、删除、添加的平均时间复杂度是O(logn)
跳表的数据结构
public class SkipList<K, V> {
public static final int MAX_LEVEL = 32; // 跳表的最大层数
public static final double P = 0.25;
private Comparator<K> comparator;
private int size; // 节点的个数
private int level; // 跳表的层数
private Node<K, V> first = new Node<>(null, null, MAX_LEVEL); // 头节点
public SkipList() {
this(null);
}
public SkipList(Comparator<K> comparator) {
this.comparator = comparator;
}
public int size() {
return size;
}
public boolean isEmpty() {
return 0 == size;
}
...
...
private static class Node<K, V> {
K key;
V value;
Node<K, V>[] nexts;
private int level;
public Node(K key, V value, int level) {
this.key = key;
this.value = value;
this.level = level;
this.nexts = new Node[level];
}
@Override
public String toString() {
return key + ":" + value + "_" + nexts.length;
}
}
}
跳表的搜索
- 从顶层链表的首元素开始,从左往右搜索,直至找到一个大于或等于目标的元素,或者到达当前层链表的尾部。
- 如果该元素等于目标元素,则表明该元素已被找到。
- 如果该元素大于目标元素或已到达链表的尾部,则退回到当前层的前一个元素,然后转入下一层进行搜索。
代码实现如下:
public V get(K key) {
keyCheck(key);
Node<K, V> node = first;
for (int i = level- 1; i >= 0; i--) {
int cmp = -1;
while (null != node.nexts[i] && (cmp = compare(node.nexts[i].key, key)) < 0) {
node = node.nexts[i];
}
if(cmp == 0) {
// key相等
return node.nexts[i].value;
}
}
return null;
}
private int compare(K k1, K k2) {
if(null != comparator) {
return comparator.compare(k1, k2);
}
return ((Comparable<K>) k1).compareTo(k2);
}
private void keyCheck(K key) {
if (key == null) {
throw new IllegalArgumentException("key must not be null.");
}
}
跳表的添加
- 创建一个新的节点,随机决定新添加节点的层数。
- 找到新节点的所有前驱节点。
- 将新节点插入到每一层的链表中。
代码实现如下:
/**
* key不存在则添加节点,key存在则将value替换为新值,返回旧值
* @param key
* @param value
* @return
*/
public V put(K key, V value) {
keyCheck(key);
Node<K, V> node = first;
Node<K, V>[] previousNodes = new Node[level]; // 前驱节点
for (int i = level - 1; i >= 0; i--) {
int cmp = -1;
while (null != node.nexts[i] && (cmp = compare(node.nexts[i].key, key)) < 0) {
node = node.nexts[i];
}
if(cmp == 0) {
// key相等
V oldValue = node.nexts[i].value;
node.nexts[i].value = value;
return oldValue;
}
previousNodes[i] = node;
}
int newLevel = randomLevel();
Node<K, V> newNode = new Node<>(key, value, newLevel);
// 维护前驱和后继
for (int i = 0; i < newLevel; i++) {
if(i < previousNodes.length) {
newNode.nexts[i] = previousNodes[i].nexts[i];
previousNodes[i].nexts[i] = newNode;
} else {
first.nexts[i] = newNode;
}
}
size++;
this.level = Integer.max(newLevel, this.level); // 更新最大层数
return null;
}
/**
* 随机返回层数
* @return
*/
private int randomLevel() {
int level = 1;
while (Math.random() < P && level < MAX_LEVEL) {
level++;
}
return level;
}
跳表的删除
- 找到要删除的节点和所有的前驱节点。
- 将要删除的节点从每一层的链表中删除。
扫描二维码关注公众号,回复:
11449111 查看本文章
![](/qrcode.jpg)
public V remove(K key) {
keyCheck(key);
Node<K, V> node = first;
Node<K, V>[] previousNodes = new Node[level]; // 前驱节点
boolean isExist = false;
for (int i = level - 1; i >= 0; i--) {
int cmp = -1;
while (null != node.nexts[i] && (cmp = compare(node.nexts[i].key, key)) < 0) {
node = node.nexts[i];
}
if(cmp == 0) {
isExist = true;
}
previousNodes[i] = node;
}
if(!isExist) {
// key不存在返回null
return null;
}
Node<K, V> removeNode = node.nexts[0];
for (int i = 0; i < removeNode.level; i++) {
previousNodes[i].nexts[i] = removeNode.nexts[i];
}
size--;
// 更新跳表的层数
int newLevel = level;
while (--newLevel >= 0 && first.nexts[newLevel] == null) {
level = newLevel;
}
return removeNode.value;
}
跳表的层数
跳表是按层构造的,底层是一个普通的有序链表,高层相当于是低层的“快速通道”也可以称之为多层索引。
在第i层中的元素按某个固定的概率 p(通常为 或 )出现在第i+1层中,产生越高的层数,概率越低
- 元素层数恰好等于1的概率为
- 元素层数大于等于2的概率为 ,而元素层数恰好等于2的概率为
- 元素层数大于等于3的概率为 ,而元素层数恰好等于3的概率为
- 元素层数大于等于4的概率为 ,而元素层数恰好等于4的概率为
- …
- 一个元素的平均层数是
当p=1/2时,每个元素所包含的平均指针数量是2。
当p=1/4时,每个元素所包含的平均指针数量是1.33(优于平衡二叉树的固定指针数量2)。
跳表的复杂度分析
每一层的元素数量,其中n为数据规模:
- 第1层链表固定有 个元素
- 第2层链表平均有 个元素
- 第3层链表平均有 个元素
- 第k层链表平均有 个元素
最高层的层数是 ,平均有个 元素。
在搜索时,每一层链表的预期查找步数最多是 ,所以总的查找步数是 ,时间复杂度是O(logn)。
更多精彩内容关注本人公众号:架构师升级之路