跳表
一、定义
- 跳表，又叫做跳跃表，跳跃列表，在有序链表的基础上增加了“跳跃”的功能。由William Pugh于1990年发布，设计的初衷是为了取代平衡树（比如红黑树）
二、应用场景
- Redis中的SortedSet、LevelDB 中的MenTable都用到了跳表。
Redis、LevelDB 都是著名的Key-Value数据库 - 对比平衡树
跳表的实现和维护会更加简单，跳表的搜索、删除、添加的平均复杂度是O（logn）
三、跳表原理
- 跳表的搜索
- 从顶层链表的首元素开始，从左往右搜索，直到找到一个大于或者等于目标的元素，或者到达当前层链表的尾部
- 如果该元素等于目标元素，则表明该元素已被找到
- 如果该元素大于目标元素或者已经到达链表尾部，则退回到当前层的前一个元素，然后转入下一层进行搜索。
- 跳表的添加、删除
- 添加：随机决定新添加元素的层数
- 删除：删除一个元素后，整个跳表的层数可能会降低。
四、跳表的层数及复杂度
- 层数
-
跳表是按层构造的，底层是一个普通的有序链表，高层相当于是低层的“快速通道”
-
在第i层中的元素按某个固定的概率p (通常为42或%4 )出现在第i+ 1层中，产生越高的层数,概率越低
-
元素层数恰好等于1的概率为1 -p
-
元素层数大于等于2的概率为p,而元素层数恰好等于2的概率为p(1- p)
-
元素层数大于等于3的概率为p2,而元素层数恰好等于3的概率为p2(1-p)8
-
元素层数大于等于4的概率为p3,而元素层数恰好等于4的概率为p3*(1- p)
-
一个元素的平均层数是1/(1 -p)
-
-
-
当p= 1/2时,每个元素所包含的平均指针数量是2
-
当p= 1/4时,每个元素所包含的平均指针数量是1.33
- 复杂度
- 每一层元素数量
- 第1层链表固定有n个元素
- 第2层链表平均有n* p个元素
- 第3层链表平均有n* p^2个元素
- 第k层链表平均有n * p^k个元素
- ...
- 时间复杂度
最高层的层数是log1/pn, 平均有个1/p元素在搜索时，每- -层链表的预期查找步数最多是1/p,所以总的查找步数是-(logp n/p), 时间复杂度是0(ogn)
五、代码实现
import java.util.Comparator;
/**
* @author 韩俊强
* @createTime 2021年06月23日 15:26:00
*/
public class SkipList<K, V> {
private static final int MAX_LEVEL = 32;
private static final double p = 0.25;
private int size;
private Comparator<K> comparator;
private Node<K,V> first;
/**
* 有效层数
*/
private int level = 0;
public SkipList() {
this(null);
}
public SkipList(Comparator<K> comparator) {
this.comparator = comparator;
first = new Node<>(null,null,MAX_LEVEL);
}
public int size(){
return size;
}
public boolean isEmpty(){
return size == 0;
}
public V put(K key, V value){
keyCheck(key);
Node<K, V> node =first;
Node<K,V>[] prevs = new Node[level];
for (int i = level-1; i >= 0 ; i--) {
int cmp = -1;
while (node.next[i] != null && (cmp = compare(key,node.next[i].key)) > 0){
node = node.next[i];
}
if (cmp == 0){
V oldV = node.next[i].value;
node.next[i].value = value;
return oldV;
}
prevs[i] = node;
}
int newLevel = randomLevel();
// 添加新结点
Node<K, V> newNode = new Node<K, V>(key, value,newLevel);
for (int i = 0; i < newLevel; i++) {
if (i >= level){
first.next[i] = newNode;
}else {
newNode.next[i] = prevs[i].next[i];
prevs[i].next[i] = newNode;
}
}
// 结点数量增减
size++;
level = Math.max(level,newLevel);
return null;
}
public V get(K key){
keyCheck(key);
Node<K, V> node =first;
for (int i = level-1; i >= 0 ; i--) {
int cmp = -1;
while (node.next[i] != null && (cmp = compare(key,node.next[i].key)) > 0){
node = node.next[i];
}
if (cmp == 0){
return node.next[i].value;
}
}
return null;
}
public V remove(K key){
keyCheck(key);
Node<K, V> node =first;
Node<K,V>[] prevs = new Node[level];
boolean exist = false;
for (int i = level-1; i >= 0 ; i--) {
int cmp = -1;
while (node.next[i] != null && (cmp = compare(key,node.next[i].key)) > 0){
node = node.next[i];
}
prevs[i] = node;
if(cmp == 0) {
exist = true;
}
}
if (!exist){
return null;
}
// 需要被删除的结点
Node<K, V> removedNode = node.next[0];
// 数量减少
size--;
for (int i = 0; i < removedNode.next.length; i++) {
prevs[i].next[i] = removedNode.next[i];
}
// 更新跳表层数
int newLevel = level;
while (--newLevel >= 0 && first.next[newLevel] == null){
level = newLevel;
}
return removedNode.value;
}
private int randomLevel(){
int level = 1;
while (Math.random() < p && level < MAX_LEVEL){
level++;
}
return level;
}
private void keyCheck(K key){
if (key == null){
throw new IllegalArgumentException("key must not be null");
}
}
private int compare(K k1, K k2){
return comparator != null
? comparator.compare(k1, k2)
: ((Comparable<K>) k1).compareTo(k2);
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("一共"+level+"层").append("\n");
for (int i = level - 1; i >= 0; i--) {
Node<K, V> node = first;
while (node.next[i] != null){
sb.append(node.next[i].key);
sb.append(" ");
node = node.next[i];
}
sb.append("\n");
}
return sb.toString();
}
private static class Node<K, V>{
K key;
V value;
Node<K,V>[] next;
public Node(K key, V value, int level) {
this.key = key;
this.value = value;
this.next = new Node[level];
}
}
}
