380. Insert Delete GetRandom O(1)

https://leetcode.com/problems/insert-delete-getrandom-o1/

Design a data structure that supports all following operations in average O(1) time.

1. insert(val): Inserts an item val to the set if not already present.
2. remove(val): Removes an item val from the set if present.
3. getRandom: Returns a random element from current set of elements. Each element must have the same probability of being returned.

Example:

// Init an empty set.
RandomizedSet randomSet = new RandomizedSet();

// Inserts 1 to the set. Returns true as 1 was inserted successfully.
randomSet.insert(1);

// Returns false as 2 does not exist in the set.
randomSet.remove(2);

// Inserts 2 to the set, returns true. Set now contains [1,2].
randomSet.insert(2);

// getRandom should return either 1 or 2 randomly.
randomSet.getRandom();

// Removes 1 from the set, returns true. Set now contains [2].
randomSet.remove(1);

// 2 was already in the set, so return false.
randomSet.insert(2);

// Since 2 is the only number in the set, getRandom always return 2.
randomSet.getRandom();

---
Related problems

381-insert-delete-getrandom-o1

382-linked-list-random-node
398-random-pick-index
528-random-pick-with-weight
---

	class RandomizedSet {
	// Random number generator, create it once for the class
	Random random;
	// Map the value to index of entry in List
	Map<Integer, Integer> map;
	// Actual storage of val, return entry from a random index
	List<Integer> list;
	/** Initialize your data structure here. */
	public RandomizedSet() {
	map = new HashMap<Integer, Integer>();
	list = new ArrayList<Integer>();
	random = new Random();
	}
	/** Inserts a value to the set. Returns true if the set did not already contain the specified element. */
	public boolean insert(int val) {
	if (!map.containsKey(val)) {
	// Save New index in map
	map.put(val, list.size());
	// Add to the end of list
	list.add(val);
	return true;
	}
	return false;
	}
	/** Removes a value from the set. Returns true if the set contained the specified element. */
	public boolean remove(int val) {
	if (map.containsKey(val)) {
	// Entry to delete
	int currentIndex = map.get(val);
	// Last entry in list
	int lastVal = list.get(list.size() - 1);
	// Pull in the last entry in list
	list.set(currentIndex, lastVal);
	// Sync the index of last val in map
	map.put(lastVal, currentIndex);
	// Remove target entry from map
	map.remove(val);
	// Remove last entry.. duplicated now at currentIndex
	list.remove(list.size() - 1);
	return true;
	}
	return false;
	}
	/** Get a random element from the set. */
	public int getRandom() {
	return list.get(random.nextInt(list.size()));
	}
	}
	/**
	* Your RandomizedSet object will be instantiated and called as such:
	* RandomizedSet obj = new RandomizedSet();
	* boolean param_1 = obj.insert(val);
	* boolean param_2 = obj.remove(val);
	* int param_3 = obj.getRandom();
	*/

view raw 380.InsertDeleteGetRandomO(1).java hosted with ❤ by GitHub

	class RandomizedSet:
	def __init__(self):
	self.items = []
	self.positions = {}
	def insert(self, val: int) -> bool:
	if val in self.positions:
	return False
	self.positions[val] = len(self.items)
	self.items.append(val)
	return True
	def remove(self, val: int) -> bool:
	if not val in self.positions:
	return False
	last = self.items[-1]
	index = self.positions[val]
	self.items[index] = last
	self.positions[last] = index
	del self.items[-1]
	del self.positions[val]
	return True
	def getRandom(self) -> int:
	return self.items[random.randint(0, len(self.items) - 1)]
	# Your RandomizedSet object will be instantiated and called as such:
	# obj = RandomizedSet()
	# param_1 = obj.insert(val)
	# param_2 = obj.remove(val)
	# param_3 = obj.getRandom()

view raw 380.InsertDeleteGetRandomO(1).py hosted with ❤ by GitHub