Insert Delete GetRandom O(1) - Practice Coding Problems

Insert Delete GetRandom O(1) - Problem

Design a data structure that supports insert, delete, and getRandom operations, all in average O(1) time complexity.

You need to implement the RandomizedSet class with these methods:

RandomizedSet() - Initializes the data structure
bool insert(int val) - Inserts val into the set if not present. Returns true if inserted, false if already exists
bool remove(int val) - Removes val from the set if present. Returns true if removed, false if not found
int getRandom() - Returns a random element from the set with equal probability for each element

The challenge is achieving O(1) average time complexity for all operations while maintaining uniform random distribution.

Input & Output

example_1.py — Basic Operations

$ Input: RandomizedSet rs = new RandomizedSet(); rs.insert(1); // return true rs.remove(2); // return false (not present) rs.insert(2); // return true rs.getRandom(); // return 1 or 2 (equal probability) rs.remove(1); // return true rs.insert(2); // return false (already present) rs.getRandom(); // return 2

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

💡 Note: Insert 1 succeeds. Remove 2 fails as it doesn't exist. Insert 2 succeeds. GetRandom returns either 1 or 2. Remove 1 succeeds. Insert 2 fails as it already exists. GetRandom returns 2 (only element left).

example_2.py — Single Element

$ Input: RandomizedSet rs = new RandomizedSet(); rs.insert(5); // return true rs.getRandom(); // return 5 rs.remove(5); // return true

› Output: [true, 5, true]

💡 Note: With only one element, getRandom always returns that element. All operations work correctly with single element.

example_3.py — Duplicate Operations

$ Input: RandomizedSet rs = new RandomizedSet(); rs.insert(10); // return true rs.insert(10); // return false (duplicate) rs.remove(10); // return true rs.remove(10); // return false (already removed)

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

💡 Note: First insert succeeds. Second insert fails due to duplicate. First remove succeeds. Second remove fails as element no longer exists.

Visualization

Tap to expand

Understanding the Visualization

New Member Joins

Check directory to see if they're already a member. If not, add their name to the end of the roster and record their position in the directory.

Member Leaves

Look up their position in the directory. Move the last person on the roster to fill their spot, update the directory, then remove the now-empty last position.

Pick Random Winner

Generate a random number within the roster size and announce the winner at that position. Every member has equal chances!

Key Takeaway

🎯 Key Insight: By combining array's instant random access with HashMap's instant lookups, and using the swap-with-last trick, we achieve O(1) for all operations while maintaining perfect randomness!

Time & Space Complexity

Time Complexity

⏱️

O(1)

Array operations and HashMap operations are both O(1) on average

✓ Linear Growth

Space Complexity

O(n)

Array stores n elements, HashMap stores n key-value pairs

⚡ Linearithmic Space

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

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28 Apple 22

The optimal solution combines an array for O(1) random access with a HashMap for O(1) lookups. The key insight is using the swap-with-last technique during removal to avoid expensive element shifting, maintaining O(1) average time complexity for all operations while ensuring uniform random distribution.

Common Approaches

Approach	Time	Space	Notes
✓ Array + HashMap (Optimal)	O(1)	O(n)	Use array for random access and HashMap to track indices for O(1) operations
Array with Linear Search	O(n)	O(n)	Use a simple array and search linearly for operations

Array + HashMap (Optimal) — Algorithm Steps

Maintain an array to store values and a HashMap to store value->index mapping
Insert: Check HashMap for existence, if not present, append to array and update HashMap
Remove: Get index from HashMap, swap element with last element, update HashMap for swapped element, remove last element
GetRandom: Generate random index within array bounds and return element

Visualization

Tap to expand

Step-by-Step Walkthrough

Insert Elements

Add elements to array end, update HashMap with index

Remove Element

Swap target with last element, update indices, remove last

Get Random

Use random index to access array directly

Code -

solution.c — C

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

#define HASH_SIZE 10007

typedef struct HashNode {
    int key;
    int value;
    struct HashNode* next;
} HashNode;

typedef struct {
    int* data;
    int size;
    int capacity;
    HashNode* hash[HASH_SIZE];
} RandomizedSet;

int hash_func(int key) {
    return abs(key) % HASH_SIZE;
}

RandomizedSet* randomizedSetCreate() {
    RandomizedSet* rs = malloc(sizeof(RandomizedSet));
    rs->capacity = 1000;
    rs->data = malloc(rs->capacity * sizeof(int));
    rs->size = 0;
    for (int i = 0; i < HASH_SIZE; i++) {
        rs->hash[i] = NULL;
    }
    srand(time(NULL));
    return rs;
}

bool randomizedSetInsert(RandomizedSet* rs, int val) {
    int idx = hash_func(val);
    HashNode* node = rs->hash[idx];
    
    // Check if exists
    while (node) {
        if (node->key == val) return false;
        node = node->next;
    }
    
    // Insert new node
    HashNode* newNode = malloc(sizeof(HashNode));
    newNode->key = val;
    newNode->value = rs->size;
    newNode->next = rs->hash[idx];
    rs->hash[idx] = newNode;
    
    rs->data[rs->size++] = val;
    return true;
}

bool randomizedSetRemove(RandomizedSet* rs, int val) {
    int idx = hash_func(val);
    HashNode** node = &rs->hash[idx];
    
    while (*node) {
        if ((*node)->key == val) {
            int index = (*node)->value;
            int lastElement = rs->data[rs->size - 1];
            
            // Swap with last element
            rs->data[index] = lastElement;
            
            // Update hash for swapped element
            int lastIdx = hash_func(lastElement);
            HashNode* lastNode = rs->hash[lastIdx];
            while (lastNode && lastNode->key != lastElement) {
                lastNode = lastNode->next;
            }
            if (lastNode) lastNode->value = index;
            
            // Remove node
            HashNode* toDelete = *node;
            *node = (*node)->next;
            free(toDelete);
            
            rs->size--;
            return true;
        }
        node = &(*node)->next;
    }
    return false;
}

int randomizedSetGetRandom(RandomizedSet* rs) {
    return rs->data[rand() % rs->size];
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Array operations and HashMap operations are both O(1) on average

✓ Linear Growth

Space Complexity

O(n)

Array stores n elements, HashMap stores n key-value pairs

⚡ Linearithmic Space

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

63.5K Views

High Frequency

~25 min Avg. Time

1.5K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Array + HashMap (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler