跳跃表（Skip List）详解

跳跃表是一种概率型数据结构，用于在有序元素集合中实现高效的查找、插入和删除操作。由 William Pugh 于 1990 年提出，其性能与平衡树（如红黑树）相当，但实现更简单。

核心思想

1. 多层链表结构：

   • 最底层（L0）包含所有元素的有序链表。
   • 每一高层（L1, L2, ...）是低一层的“子集”，通过“跳跃”指针跳过部分节点。
   • 高层节点数量呈指数递减（如 L1≈n/2, L2≈n/4）。

2. 随机层数：

   • 插入节点时，通过随机算法（如抛硬币）决定层数（如 50% 概率进入 L1，25% 进入 L2）。
   • 保证高层节点稀疏分布，避免手动平衡。

关键操作

1. 查找（Search）

• 步骤：
  1. 从最高层头节点开始。
  2. 向右遍历：若下一节点 ≤ 目标值，则继续右移。
  3. 若下一节点 > 目标值，则下沉一层。
  4. 重复直至最底层找到目标或确认不存在。
• 时间复杂度：平均 O(log n)，最坏 O(n)。

2. 插入（Insert）

• 步骤：
  1. 通过查找确定插入位置，并记录每层的前驱节点。
  2. 随机生成新节点的层高 k。
  3. 创建新节点，从 L0 到 Lk 依次链接：
     • 新节点在 Li 层的后继 = 前驱节点在 Li 层的后继
     • 前驱节点在 Li 层的后继 = 新节点
• 示例：插入值 6（随机层数=2）

3. 删除（Delete）

• 步骤：
  1. 查找目标节点，记录每层的前驱节点。
  2. 从最高层开始，将前驱节点的指针指向目标节点的后继。
  3. 移除目标节点，若高层链表为空则降低总层数。

特点与优势

对比平衡树

代码框架（Python 伪代码）

import random

class SkipListNode:
    def __init__(self, val, level):
        self.val = val
        self.next = [None] * level  # 每层的后继指针

class SkipList:
    def __init__(self, max_level=16, p=0.5):
        self.max_level = max_level
        self.p = p  # 节点晋升概率
        self.head = SkipListNode(None, max_level)  # 头节点
        self.level = 0  # 当前有效层数

    def random_level(self):
        level = 1
        while random.random() < self.p and level < self.max_level:
            level += 1
        return level

    def search(self, target: int) -> bool:
        curr = self.head
        for i in range(self.level-1, -1, -1):  # 从顶层向底层扫描
            while curr.next[i] and curr.next[i].val < target:
                curr = curr.next[i]
            if curr.next[i] and curr.next[i].val == target:
                return True
        return False

    def add(self, num: int) -> None:
        update = [self.head] * self.max_level  # 记录每层的前驱
        curr = self.head
        for i in range(self.level-1, -1, -1):
            while curr.next[i] and curr.next[i].val < num:
                curr = curr.next[i]
            update[i] = curr  # 保存插入位置的前驱

        new_level = self.random_level()
        if new_level > self.level:
            for i in range(self.level, new_level):
                update[i] = self.head
            self.level = new_level

        new_node = SkipListNode(num, new_level)
        for i in range(new_level):
            new_node.next[i] = update[i].next[i]
            update[i].next[i] = new_node

    def erase(self, num: int) -> bool:
        update = [None] * self.max_level
        curr = self.head
        for i in range(self.level-1, -1, -1):
            while curr.next[i] and curr.next[i].val < num:
                curr = curr.next[i]
            update[i] = curr

        target = curr.next[0] if curr.next[0] and curr.next[0].val == num else None
        if not target: 
            return False

        for i in range(self.level):
            if update[i].next[i] != target:
                break
            update[i].next[i] = target.next[i]  # 移除链接
        while self.level > 1 and self.head.next[self.level-1] is None:
            self.level -= 1  # 降低空层
        return True

实际应用

• Redis 有序集合（ZSET）：使用跳跃表存储分数排序，支持 O(log n) 的 ZRANGE、ZADD 等操作。
• 数据库引擎：LevelDB/RocksDB 用跳跃表管理内存表（MemTable），加速写入和查询。
• 并发数据结构：通过细粒度锁（如每层加锁）实现高并发访问。

? 核心价值：以接近 O(log n) 的效率实现有序集合操作，同时大幅降低工程复杂度。