跳錶（Skip List）

數據結構與算法筆記：戀上數據結構筆記目錄

引出跳錶

一個有序鏈表搜索、添加、刪除的平均時間複雜度是多少？

O(n)

能否利用二分搜索優化有序鏈表，將搜索、添加、刪除的平均時間複雜度降低至 O(logn)？

鏈表沒有像數組那樣的高效隨機訪問（O(1) 時間複雜度），所以不能像有序數組那樣直接進行二分搜索優化

有沒有其他辦法讓有序鏈表搜索、添加、刪除的平均時間複雜度降低至 O(logn)？

跳錶（SkipList）

跳錶介紹

跳錶，又叫做跳躍表、跳躍列表，在有序鏈表的基礎上增加了“跳躍”的功能

由 William Pugh 於1990年發佈，設計的初衷是爲了取代平衡樹（比如紅黑樹）

Redis 中的 SortedSet、LevelDB 中的 MemTable 都用到了跳錶

Redis、LevelDB 都是著名的 Key-Value數據庫

對比平衡樹：

跳錶的實現和維護會更加簡單
跳錶的搜索、刪除、添加的平均時間複雜度是 O(logn)（與紅黑樹相同）

跳錶原理及實現

使用跳錶優化鏈表

普通鏈表：

有效層數爲 2 的跳錶：

有效層數爲 4 的跳錶：

跳錶基礎結構

/**
 * 跳錶
 * @author yusael
 */
@SuppressWarnings("unchecked")
public class SkipList <K, V> {
	private static final double P = 0.25; // 仿照Redis的做法, 維護一個概率值
	private static final int MAX_LEVEL = 32; // 最高層數
	private int size;
	private Comparator<K> comparator;
	/**
	 * 有效層數
	 */
	private int level;
	/**
	 * 不存放任何 K-V 的虛擬頭節點
	 */
	private Node<K, V> first; 
	
	public SkipList(Comparator<K> comparator) {
		this.comparator = comparator;
		// 頭節點的高度必須是跳錶的最高層數(非有效層數), 爲了後面插入新節點做準備
		first = new Node<>(null, null, MAX_LEVEL);
	}
	
	private int compare(K k1, K k2) {
		return comparator != null
				? comparator.compare(k1, k2)
				: ((Comparable<K>)k1).compareTo(k2);
	}

	private static class Node<K, V> {
		K key;
		V value;
		Node<K, V>[] nexts; // 該節點的不同層指向的下一節點
		// 拿上面的四層跳錶的圖來舉例
		// first.next[3] == 21節點
		// first.next[2] == 9節點
		// first.next[1] == 6節點
		// first.next[0] == 3節點
		public Node(K key, V value, int level) {
			this.key = key;
			this.value = value;
			nexts = new Node[level];
		}
	}

}

跳錶的搜索

① 從頂層鏈表的首元素開始，從左往右搜索，直至找到一個大於或等於目標的元素，或者到達當前層鏈表的尾部
② 如果該元素等於目標元素，則表明該元素已被找到
③ 如果該元素大於目標元素或已到達鏈表的尾部，則退回到當前層的前一個元素，然後轉入下一層進行搜索

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.nexts[i] != null 
				&& (cmp = compare(key, node.nexts[i].key)) > 0) {
			node = node.nexts[i];
		}
		// node.nexts[i].key >= key
		if (cmp == 0) return node.nexts[i].value;
	}
	return null;
}

跳錶的添加、刪除

添加的細節：隨機決定新添加元素的層數（官方建議）

/**
 * 跳錶中加入新結點時的層數隨機
 * @return
 */
private int randomLevel() {
	int level = 1; 
	while (Math.random() < P && level < MAX_LEVEL) { // 每次有25%的概率+1層
		level++;
	}
	return level;
}

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.nexts[i] != null 
				&& (cmp = compare(key, node.nexts[i].key)) > 0) {
			node = node.nexts[i];
		}
		// node.nexts[i].key >= key
		if (cmp == 0) { // 節點原本就存在
			V oldV = node.nexts[i].value;
			node.nexts[i].value = value;
			return oldV;
		}
		prevs[i] = node; // 保存前驅節點
	}
		
	// 新節點的層數(隨機)
	int newLevel = randomLevel();
	// 添加新節點
	Node<K, V> newNode = new Node<>(key, value, newLevel);
	// 設置新節點的前驅和後繼(獲取了前驅就相當於獲取了後繼)
	for (int i = 0; i < newLevel; i++) {
		if (i >= level) { // 新節點的層數比有效層數高
			// 頭結點成爲新節點的前驅
			first.nexts[i] = newNode; // 讓頭節點指向新節點(頭節點創建時是最高層)
			// 後繼結點默認指向null
		} else { // 新節點的層數比有效層數低
			newNode.nexts[i] = prevs[i].nexts[i]; // 讓新節點的後繼節點指向(之前的)前驅的後繼
			prevs[i].nexts[i] = newNode; // 讓前驅節點指向新節點
		}
	}
	level = Math.max(level, newLevel); // 計算跳錶的最終層數(更新有效層數)
	size++; // 節點數量增加
	return null; // 之前不存在該節點, 返回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.nexts[i] != null 
				&& (cmp = compare(key, node.nexts[i].key)) > 0) {
			node = node.nexts[i];
		}
		// key <= node.nexts[i].key 
		if (cmp == 0) exist = true; // 存在
		prevs[i] = node; // 保存前驅節點
	}
	if (!exist) return null; // 跳錶中沒有該元素, 無需刪除
	
	// 需要被刪除的節點
	// 此時該元素必然存在, 且node必然爲最下面一層, 該元素的前驅節點 
	Node<K, V> removedNode = node.nexts[0];
	
	// 設置後繼
	for (int i = 0 ; i < removedNode.nexts.length; i++) {
		prevs[i].nexts[i] = removedNode.nexts[i];
	}
	// 更新跳錶的層數
	int newLevel = level;
	while (--newLevel > 0 && first.nexts[newLevel] == null) {
		level = newLevel;
	}
	size--; // 數量減少
	return removedNode.value;	 
}

跳錶的層數

跳錶的複雜度分析

每一層的元素數量：從下往上

第 1 層鏈表固定有 n 個元素
第 2 層鏈表平均有 n * p 個元素
第 3 層鏈表平均有 n * p^2 個元素
第 k 層鏈表平均有 n * p^k 個元素
……

最高層的層數是 log_1/p n，平均有個 1/p 元素

在搜索時，每一層鏈表的預期查找步數最多是 1/p

所以總的查找步數是 -(log_p n/p)
時間複雜度是 O(logn)

跳錶 - 完整源碼

package com.mj;

import java.util.Comparator;

/**
 * 跳錶
 * @author yusael
 */
@SuppressWarnings("unchecked")
public class SkipList <K, V> {
	private static final double P = 0.25; // 仿照Redis的做法, 維護一個概率值
	private static final int MAX_LEVEL = 32; // 最高層數
	private int size;
	private Comparator<K> comparator;
	/**
	 * 有效層數
	 */
	private int level;
	/**
	 * 不存放任何 K-V 的虛擬頭結點
	 */
	private Node<K, V> first; 
	
	public SkipList(Comparator<K> comparator) {
		this.comparator = comparator;
		first = new Node<>(null, null, MAX_LEVEL);
	}
	
	public SkipList() {
		this(null);
	}
	
	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.nexts[i] != null 
					&& (cmp = compare(key, node.nexts[i].key)) > 0) {
				node = node.nexts[i];
			}
			// node.nexts[i].key >= key
			if (cmp == 0) { // 節點原本就存在
				V oldV = node.nexts[i].value;
				node.nexts[i].value = value;
				return oldV;
			}
			prevs[i] = node; // 保存前驅節點
		}
			
		// 新節點的層數(隨機)
		int newLevel = randomLevel();
		// 添加新節點
		Node<K, V> newNode = new Node<>(key, value, newLevel);
		// 設置新節點的前驅和後繼(獲取了前驅就相當於獲取了後繼)
		for (int i = 0; i < newLevel; i++) {
			if (i >= level) { // 新節點的層數比有效層數高
				// 頭結點成爲新節點的前驅
				first.nexts[i] = newNode; // 讓頭節點指向新節點(頭節點創建時是最高層)
				// 後繼結點默認指向null
			} else { // 新節點的層數比有效層數低
				newNode.nexts[i] = prevs[i].nexts[i]; // 讓新節點的後繼節點指向(之前的)前驅的後繼
				prevs[i].nexts[i] = newNode; // 讓前驅節點指向新節點
			}
		}
		level = Math.max(level, newLevel); // 計算跳錶的最終層數(更新有效層數)
		size++; // 節點數量增加
		return null; // 之前不存在該節點, 返回null
	}
	
	public V get(K key) {
		keyCheck(key);
		
		// first.next[3] == 21節點
		// first.next[2] == 9節點
		// first.next[1] == 6節點
		// first.next[0] == 3節點

		Node<K, V> node = first;
		for (int i = level - 1; i >= 0 ; i--) {
			int cmp = -1;
			while (node.nexts[i] != null 
					&& (cmp = compare(key, node.nexts[i].key)) > 0) {
				node = node.nexts[i];
			}
			// node.nexts[i].key >= key
			if (cmp == 0) return node.nexts[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.nexts[i] != null 
					&& (cmp = compare(key, node.nexts[i].key)) > 0) {
				node = node.nexts[i];
			}
			// key <= node.nexts[i].key 
			if (cmp == 0) exist = true; // 存在
			prevs[i] = node; // 保存前驅節點
		}
		if (!exist) return null; // 跳錶中沒有該元素, 無需刪除
		
		// 需要被刪除的節點
		// 此時該元素必然存在, 且node必然爲最下面一層, 該元素的前驅節點 
		Node<K, V> removedNode = node.nexts[0];
		
		// 設置後繼
		for (int i = 0 ; i < removedNode.nexts.length; i++) {
			prevs[i].nexts[i] = removedNode.nexts[i];
		}
		// 更新跳錶的層數
		int newLevel = level;
		while (--newLevel > 0 && first.nexts[newLevel] == null) {
			level = newLevel;
		}
		size--; // 數量減少
		return removedNode.value;
	}
	
	/**
	 * 跳錶中加入新結點時的層數隨機
	 * @return
	 */
	private int randomLevel() {
		int level = 1; 
		while (Math.random() < P && level < MAX_LEVEL) { // 每次有25%的概率+1層
			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);
	}

	private static class Node<K, V> {
		K key;
		V value;
		Node<K, V>[] nexts;
		public Node(K key, V value, int level) {
			this.key = key;
			this.value = value;
			nexts = new Node[level];
		}
		@Override
		public String toString() {
			return key + ":" + value + "_" + nexts.length;
		}
	}
	
	@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.nexts[i] != null) {
				sb.append(node.nexts[i]);
				sb.append("\t");
				node = node.nexts[i];
			}
			sb.append("\n");
		}
		return sb.toString();
	}
}

測試代碼：

package com.mj;

import java.util.TreeMap;
import com.mj.tool.Asserts;
import com.mj.tool.Times;

public class Main {
	public static void main(String[] args) {
//		SkipList<Integer, Integer> list = new SkipList<>();
//		test(list, 10, 10);
		time();
	}
	private static void time() {
		TreeMap<Integer, Integer> map = new TreeMap<>();
		SkipList<Integer, Integer> list = new SkipList<>();
		int count = 100_0000;
		int delta = 10;
		
		Times.test("SkipList", () -> {
			test(list, count, delta);
		});
		
		System.out.println("-----------------------");
		
		Times.test("TreeMap", () -> {
			test(map, count, delta);
		});
	}
	
	public static void test(SkipList<Integer, Integer> list, int count, int delta) {
		for (int i = 0; i < count; i++) {
			list.put(i, i + delta);
		}
//		System.out.println(list);
		for (int i = 0; i < count; i++) {
			Asserts.test(list.get(i) == i + delta);
		}
		Asserts.test(list.size() == count);
		for (int i = 0; i < count; i++) {
			Asserts.test(list.remove(i) == i + delta);
		}
		Asserts.test(list.size() == 0);
	}
	
	private static void test(TreeMap<Integer, Integer> map, int count, int delta) {
		for (int i = 0; i < count; i++) {
			map.put(i, i + delta);
		}
		for (int i = 0; i < count; i++) {
			Asserts.test(map.get(i) == i + delta);
		}
		Asserts.test(map.size() == count);
		for (int i = 0; i < count; i++) {
			Asserts.test(map.remove(i) == i + delta);
		}
		Asserts.test(map.size() == 0);
	}
	
}

一共4層
19:29_4	
4:14_3	19:29_4	
3:13_2	4:14_3	7:17_2	9:19_2	19:29_4	
0:10_1	1:11_1	2:12_1	3:13_2	4:14_3	5:15_1	6:16_1	7:17_2	8:18_1	9:19_2	10:20_1	11:21_1	12:22_1	13:23_1	14:24_1	15:25_1	16:26_1	17:27_1	18:28_1	19:29_4

【SkipList】
耗時：0.451s(451.0ms)
-------------------------------------
【TreeMap】
耗時：0.383s(383.0ms)
-------------------------------------

【戀上數據結構】跳錶（Skip List）原理及實現

跳錶（Skip List）

引出跳錶

跳錶介紹

跳錶原理及實現

使用跳錶優化鏈表

跳錶基礎結構

跳錶的搜索

跳錶的添加、刪除

跳錶的層數

跳錶的複雜度分析

跳錶 - 完整源碼

一鍵自動化博客發佈工具,用過的人都說好(掘金篇)

「Pygors跨平臺GUI」2：安裝MinGW-w64、MSYS2還是WSL2

[轉帖]

python列出centos7內存使用前50的進程信息

「Pygors跨平臺GUI」1：Pygors跨平臺GUI應用研究

nodejs學習06——小案例

評估統計算法在銀行僞造鈔票檢測中的價值

C# Xmlserializer 程序集內存泄露

Java ThreadPoolShutdown

5月21日相聚上海張江！與文心大模型一起共建大模型產業應用生態圈

【Java 強化】單元測試（JUnit3、JUnit4）、XML（語法、約束、文檔結構）、DOM、DOM4J

【計算機網絡】第5章 Internet原理與技術2（因特網的路由協議RIP、OSPF、BGP，網絡地址轉換NAT，網絡協議IPv6）

南郵《網絡技術與應用》課後作業解析

【Java 強化】代碼規範、JavaBean、lombok、內省（Introspector）、commons-beanutils組件

【戀上數據結構】串匹配算法（蠻力匹配、KMP【重點】、Boyer-Moore、Karp-Rabin、Sunday）

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結