我在一次采访中遇到了这个问题。你会怎么回答？
设计一个在 O(1) 时间内提供以下操作的数据结构：
【问题讨论】：
标签： data-structures
我们为什么不使用 epoch%arraysize 来查找随机元素。查找数组大小为 O(n)，但摊销复杂度为 O(1)。
【讨论】：
对于这个问题，我将使用两个数据结构
步骤：-
代码：-
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Random;
import java.util.Scanner;
public class JavaApplication1 {
public static void main(String args[]){
Scanner sc = new Scanner(System.in);
ArrayList<Integer> al =new ArrayList<Integer>();
HashMap<Integer,Integer> mp = new HashMap<Integer,Integer>();
while(true){
System.out.println("**menu**");
System.out.println("1.insert");
System.out.println("2.remove");
System.out.println("3.search");
System.out.println("4.rendom");
int ch = sc.nextInt();
switch(ch){
case 1 : System.out.println("Enter the Element ");
int a = sc.nextInt();
if(mp.containsKey(a)){
System.out.println("Element is already present ");
}
else{
al.add(a);
mp.put(a, al.size()-1);
}
break;
case 2 : System.out.println("Enter the Element Which u want to remove");
a = sc.nextInt();
if(mp.containsKey(a)){
int size = al.size();
int index = mp.get(a);
int last = al.get(size-1);
Collections.swap(al, index, size-1);
al.remove(size-1);
mp.put(last, index);
System.out.println("Data Deleted");
}
else{
System.out.println("Data Not found");
}
break;
case 3 : System.out.println("Enter the Element to Search");
a = sc.nextInt();
if(mp.containsKey(a)){
System.out.println(mp.get(a));
}
else{
System.out.println("Data Not Found");
}
break;
case 4 : Random rm = new Random();
int index = rm.nextInt(al.size());
System.out.println(al.get(index));
break;
}
}
}
}
-- 时间复杂度 O(1)。 -- 空间复杂度 O(N)。
【讨论】：
/* Java program to design a data structure that support folloiwng operations
in Theta(n) time
a) Insert
b) Delete
c) Search
d) getRandom */
import java.util.*;
// class to represent the required data structure
class MyDS
{
ArrayList<Integer> arr; // A resizable array
// A hash where keys are array elements and vlaues are
// indexes in arr[]
HashMap<Integer, Integer> hash;
// Constructor (creates arr[] and hash)
public MyDS()
{
arr = new ArrayList<Integer>();
hash = new HashMap<Integer, Integer>();
}
// A Theta(1) function to add an element to MyDS
// data structure
void add(int x)
{
// If ekement is already present, then noting to do
if (hash.get(x) != null)
return;
// Else put element at the end of arr[]
int s = arr.size();
arr.add(x);
// And put in hash also
hash.put(x, s);
}
// A Theta(1) function to remove an element from MyDS
// data structure
void remove(int x)
{
// Check if element is present
Integer index = hash.get(x);
if (index == null)
return;
// If present, then remove element from hash
hash.remove(x);
// Swap element with last element so that remove from
// arr[] can be done in O(1) time
int size = arr.size();
Integer last = arr.get(size-1);
Collections.swap(arr, index, size-1);
// Remove last element (This is O(1))
arr.remove(size-1);
// Update hash table for new index of last element
hash.put(last, index);
}
// Returns a random element from MyDS
int getRandom()
{
// Find a random index from 0 to size - 1
Random rand = new Random(); // Choose a different seed
int index = rand.nextInt(arr.size());
// Return element at randomly picked index
return arr.get(index);
}
// Returns index of element if element is present, otherwise null
Integer search(int x)
{
return hash.get(x);
}
}
// Driver class
class Main
{
public static void main (String[] args)
{
MyDS ds = new MyDS();
ds.add(10);
ds.add(20);
ds.add(30);
ds.add(40);
System.out.println(ds.search(30));
ds.remove(20);
ds.add(50);
System.out.println(ds.search(50));
System.out.println(ds.getRandom());`enter code here`
}
}
【讨论】：
我们不能使用 Java 的 HashSet 来做到这一点吗？默认情况下，它在 O(1) 中提供插入、删除、搜索所有功能。 对于 getRandom 我们可以使用 Set 的迭代器，它无论如何都会给出随机行为。我们可以只从集合中迭代第一个元素而不必担心其余元素
public void getRandom(){
Iterator<integer> sitr = s.iterator();
Integer x = sitr.next();
return x;
}
【讨论】：
我同意 Anon 的观点。除了最后一个要求获得具有相同公平性的随机元素之外，所有其他要求只能使用单个基于哈希的 DS 来解决。我将在 Java 中为此选择 HashSet。元素哈希码的模数将为我提供 O(1) 时间内底层数组的索引号。我可以将它用于添加、删除和包含操作。
【讨论】：
考虑一个由哈希表 H 和数组 A 组成的数据结构。哈希表的键是数据结构中的元素，值是它们在数组中的位置。
由于数组需要自动增加大小，因此添加一个元素需要 O(1) 分期，但我想这没关系。
【讨论】：
虽然这已经很老了，但由于在 C++ 中没有答案，这是我的两分钱。
#include <vector>
#include <unordered_map>
#include <stdlib.h>
template <typename T> class bucket{
int size;
std::vector<T> v;
std::unordered_map<T, int> m;
public:
bucket(){
size = 0;
std::vector<T>* v = new std::vector<T>();
std::unordered_map<T, int>* m = new std::unordered_map<T, int>();
}
void insert(const T& item){
//prevent insertion of duplicates
if(m.find(item) != m.end()){
exit(-1);
}
v.push_back(item);
m.emplace(item, size);
size++;
}
void remove(const T& item){
//exits if the item is not present in the list
if(m[item] == -1){
exit(-1);
}else if(m.find(item) == m.end()){
exit(-1);
}
int idx = m[item];
m[v.back()] = idx;
T itm = v[idx];
v.insert(v.begin()+idx, v.back());
v.erase(v.begin()+idx+1);
v.insert(v.begin()+size, itm);
v.erase(v.begin()+size);
m[item] = -1;
v.pop_back();
size--;
}
T& getRandom(){
int idx = rand()%size;
return v[idx];
}
bool lookup(const T& item){
if(m.find(item) == m.end()) return false;
return true;
}
//method to check that remove has worked
void print(){
for(auto it = v.begin(); it != v.end(); it++){
std::cout<<*it<<" ";
}
}
};
这是一段测试解决方案的客户端代码。
int main() {
bucket<char>* b = new bucket<char>();
b->insert('d');
b->insert('k');
b->insert('l');
b->insert('h');
b->insert('j');
b->insert('z');
b->insert('p');
std::cout<<b->random()<<std::endl;
b->print();
std::cout<<std::endl;
b->remove('h');
b->print();
return 0;
}
【讨论】：
我们可以使用散列来支持 Θ(1) 时间内的运算。
插入（x） 1) 通过进行哈希映射查找来检查 x 是否已经存在。 2）如果不存在，则将其插入数组的末尾。 3) 也加入hash table，x作为key，最后一个数组索引作为index。
移除(x) 1) 通过进行哈希映射查找来检查 x 是否存在。 2）如果存在，则找到其索引并将其从哈希映射中删除。 3) 将数组中的最后一个元素与该元素交换并删除最后一个元素。 完成交换是因为可以在 O(1) 时间内删除最后一个元素。 4) 更新哈希图中最后一个元素的索引。
getRandom() 1) 生成一个从 0 到最后一个索引的随机数。 2) 返回随机生成索引处的数组元素。
搜索（x） 在哈希图中查找 x。
【讨论】：
你可能不喜欢这个，因为他们可能正在寻找一个聪明的解决方案，但有时坚持你的枪是值得的......哈希表已经满足要求 - 总体上可能更好比其他任何东西都好（尽管显然是在摊销的常数时间内，并且对其他解决方案有不同的妥协）。
棘手的要求是“随机元素”选择：在哈希表中，您需要扫描或探测这样的元素。
对于封闭式散列/开放式寻址，任何给定存储桶被占用的机会为size() / capacity()，但至关重要的是，这通常通过散列表实现保持在恒定的乘法范围内（例如，表可能保持大于其根据性能/内存调整，将当前内容提高 1.2 倍到 ~10 倍）。这意味着我们平均可以预期搜索 1.2 到 10 个桶——完全独立于容器的总大小；摊销 O(1)。
我可以想象两种简单的方法（还有很多更复杂的方法）：
从随机桶中线性搜索
反复尝试随机存储桶，直到找到一个已填充的存储桶
不是一个很好的解决方案，但与始终维护第二个索引数组的内存和性能开销相比，它可能仍然是一个更好的整体折衷方案。
【讨论】：
我认为我们可以使用带有哈希表的双向链表。键将是元素，其关联值将是双向链表中的节点。
【讨论】：
这是我不久前在被问到相同问题时提出的该问题的 C# 解决方案。它实现了 Add、Remove、Contains 和 Random 以及其他标准 .NET 接口。并不是说您需要在面试中如此详细地实施它，但很高兴有一个具体的解决方案来查看......
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
/// <summary>
/// This class represents an unordered bag of items with the
/// the capability to get a random item. All operations are O(1).
/// </summary>
/// <typeparam name="T">The type of the item.</typeparam>
public class Bag<T> : ICollection<T>, IEnumerable<T>, ICollection, IEnumerable
{
private Dictionary<T, int> index;
private List<T> items;
private Random rand;
private object syncRoot;
/// <summary>
/// Initializes a new instance of the <see cref="Bag<T>"/> class.
/// </summary>
public Bag()
: this(0)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="Bag<T>"/> class.
/// </summary>
/// <param name="capacity">The capacity.</param>
public Bag(int capacity)
{
this.index = new Dictionary<T, int>(capacity);
this.items = new List<T>(capacity);
}
/// <summary>
/// Initializes a new instance of the <see cref="Bag<T>"/> class.
/// </summary>
/// <param name="collection">The collection.</param>
public Bag(IEnumerable<T> collection)
{
this.items = new List<T>(collection);
this.index = this.items
.Select((value, index) => new { value, index })
.ToDictionary(pair => pair.value, pair => pair.index);
}
/// <summary>
/// Get random item from bag.
/// </summary>
/// <returns>Random item from bag.</returns>
/// <exception cref="System.InvalidOperationException">
/// The bag is empty.
/// </exception>
public T Random()
{
if (this.items.Count == 0)
{
throw new InvalidOperationException();
}
if (this.rand == null)
{
this.rand = new Random();
}
int randomIndex = this.rand.Next(0, this.items.Count);
return this.items[randomIndex];
}
/// <summary>
/// Adds the specified item.
/// </summary>
/// <param name="item">The item.</param>
public void Add(T item)
{
this.index.Add(item, this.items.Count);
this.items.Add(item);
}
/// <summary>
/// Removes the specified item.
/// </summary>
/// <param name="item">The item.</param>
/// <returns></returns>
public bool Remove(T item)
{
// Replace index of value to remove with last item in values list
int keyIndex = this.index[item];
T lastItem = this.items[this.items.Count - 1];
this.items[keyIndex] = lastItem;
// Update index in dictionary for last item that was just moved
this.index[lastItem] = keyIndex;
// Remove old value
this.index.Remove(item);
this.items.RemoveAt(this.items.Count - 1);
return true;
}
/// <inheritdoc />
public bool Contains(T item)
{
return this.index.ContainsKey(item);
}
/// <inheritdoc />
public void Clear()
{
this.index.Clear();
this.items.Clear();
}
/// <inheritdoc />
public int Count
{
get { return this.items.Count; }
}
/// <inheritdoc />
public void CopyTo(T[] array, int arrayIndex)
{
this.items.CopyTo(array, arrayIndex);
}
/// <inheritdoc />
public bool IsReadOnly
{
get { return false; }
}
/// <inheritdoc />
public IEnumerator<T> GetEnumerator()
{
foreach (var value in this.items)
{
yield return value;
}
}
/// <inheritdoc />
IEnumerator IEnumerable.GetEnumerator()
{
return this.GetEnumerator();
}
/// <inheritdoc />
public void CopyTo(Array array, int index)
{
this.CopyTo(array as T[], index);
}
/// <inheritdoc />
public bool IsSynchronized
{
get { return false; }
}
/// <inheritdoc />
public object SyncRoot
{
get
{
if (this.syncRoot == null)
{
Interlocked.CompareExchange<object>(
ref this.syncRoot,
new object(),
null);
}
return this.syncRoot;
}
}
}
【讨论】：
ArgumentException 并显示消息“已添加具有相同密钥的项目”。将被抛出（来自底层索引字典）。
在 C# 3.0 + .NET Framework 4 中，泛型 Dictionary<TKey,TValue> 甚至比 Hashtable 更好，因为您可以使用 System.Linq 扩展方法 ElementAt() 来索引到 KeyValuePair<TKey,TValue> 元素所在的底层动态数组存储：
using System.Linq;
Random _generator = new Random((int)DateTime.Now.Ticks);
Dictionary<string,object> _elements = new Dictionary<string,object>();
....
Public object GetRandom()
{
return _elements.ElementAt(_generator.Next(_elements.Count)).Value;
}
但是，据我所知，哈希表（或其字典后代）并不是这个问题的真正解决方案，因为 Put() 只能摊销 O(1) ，而不是真正的 O(1) ，因为它是在动态调整大小边界处 O(N)。
这个问题有真正的解决方案吗？我能想到的是，如果您指定一个字典/哈希表的初始容量超出您预期的一个数量级，那么您将获得 O(1) 操作，因为您永远不需要调整大小。
【讨论】：
最好的解决方案可能是哈希表+数组，它真正快速且确定性。
但评分最低的答案（只需使用哈希表！）实际上也很棒！
人们可能不喜欢这个，因为“可能存在无限循环”，我见过非常聪明的人也有这种反应，但这是错误的！无限可能的事件只是不会发生。
假设您的伪随机源的良好行为（对于这种特定行为并不难确定）并且哈希表总是至少 20% 已满，很容易看出：
永远不会发生 getRandom() 必须尝试超过 1000 次的情况。只是从不。事实上，这种事件的概率是 0.8^1000，即 10^-97——所以我们必须重复 10^88 次才能有十亿分之一的机会发生一次。即使这个程序在人类所有计算机上全时运行直到太阳灭亡，这永远不会发生。
【讨论】：
O(1) 查找意味着 hashed data structure。
对比：
【讨论】：
hashtable.get((int)(Math.random()*hashtable.size()));