题目地址(1206. 设计跳表)

题目地址(1206. 设计跳表)

题目描述

不使用任何库函数，设计一个 跳表 。

跳表 是在 O(log(n)) 时间内完成增加、删除、搜索操作的数据结构。跳表相比于树堆与红黑树，其功能与性能相当，并且跳表的代码长度相较下更短，其设计思想与链表相似。

例如，一个跳表包含 [30, 40, 50, 60, 70, 90] ，然后增加 80、45 到跳表中，以下图的方式操作：


Artyom Kalinin [CC BY-SA 3.0], via Wikimedia Commons

跳表中有很多层，每一层是一个短的链表。在第一层的作用下，增加、删除和搜索操作的时间复杂度不超过 O(n)。跳表的每一个操作的平均时间复杂度是 O(log(n))，空间复杂度是 O(n)。

了解更多 : https://en.wikipedia.org/wiki/Skip_list

在本题中，你的设计应该要包含这些函数：

bool search(int target) : 返回target是否存在于跳表中。
void add(int num): 插入一个元素到跳表。
bool erase(int num): 在跳表中删除一个值，如果 num 不存在，直接返回false. 如果存在多个 num ，删除其中任意一个即可。

注意，跳表中可能存在多个相同的值，你的代码需要处理这种情况。

 

示例 1:

输入
["Skiplist", "add", "add", "add", "search", "add", "search", "erase", "erase", "search"]
[[], [1], [2], [3], [0], [4], [1], [0], [1], [1]]
输出
[null, null, null, null, false, null, true, false, true, false]

解释
Skiplist skiplist = new Skiplist();
skiplist.add(1);
skiplist.add(2);
skiplist.add(3);
skiplist.search(0);   // 返回 false
skiplist.add(4);
skiplist.search(1);   // 返回 true
skiplist.erase(0);    // 返回 false，0 不在跳表中
skiplist.erase(1);    // 返回 true
skiplist.search(1);   // 返回 false，1 已被擦除


 

提示:

0 <= num, target <= 2 * 104
调用search, add,  erase操作次数不大于 5 * 104 

前置知识

公司

• 暂无

思路

关键点

代码

• 语言支持：Python3

Python3 Code:

maxLevel = 16
power = 2
maxRand = power ** maxLevel -1 
randLevel = lambda: maxLevel - int(math.log(random.randint(1,maxRand),power))

class SkipNode:
    def __init__(self, value):
        self.value = value
        self.right = None 
        self.down = None 

class Skiplist:

    def __init__(self):
        # 初始化数的范围
        left = [SkipNode(-float('inf')) for _ in range(maxLevel)]
        right = [SkipNode(float('inf')) for _ in range(maxLevel)]
        # 将左右界连接在一起 
        for i in range(maxLevel-1):
            left[i].right = right[i]
            left[i].down = left[i+1]
            right[i].down = right[i+1]
        # 最后一层需要单独处理 只有右指针 没有向下的指针
        left[-1].right = right[-1]
        # 跳表初始指针为左边的首元素
        self.head = left[0]

    def search(self, target: int) -> bool:
        # 从初始指针开始跳跃迭代，找不到的node迟早为None，跳出循环自动返回False
        node = self.head 
        while node:
            if node.right.value > target:
                node = node.down
            elif node.right.value < target:
                node = node.right
            else:
                return True
        return False

    def add(self, num: int) -> None:
        # 保存prev指针
        prev = []
        node = self.head
        while node:
            # 在跳表的每一行找到第一个大于等于num的node
            if node.right.value >= num:
                prev.append(node)
                node = node.down
            else:
                node = node.right 
        # 待插入的指针数组，长度按概率进行随机
        arr = [SkipNode(num) for _ in range(randLevel())]
        # 用zip把prev后续的元素与新的指针数组交联在一起即可完成跳表插入
        t = SkipNode(None)
        for p,a in zip(prev[maxLevel-len(arr):],arr):
            a.right = p.right
            p.right = a 
            t.down = a
            t = a 

    def erase(self, num: int) -> bool:
        ans = False
        node = self.head
        while node:
            if node.right.value > num:
                node = node.down
            elif node.right.value < num:
                node = node.right
            else:
                ans = True 
                # 删除该节点的指针 
                node.right = node.right.right
                # 继续去删除其他相同值
                node = node.down
        return ans 



# Your Skiplist object will be instantiated and called as such:
# obj = Skiplist()
# param_1 = obj.search(target)
# obj.add(num)
# param_3 = obj.erase(num)

复杂度分析

令 n 为数组长度。

• 时间复杂度：$O(logn)$
• 空间复杂度：$O(n)$