leetcode381. Insert Delete GetRandom O(1) - Duplicates allowed-优快云博客

本文介绍了一种支持插入、删除和随机获取元素操作的数据结构，并且所有这些操作都能够在平均O(1)时间内完成。该数据结构允许元素重复，使用一个列表和一个映射来维护元素及其位置信息，确保了高效的操作执行。

381. 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.
insert(val): Inserts an item val to the collection.
remove(val): Removes an item val from the collection if present.
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();

解法

用一个list和一个map，list中存放添加的元素列表，map中key为添加的元素的值，value为该元素在list中的位置set。每次添加元素时，更新set。每次删除元素时，如果不是list中的最后一个元素，最后一个元素占领该删除元素的位置。更新最后一个元素的set表，更新被删除元素的set表。

public class RandomizedCollection {
    List<Integer> nums;
    Map<Integer, Set<Integer>> loc;
    Random random;

    /**
     * Initialize your data structure here.
     */
    public RandomizedCollection() {
        nums = new ArrayList<Integer>();
        loc = new HashMap<Integer, Set<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) {
        boolean flag = loc.containsKey(val);
        Set <Integer> position;
        if (flag) {
            position = loc.get(val);
        } else {
            position = new HashSet<>();
        }
        position.add(nums.size());
        loc.put(val, position);
        nums.add(val);

        return !flag;
    }

    /**
     * Removes a value from the set. Returns true if the set contained the specified element.
     */
    public boolean remove(int val) {
        boolean flag = loc.containsKey(val);
        if (!flag) {
            return false;
        }
        Set<Integer> position = loc.get(val);
        int l = position.iterator().next();
        position.remove(l);
        if (l < nums.size() - 1) {
            int lastnode = nums.get(nums.size() - 1);
            nums.set(l, lastnode);
            Set<Integer> lastPosition = loc.get(lastnode);
            int p = nums.size() - 1;
            lastPosition.remove(p);
            lastPosition.add(l);
            // loc.put(lastnode, lastPosition);
        }
        // position.remove(l);

        if (position == null || position.size() == 0) {
            loc.remove(val);
        } 

        nums.remove(nums.size() - 1);
        return flag;
    }

    /**
     * Get a random element from the set.
     */
    public int getRandom() {
        return nums.get(random.nextInt(nums.size()));
    }
}

/**
 * Your RandomizedCollection object will be instantiated and called as such:
 * RandomizedCollection obj = new RandomizedCollection();
 * boolean param_1 = obj.insert(val);
 * boolean param_2 = obj.remove(val);
 * int param_3 = obj.getRandom();
 */