题目描述：
设计一个支持在平均 时间复杂度 O(1) 下，执行以下操作的数据结构。
-
insert(val)：当元素 val 不存在时，向集合中插入该项。remove(val)：元素 val 存在时，从集合中移除该项。getRandom：随机返回现有集合中的一项。每个元素应该有相同的概率被返回
示例：
// 初始化一个空的集合。 RandomizedSet randomSet = new RandomizedSet(); // 向集合中插入 1 。返回 true 表示 1 被成功地插入。 randomSet.insert(1); // 返回 false ，表示集合中不存在 2 。 randomSet.remove(2); // 向集合中插入 2 。返回 true 。集合现在包含 [1,2] 。 randomSet.insert(2); // getRandom 应随机返回 1 或 2 。 randomSet.getRandom(); // 从集合中移除 1 ，返回 true 。集合现在包含 [2] 。 randomSet.remove(1); // 2 已在集合中，所以返回 false 。 randomSet.insert(2); // 由于 2 是集合中唯一的数字，getRandom 总是返回 2 。 randomSet.getRandom();
解题思路：
分析：题目的难点在于有delete操作的情况下，要保证getRandom( )等概率随机返回集合中的一个元素。
一般地，题目的对时间复杂度的要求越高，都需要使用更多的辅助结构，以“空间换时间”。这里可以采用“两个哈希表”（多一个哈希表）或者“一个哈希表加一个数组”（多一个数组）。
渐进思路：
（1）没有delete(val)，只有insert(val)和getRandom( )操作的情况下，连续的插入元素键值对<key，index>，因为index在逻辑上是连续，因此getRandom()等概率随机返回集合中的一个元素很容易实现，rand() % index (0~index-1)即可;
（2）有delete(val)操作，可以删除元素键值对之后，使得index不连续，中间有空洞，所以此时getRandom()产生的index可能正好是被删除的，导致时间复杂度超过O(1)，所以delete(val)操作需要有一些限定条件，即保证每删除一个元素键值对之后，index个数减一，但是整体index在逻辑上是连续的。
例如：0~5 ——> 0~4 ——> 0~3
代码里关键部分有注释。
class RandomizedSet {
public:
/** Initialize your data structure here. */
//建立两个hash表，一个是<key,index>,另一个是<index,key>;
RandomizedSet() {
}
/** Inserts a value to the set. Returns true if the set did not already contain the specified element. */
bool insert(int val) {
//元素不存在时，插入
if(keyIndexMap.count(val) == 0)
{
keyIndexMap[val] = size;
indexKeyMap[size] = val;
++size;
return true;
}
return false;
}
/** Removes a value from the set. Returns true if the set contained the specified element. */
bool remove(int val) {
////每删除一个键值对，用最后的键值对填充该空位，保证整个index在逻辑上连续，size减一
if(keyIndexMap.count(val) == 1)
{
int removeIndex = keyIndexMap[val];
int lastIndex = --size;//若size=1000,表示0~999；这里是取最后一个index
int lastKey = indexKeyMap[lastIndex];
keyIndexMap[lastKey] = removeIndex;
indexKeyMap[removeIndex] = lastKey;
keyIndexMap.erase(val);
indexKeyMap.erase(lastIndex);//下标方式取val对应的值index
return true;
}
return false;
}
/** Get a random element from the set. */
int getRandom() {
if (size == 0) {
return NULL;
}
//srand((unsigned)time(NULL)); //去掉srand（）,保证稳定的产生随机序列
int randomIndex = (int) (rand() % size); // 0 ~ size -1
return indexKeyMap[randomIndex];
}
private:
map<int,int> keyIndexMap;
map<int,int> indexKeyMap;
int size = 0;
};
/**
* Your RandomizedSet object will be instantiated and called as such:
* RandomizedSet obj = new RandomizedSet();
* bool param_1 = obj.insert(val);
* bool param_2 = obj.remove(val);
* int param_3 = obj.getRandom();
*/
用时更少的范例：
这是Leetcode官网上C++完成此题提高的用时排名靠前的代码，这里与上面的解法差异就在于额外的辅助结构的选择，这里选的是在哈希表的基础上多增加一个数组，数组操作的时间复杂度和哈希表操作的时间复杂度均为O(1)，但是数组时间复杂度O(1)的常数项更小，因此，这种解法效率更高。
class RandomizedSet {
public:
/** Initialize your data structure here. */
RandomizedSet() {
}
/** Inserts a value to the set. Returns true if the set did not already contain the specified element. */
bool insert(int val) {
if (m.count(val)) return false;
nums.push_back(val);
m[val] = nums.size() - 1;
return true;
}
/** Removes a value from the set. Returns true if the set contained the specified element. */
bool remove(int val) {
if (!m.count(val)) return false;
int last = nums.back();
m[last] = m[val];
nums[m[val]] = last;
nums.pop_back();
m.erase(val);
return true;
}
/** Get a random element from the set. */
int getRandom() {
return nums[rand() % nums.size()];
}
//private:
//注释掉private，提高一点速度
vector<int> nums;
unordered_map<int, int> m;
};
/**
* Your RandomizedSet object will be instantiated and called as such:
* RandomizedSet obj = new RandomizedSet();
* bool param_1 = obj.insert(val);
* bool param_2 = obj.remove(val);
* int param_3 = obj.getRandom();
*/
原文地址：https://www.cnblogs.com/paulprayer/p/9927564.html
时间： 2024-10-18 19:51:30