Insert Delete GetRandom O(1) - Duplicates allowed

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

Design a data structure RandomizedCollection that supports inserting and removing values, as well as getting a random element from it. Duplicates are allowed in this collection.

Implement the RandomizedCollection class:

RandomizedCollection() - Initializes the empty RandomizedCollection object
bool insert(int val) - Inserts an item val into the multiset. Returns true if the item was not present, false otherwise
bool remove(int val) - Removes an item val from the multiset if present. Returns true if the item was present, false otherwise. If val has multiple occurrences, only remove one of them
int getRandom() - Returns a random element from the current multiset. The probability of each element being returned is linearly related to the number of the same values the multiset contains

All functions must work in average O(1) time complexity.

Input & Output

Example 1 — Basic Operations

$ Input: operations = ["RandomizedCollection", "insert", "insert", "insert", "getRandom", "remove", "getRandom"], values = [[], [1], [1], [2], [], [1], []]

› Output: [null, true, false, true, 1, true, 2]

💡 Note: Initialize empty collection → insert(1) returns true (new) → insert(1) returns false (duplicate) → insert(2) returns true (new) → getRandom() returns a random element from [1,1,2] → remove(1) returns true (present) → getRandom() returns a random element from remaining collection

Example 2 — Multiple Duplicates

$ Input: operations = ["RandomizedCollection", "insert", "insert", "insert", "getRandom"], values = [[], [4], [3], [4], []]

› Output: [null, true, true, false, 4]

💡 Note: Insert 4 (new), insert 3 (new), insert 4 (duplicate). Collection has [4, 3, 4]. getRandom returns a random element with probability proportional to frequency

Example 3 — Remove from Duplicates

$ Input: operations = ["RandomizedCollection", "insert", "insert", "remove", "getRandom"], values = [[], [10], [10], [10], []]

› Output: [null, true, false, true, 10]

💡 Note: Insert 10 twice, then remove one occurrence. One 10 remains, so getRandom returns the remaining element

Constraints

-2³¹ ≤ val ≤ 2³¹ - 1
At most 2 * 10⁵ calls will be made to insert, remove, and getRandom
There will be at least one element in the data structure when getRandom is called

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 a Amazon 8 M Microsoft 6

The key insight is using a dynamic array for O(1) random access combined with a hash map that maps each value to a set of indices where it appears. The optimal approach uses the swap-with-last technique for O(1) removal while maintaining index consistency. Time: O(1) average, Space: O(n).

Common Approaches

✓ Brute Force with List

⏱️ Time: O(n) Space: O(n)

Store all elements in a list. For insert, append to end. For remove, search through list to find element. For getRandom, pick random index.

Hash Map + Dynamic Array

⏱️ Time: O(1) Space: O(n)

Maintain a dynamic array for elements and a hash map where each value maps to a set of indices. This allows O(1) insert, remove, and getRandom operations.

Brute Force with List — Algorithm Steps

Step 1: Store elements in a simple list
Step 2: For remove, linear search to find element
Step 3: For getRandom, pick random index from list

Visualization

Tap to expand

Step-by-Step Walkthrough

Insert

Append to end of list

Remove

Linear search through list

Random

Pick random index

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <time.h>

typedef struct {
    int* nums;
    int size;
    int capacity;
} RandomizedCollection;

RandomizedCollection* randomizedCollectionCreate() {
    RandomizedCollection* obj = malloc(sizeof(RandomizedCollection));
    obj->capacity = 1000;
    obj->nums = malloc(obj->capacity * sizeof(int));
    obj->size = 0;
    srand(time(NULL));
    return obj;
}

bool randomizedCollectionInsert(RandomizedCollection* obj, int val) {
    bool wasPresent = false;
    for (int i = 0; i < obj->size; i++) {
        if (obj->nums[i] == val) {
            wasPresent = true;
            break;
        }
    }
    
    if (obj->size >= obj->capacity) {
        obj->capacity *= 2;
        obj->nums = realloc(obj->nums, obj->capacity * sizeof(int));
    }
    
    obj->nums[obj->size++] = val;
    return !wasPresent;
}

bool randomizedCollectionRemove(RandomizedCollection* obj, int val) {
    for (int i = 0; i < obj->size; i++) {
        if (obj->nums[i] == val) {
            for (int j = i; j < obj->size - 1; j++) {
                obj->nums[j] = obj->nums[j + 1];
            }
            obj->size--;
            return true;
        }
    }
    return false;
}

int randomizedCollectionGetRandom(RandomizedCollection* obj) {
    int randomIndex = rand() % obj->size;
    return obj->nums[randomIndex];
}

int main() {
    printf("[null]\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Remove operation requires linear search through the list

✓ Linear Growth

Space Complexity

O(n)

List stores all n elements

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~25 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force with List — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler