1. 题目背景与需求分析
在算法面试和日常开发中，我们经常需要处理集合数据的快速操作。LeetCode 380题提出了一个看似简单但极具挑战性的问题：如何设计一个数据结构，能够同时支持O(1)时间复杂度的插入、删除和随机访问操作？
1.1 问题本质剖析
这个问题的核心在于突破单一数据结构的局限性。让我们先分析常见数据结构的时间复杂度特性：
-
数组：
- 优点：随机访问（通过索引）是O(1)
- 缺点：插入/删除中间元素需要移动后续元素，最坏情况下是O(n)
-
哈希表（对象/Map）：
- 优点：插入、删除、查找都是O(1)
- 缺点：无法直接通过索引随机访问元素
-
链表：
- 优点：插入删除是O(1)
- 缺点：随机访问需要遍历，是O(n)
1.2 设计思路突破
通过上述分析，我们可以得出关键结论：没有任何单一数据结构能同时满足所有操作都是O(1)的要求。因此，我们需要采用"组合数据结构"的思路：
- 使用数组存储元素，保证getRandom()的O(1)随机访问
- 使用哈希表存储"元素→索引"映射，实现O(1)的查找和定位
- 在删除操作时，采用"交换+尾部删除"技巧避免数组元素移动
2. 完整实现与深度解析
2.1 基础版本实现（使用对象作为哈希表）
typescript复制class RandomizedSet {
private arr: number[];
private valToIndex: Record<number, number>;
constructor() {
this.arr = [];
this.valToIndex = {};
}
insert(val: number): boolean {
if (val in this.valToIndex) {
return false;
}
this.valToIndex[val] = this.arr.length;
this.arr.push(val);
return true;
}
remove(val: number): boolean {
if (!(val in this.valToIndex)) {
return false;
}
const index = this.valToIndex[val];
const lastVal = this.arr[this.arr.length - 1];
// 交换元素
this.arr[index] = lastVal;
this.valToIndex[lastVal] = index;
// 删除尾部元素
this.arr.pop();
delete this.valToIndex[val];
return true;
}
getRandom(): number {
const randomIndex = Math.floor(Math.random() * this.arr.length);
return this.arr[randomIndex];
}
}
2.1.1 插入操作详解
插入操作的O(1)时间复杂度是通过以下步骤保证的：
- 检查存在性：
val in this.valToIndex是O(1) - 记录索引：
this.valToIndex[val] = this.arr.length是O(1) - 数组追加：
this.arr.push(val)是O(1)
关键细节：必须先记录索引再push，因为push后数组长度会增加，新元素的索引会变化。
2.1.2 删除操作精析
删除操作的优化是本题最精彩的部分：
typescript复制remove(val: number): boolean {
if (!(val in this.valToIndex)) return false;
const index = this.valToIndex[val]; // 获取待删除元素的索引
const lastVal = this.arr[this.arr.length - 1]; // 获取最后一个元素
// 将最后一个元素移动到待删除位置
this.arr[index] = lastVal;
this.valToIndex[lastVal] = index;
// 删除尾部元素
this.arr.pop();
delete this.valToIndex[val];
return true;
}
这个设计的精妙之处在于：
- 通过交换避免了数组中间元素的删除导致的O(n)移动
- 只需要更新被移动元素的索引映射
- 尾部删除操作(pop)始终是O(1)
2.1.3 随机访问实现
随机访问的实现相对简单：
typescript复制getRandom(): number {
const randomIndex = Math.floor(Math.random() * this.arr.length);
return this.arr[randomIndex];
}
这里需要注意：
Math.random()生成[0,1)的随机数Math.floor确保索引是整数- 数组的索引访问是O(1)
2.2 进阶优化版本（使用Map）
虽然对象作为哈希表可以工作，但使用Map有以下优势：
- 键可以是任意类型，不会自动转换为字符串
- 提供了更清晰的API(has, get, set, delete)
- 在大量操作时性能更稳定
优化后的实现：
typescript复制class RandomizedSet {
private arr: number[];
private valToIndex: Map<number, number>;
constructor() {
this.arr = [];
this.valToIndex = new Map();
}
insert(val: number): boolean {
if (this.valToIndex.has(val)) {
return false;
}
this.valToIndex.set(val, this.arr.length);
this.arr.push(val);
return true;
}
remove(val: number): boolean {
if (!this.valToIndex.has(val)) {
return false;
}
const index = this.valToIndex.get(val)!;
const lastVal = this.arr[this.arr.length - 1];
// 只有当删除的不是最后一个元素时才需要交换
if (index !== this.arr.length - 1) {
this.arr[index] = lastVal;
this.valToIndex.set(lastVal, index);
}
this.arr.pop();
this.valToIndex.delete(val);
return true;
}
getRandom(): number {
return this.arr[Math.floor(Math.random() * this.arr.length)];
}
}
2.2.1 Map版本的优势
- 类型安全：明确键是number类型
- API清晰：has/set/get/delete方法专为映射设计
- 额外优化：当删除的就是最后一个元素时，跳过交换操作
3. 关键细节与边界处理
3.1 存在性检查的陷阱
初学者容易犯的一个错误是使用值判断而非存在性判断：
typescript复制// 错误写法！
if (this.valToIndex[val]) {
return false;
}
这种写法的问题在于：
- 当元素的索引为0时，
this.valToIndex[val]是0，会被转为false - 导致误判元素不存在
正确做法是使用in操作符或Map的has方法。
3.2 索引一致性的维护
在删除操作中，必须严格维护索引映射的一致性：
- 当交换元素后，必须更新被移动元素的索引
- 删除操作完成后，必须清除被删除元素的映射
忽略这一点会导致后续操作获取到错误的索引。
3.3 边界条件处理
虽然题目保证getRandom()调用时集合非空，但良好的实践应该处理边界情况：
typescript复制getRandom(): number {
if (this.arr.length === 0) {
throw new Error("Cannot get random element from empty set");
}
return this.arr[Math.floor(Math.random() * this.arr.length)];
}
4. 复杂度分析与证明
4.1 时间复杂度
-
insert:
- Map.has(): O(1)
- Map.set(): O(1)
- Array.push(): O(1)
- 总体: O(1)
-
remove:
- Map.has(): O(1)
- Map.get(): O(1)
- 数组访问和赋值: O(1)
- Array.pop(): O(1)
- Map.delete(): O(1)
- 总体: O(1)
-
getRandom:
- Math.random和计算: O(1)
- 数组索引访问: O(1)
- 总体: O(1)
4.2 空间复杂度
- 使用O(n)的额外空间存储索引映射
- 总体空间复杂度: O(n)
5. 实际应用与扩展
5.1 应用场景
这种数据结构组合思路在实际开发中有广泛应用：
- 抽奖系统：需要随机选取用户且支持快速增删
- 游戏开发：随机道具掉落系统
- 缓存系统：需要随机淘汰策略(LRU的变种)
5.2 变种问题
- 允许重复元素：需要使用Map<number, Set
>来存储索引集合 - 加权随机选择：需要结合前缀和数组+二分查找
- 多维度随机访问：可以扩展为多维数组+哈希表
5.3 性能优化技巧
- 预分配数组大小：如果知道大致规模，可以预先分配数组
- 使用TypedArray：对于纯数字集合，可以使用Int32Array等
- 惰性删除：对于频繁删除场景，可以标记删除而非立即删除
6. 常见问题与解决方案
6.1 为什么删除操作要先交换再删除？
直接删除数组中间元素会导致后续元素移动，时间复杂度变为O(n)。通过交换到末尾再删除，可以保证O(1)时间复杂度。
6.2 Map和对象作为哈希表有什么区别？
| 特性 | Map | 对象(Object) |
|---|---|---|
| 键类型 | 任意类型 | 字符串或Symbol |
| 键顺序 | 插入顺序 | 不一定 |
| 大小获取 | size属性 | 需要手动计算 |
| 性能 | 大量操作时更稳定 | 通常更快 |
| 序列化 | 不能直接JSON序列化 | 可以直接序列化 |
6.3 如何测试实现的正确性？
可以编写以下测试用例：
- 插入重复元素测试
- 删除不存在元素测试
- 随机访问的概率分布测试
- 大规模数据操作的性能测试
示例测试代码：
typescript复制const test = () => {
const rs = new RandomizedSet();
const count: Record<number, number> = {};
// 插入测试
console.log(rs.insert(1)); // true
console.log(rs.insert(1)); // false
// 删除测试
console.log(rs.remove(2)); // false
console.log(rs.remove(1)); // true
// 随机访问测试
for (let i = 0; i < 100; i++) {
rs.insert(i);
}
for (let i = 0; i < 10000; i++) {
const val = rs.getRandom();
count[val] = (count[val] || 0) + 1;
}
// 检查随机分布是否均匀
console.log(count);
};
7. 算法思想延伸
这种"组合数据结构"的思想可以解决许多类似问题：
- LRU缓存：哈希表+双向链表
- LFU缓存：哈希表+平衡树/多层链表
- 时间序列数据库：跳表+哈希表
- 索引结构：B+树+哈希索引
关键思路是：识别不同操作的性能需求，选择合适的数据结构组合，通过额外的空间换取时间效率。