当前位置：首页 > news >正文

【LeetCode380题】和【LeetCode238题】题解

news 2025/10/8 7:12:02

380. O(1) 时间插入、删除和获取随机元素

实现RandomizedSet 类：

RandomizedSet() 初始化 RandomizedSet 对象
bool insert(int val) 当元素 val 不存在时，向集合中插入该项，并返回 true ；否则，返回 false 。
bool remove(int val) 当元素 val 存在时，从集合中移除该项，并返回 true ；否则，返回 false 。
int getRandom() 随机返回现有集合中的一项（测试用例保证调用此方法时集合中至少存在一个元素）。每个元素应该有 相同的概率 被返回。

你必须实现类的所有函数，并满足每个函数的平均时间复杂度为 O(1) 。

示例：

输入
["RandomizedSet", "insert", "remove", "insert", "getRandom", "remove", "insert", "getRandom"]
[[], [1], [2], [2], [], [1], [2], []]
输出
[null, true, false, true, 2, true, false, 2]

解释
RandomizedSet randomizedSet = new RandomizedSet();
randomizedSet.insert(1); // 向集合中插入 1 。返回 true 表示 1 被成功地插入。
randomizedSet.remove(2); // 返回 false ，表示集合中不存在 2 。
randomizedSet.insert(2); // 向集合中插入 2 。返回 true 。集合现在包含 [1,2] 。
randomizedSet.getRandom(); // getRandom 应随机返回 1 或 2 。
randomizedSet.remove(1); // 从集合中移除 1 ，返回 true 。集合现在包含 [2] 。
randomizedSet.insert(2); // 2 已在集合中，所以返回 false 。
randomizedSet.getRandom(); // 由于 2 是集合中唯一的数字，getRandom 总是返回 2 。

提示：

-231 <= val <= 231 - 1
最多调用 insert、remove 和 getRandom 函数 2 * ``105 次
在调用 getRandom 方法时，数据结构中 至少存在一个 元素。

题解

class RandomizedSet:

    def __init__(self):
        self.dic = {}
        self.vec = []
        self.idx = 0

    def insert(self, val: int) -> bool:
        if val not in self.dic:
            self.dic[val] = self.idx
            self.idx += 1
            self.vec.append(val)
            return True
        return False

    def remove(self, val: int) -> bool:
        if val in self.dic:
            i = self.dic[val]
            self.vec[-1], self.vec[i] = self.vec[i], self.vec[-1]
            self.dic[self.vec[i]] = i
            self.vec.pop()
            del self.dic[val]
            self.idx -= 1
            return True
        return False


    def getRandom(self) -> int:
        i = random.randint(0, self.idx-1)
        return self.vec[i]

哈希表（字典）和数组（列表）两种数据结构

要实现一个支持 O (1) 插入、删除和随机访问的数据结构，单一数据结构很难满足所有需求：

数组：随机访问 O (1)，但插入/删除元素在中间位置时是 O (n)

数组的每个元素都可以通过索引直接计算出在内存中的地址，例如数组 [a, b, c, d]，知道起始地址后，索引 2 的元素c的地址可以直接算出，无需遍历，因此是 O (1)

数组的连续存储特性要求元素之间不能有 "空隙"。

若在中间插入元素（如在b和c之间插入x），需要将c、d等后续元素整体后移，才能腾出位置，移动元素的操作是 O (n)。

若删除中间元素（如删除b），需要将c、d等后续元素整体前移，填补空隙，同样是 O (n)。

哈希表：插入删除 O (1)，但无法实现真正的随机访问（按索引访问）

元素的存储位置由哈希函数计算得到，内存地址不连续

插入时，通过哈希函数直接计算元素应存入的位置，无需关心其他元素的位置，直接放入即可；删除时，同样通过哈希函数定位到元素位置，直接移除即可。这两个操作都不需要移动其他元素，因此平均是 O (1)。

元素的位置由哈希函数决定，与元素的插入顺序、大小无关，没有 "索引" 的概念（哈希表的 "桶索引" 和数组的 "元素索引" 完全不同）。

无法像数组那样通过 "索引 = 2" 直接找到第 3 个插入的元素，也无法保证元素按索引顺序存储。

因此，哈希表无法实现数组那样的 "按索引随机访问"，也就不能等概率地返回随机元素。

所以采用了 "哈希表 + 数组" 的组合方式：

数组 (self.vec) 存储元素值，用于 O (1) 时间的随机访问

哈希表 (self.dic) 存储元素值到数组索引的映射，用于 O (1) 时间的查找

键是元素值val，值是该元素在数组中的索引i，例如dic[1] = 0表示元素1在数组索引 0 的位置。

快速查找元素位置：通过val in dic或dic[val]可 O (1) 时间判断元素是否存在，或获取其索引。

辅助删除操作：删除元素时需要更新被交换元素的索引映射。

各方法

初始化 (__init__)
- self.dic：字典，键是元素值，值是该元素在数组中的索引
- self.vec：列表，按顺序存储所有元素
- self.idx：记录当前元素数量（也作为下一个插入元素的索引）
插入 (insert)
- 先检查元素是否已在字典中（O (1) 操作）
- 如果不存在：
  - 在字典中记录元素值和它的索引（当前的self.idx）
  - 索引值加 1
  - 在数组末尾添加该元素（O (1) 操作）
  - 返回True表示插入成功
- 如果已存在，直接返回False
删除 (remove)
- 先检查元素是否在字典中（O (1) 操作）
- 如果存在：
  - 获取该元素在数组中的索引i
  - 将数组中最后一个元素与索引i处的元素交换（O (1) 操作）
  - 更新被交换元素在字典中的索引值
  - 删除数组最后一个元素（O (1) 操作）
  - 从字典中删除该元素
  - 索引值减 1
  - 返回True表示删除成功
- 如果不存在，直接返回False

"交换 + 删除末尾" 的方式避免了数组中间删除元素的 O (n) 复杂度

随机访问 (getRandom)
- 生成一个 0 到当前元素数量减 1 之间的随机整数作为索引
- 返回数组中该索引对应的元素（O (1) 操作）
- 保证了每个元素被返回的概率相等

238. 除自身以外数组的乘积

给你一个整数数组 nums，返回数组 answer ，其中 answer[i] 等于 nums 中除 nums[i] 之外其余各元素的乘积。

题目数据保证数组 nums之中任意元素的全部前缀元素和后缀的乘积都在 32 位整数范围内。

请 不要使用除法，且在 O(n) 时间复杂度内完成此题。

示例 1:

输入: nums = [1,2,3,4]
输出: [24,12,8,6]

示例 2:

输入: nums = [-1,1,0,-3,3]
输出: [0,0,9,0,0]

提示：

2 <= nums.length <= 105
-30 <= nums[i] <= 30
输入保证数组 answer[i] 在 32 位整数范围内

题解

class Solution:
    def productExceptSelf(self, nums: List[int]) -> List[int]:
        ans, tmp = [1] * len(nums), 1
        for i in range(1, len(nums)):
            ans[i] = ans[i - 1] * nums[i - 1]
        for i in range(len(nums) - 2, -1, -1):
            tmp *= nums[i + 1]
            ans[i] *= tmp
        return ans