LeetCode—381. Insert Delete GetRandom O(1) - Duplicates allowed (java)

问题：

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();

代码1：

public class RandomizedCollection {
List<Integer>set = new ArrayList<Integer>();
Random random;
public static void main(String[] args) {
// TODO Auto-generated method stub
SanBaYi sanbayi = new SanBaYi();
System.out.println(sanbayi.insert(1));
System.out.println(sanbayi.insert(1));
System.out.println(sanbayi.remove(1));
System.out.println(sanbayi.getRandom());
}
public SanBaYi(){
random = new Random();

}
public boolean insert(int val){
boolean flag = false;
if(!set.contains(val)){
flag = true;

}
set.add(val);
System.out.println("size:"+set.size());
return flag;

}
public boolean remove(int val){
boolean flags  = false;
if(set.contains(val)){
for(int i = set.size()-1;i>-1;i-- ){
if(set.get(i).equals(val)){
set.remove(i);
i--;
break;
}
}
flags = true;
}
return flags;
}
public  int getRandom(){
int size = set.size();
        int tmp = 0,out = 0;
        System.out.println("size:"+size);
        if(size == 1){
       return set.get(0);
       
        }else if(size > 1 ){
        tmp = random.nextInt(size);
out = set.get(tmp);
        }
return out;
}

}

代码2：

public class RandomizedCollection {  
    List<Integer> list;  
    Random r;  
    *//** Initialize your data structure here. *//*  
    public RandomizedCollection() {  
        list=new ArrayList<Integer>();  
        r=new Random();  
    }  
      
    *//** Inserts a value to the collection. Returns true if the collection did not already contain the specified element. *//*  
    public boolean insert(int val) {  
        Integer v=val;  
        boolean flag=list.contains(v);  
        list.add(v);  
        return !flag;  
    }  
      
    *//** Removes a value from the collection. Returns true if the collection contained the specified element. *//*  
    public boolean remove(int val) {  
        Integer v=val;  //转化成Object类型 根据值查找 不是根据索引查找
        boolean flag=list.contains(v);  
        list.remove(v);  
        return flag;  
    }  
      
    *//** Get a random element from the collection. *//*  
    public int getRandom() {  
        return list.get(r.nextInt(list.size()));  
    }  
} 

代码3：

public class RandomizedCollection {
    ArrayList<Integer> nums;
	HashMap<Integer, Set<Integer>> locs;
	java.util.Random rand = new java.util.Random();
    /** Initialize your data structure here. */
    public RandomizedCollection() {
        nums = new ArrayList<Integer>();
	    locs = new HashMap<Integer, Set<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 contain = locs.containsKey(val);
	    if ( ! contain ) locs.put( val, new LinkedHashSet<Integer>() ); 
	    locs.get(val).add(nums.size());        
	    nums.add(val);
	    return ! contain ;
    }
    
    /** Removes a value from the collection. Returns true if the collection contained the specified element. */
    public boolean remove(int val) {
        boolean contain = locs.containsKey(val);
	    if ( ! contain ) return false;
	    int loc = locs.get(val).iterator().next();
	    locs.get(val).remove(loc);
	    if (loc < nums.size() - 1 ) {
	       int lastone = nums.get( nums.size()-1 );
	       nums.set( loc , lastone );
	       locs.get(lastone).remove( nums.size()-1);
	       locs.get(lastone).add(loc);
	    }
	    nums.remove(nums.size() - 1);
	   
	    if (locs.get(val).isEmpty()) locs.remove(val);
	    return true;
    }
    
    /** Get a random element from the collection. */
    public int getRandom() {
        return nums.get( rand.nextInt(nums.size()) );
    }
}