Search code examples
javadata-structurescomplexity-theorymontecarlopicking

picking without replacement in java

I often* find myself in need of a data structure which has the following properties:

  • can be initialized with an array of n objects in O(n).
  • one can obtain a random element in O(1), after this operation the picked element is removed from the structure. (without replacement)
  • one can undo p 'picking without replacement' operations in O(p)
  • one can remove a specific object (eg by id) from the structure in O(log(n))
  • one can obtain an array of the objects currently in the structure in O(n).

the complexity (or even possibility) of other actions (eg insert) does not matter. Besides the complexity it should also be efficient for small numbers of n.

Can anyone give me guidelines on implementing such a structure? I currently implemented a structure having all above properties, except the picking of the element takes O(d) with d the number of past picks (since I explicitly check whether it is 'not yet picked'). I can figure out structures allowing picking in O(1), but these have higher complexities on at least one of the other operations.

BTW: note that O(1) above implies that the complexity is independent from #earlier picked elements and independent from total #elements.

*in monte carlo algorithms (iterative picks of p random elements from a 'set' of n elements).

Solution

  • Ok, same answer as 0verbose with a simple fix to get the O(1) random lookup. Create an array which stores the same n objects. Now, in the HashMap, store the pairs . For example, say your Objects (strings for simplicity) are:

    {"abc" , "def", "ghi"}

    Create an 

    List<String> array = ArrayList<String>("abc","def","ghi")

    Create a HashMap map with the following values:

    for (int i = 0; i < array.size(); i++) 
{
    map.put(array[i],i);
}

    O(1) random lookup is easily achieved by picking any index in the array. The only complication that arises is when you delete an object. For that, do:

    1. Find object in map. Get its array index. Lets call this index i (map.get(i)) - O(1)

    2. Swap array[i] with array[size of array - 1] (the last element in the array). Reduce the size of the array by 1 (since there is one less number now) - O(1)

    3. Update the index of the new object in position i of the array in map (map.put(array[i], i)) - O(1)

    I apologize for the mix of java and cpp notation, hope this helps