LeetCode-Insert Delete GetRandom O(1) - Duplicates allowed

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

Note: Duplicate elements are allowed.

 

1. insert(val): Inserts an item val to the collection.
2. remove(val): Removes an item val from the collection if present.
3. getRandom: Returns a random element from current collection of elements. The probability of each element being returned is linearly related to the number of same value the collection contains.

Example:

// Init an empty collection.
RandomizedCollection collection = new RandomizedCollection();

// Inserts 1 to the collection. Returns true as the collection did not contain 1.
collection.insert(1);

// Inserts another 1 to the collection. Returns false as the collection contained 1. Collection now contains [1,1].
collection.insert(1);

// Inserts 2 to the collection, returns true. Collection now contains [1,1,2].
collection.insert(2);

// getRandom should return 1 with the probability 2/3, and returns 2 with the probability 1/3.
collection.getRandom();

// Removes 1 from the collection, returns true. Collection now contains [1,2].
collection.remove(1);

// getRandom should return 1 and 2 both equally likely.
collection.getRandom();

Analysis:
Because duplicates are allowed, we use a HashSet to store every index of a number. 

import java.util.Random;

public class RandomizedCollection {
        HashMap<Integer, HashSet<Integer>> numMap;
        List<Integer> numList;

        /** Initialize your data structure here. */
        public RandomizedCollection() {
            numMap = new HashMap<Integer, HashSet<Integer>>();
            numList = new ArrayList<Integer>();
        }

        /**
         * Inserts a value to the collection. Returns true if the collection did
         * not already contain the specified element.
         */
        public boolean insert(int val) {
            boolean hasVal = false;
            if (numMap.containsKey(val)) {
                hasVal = true;
                numMap.get(val).add(numList.size());
                numList.add(val);
            } else {
                HashSet<Integer> set = new HashSet<Integer>();
                set.add(numList.size());
                numMap.put(val, set);
                numList.add(val);
            }
            return !hasVal;
        }

        /**
         * Removes a value from the collection. Returns true if the collection
         * contained the specified element.
         */
        public boolean remove(int val) {
            if (!numMap.containsKey(val))
                return false;

            // Get an index of @val from index set and remove this index from
            // the set.
            HashSet<Integer> indSet = numMap.get(val);
            int ind = indSet.iterator().next();
            indSet.remove(ind);

            // Delete the entry, if the index list becomes empty.
            if (indSet.isEmpty()) {
                numMap.remove(val);
            }
            
            
            // Remove the indexed number from @numList by swapping it to the tail.
            // Modify the index of the tail number.
            // NOTE: it is important to check whether @ind is the tail of @numList!
            if (ind!=numList.size()-1){
                int tailNum = numList.get(numList.size() - 1);
                numMap.get(tailNum).remove(numList.size() - 1);
                numMap.get(tailNum).add(ind);
                numList.set(ind, tailNum);
            }
            numList.remove(numList.size() - 1);

            return true;
        }

        /** Get a random element from the collection. */
        public int getRandom() {
            Random engine = new Random();
            int ind = engine.nextInt(numList.size());
            return numList.get(ind);
        }
    }