Insert Delete GetRandom O(1)

Insert Delete GetRandom O(1) - Problem

Design a data structure that supports all following operations in average O(1) time.

Implement the RandomizedSet class:

RandomizedSet() Initializes the RandomizedSet object.
bool insert(int val) Inserts an item val into the set if not present. Returns true if the item was not present, false otherwise.
bool remove(int val) Removes an item val from the set if present. Returns true if the item was present, false otherwise.
int getRandom() Returns a random element from the current set of elements (it's guaranteed that at least one element exists when this method is called). Each element must have the same probability of being returned.

You must implement the functions of the class such that each function works in average O(1) time complexity.

Input & Output

Example 1 — Basic Operations

$ Input: ["RandomizedSet","insert","remove","insert","getRandom","remove","insert","getRandom"] [[], [1], [2], [2], [], [1], [2], []]

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

💡 Note: RandomizedSet() initializes empty set. insert(1) adds 1, returns true. remove(2) tries to remove non-existent 2, returns false. insert(2) adds 2, returns true. getRandom() returns 2 (only element). remove(1) removes 1, returns true. insert(2) tries to add existing 2, returns false. getRandom() returns 2.

Example 2 — Multiple Elements

$ Input: ["RandomizedSet","insert","insert","insert","getRandom","getRandom"] [[], [1], [2], [3], [], []]

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

💡 Note: Insert three elements [1,2,3]. Each getRandom() call returns one of these elements with equal probability.

Example 3 — Edge Case Single Element

$ Input: ["RandomizedSet","insert","getRandom","remove"] [[], [5], [], [5]]

› Output: [null, true, 5, true]

💡 Note: Insert single element 5. getRandom() must return 5 (only choice). Remove 5 successfully.

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 45 a Amazon 38 f Facebook 32 M Microsoft 28

The optimal solution combines an array for O(1) random access with a hashmap for O(1) insert/remove operations. The key insight is using the swap-with-last technique to maintain array compactness during removal. Time: O(1) average for all operations, Space: O(n).

Common Approaches

✓ Bfs

⏱️ Time: N/A Space: N/A

Array + HashMap (Optimal)

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

Use an array to store values for O(1) random access, and a hashmap to store value-to-index mapping for O(1) insert/remove. When removing, swap the element with the last element to avoid shifting.

Array Only (Brute Force)

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

Store elements in an array. For insert, check if element exists by scanning entire array. For remove, find element and shift remaining elements. For getRandom, pick random index.

Hash Set Only

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

Store elements in a hash set for fast insert/remove operations. However, getRandom requires converting the set to a list each time, making it inefficient.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_SIZE 100000
#define MAX_ITEMS 100000

typedef struct {
    int row, col, dist;
} QueueItem;

typedef struct {
    int dist, price, row, col;
} Item;

int compare(const void* a, const void* b) {
    Item* ia = (Item*)a;
    Item* ib = (Item*)b;
    if (ia->dist != ib->dist) return ia->dist - ib->dist;
    if (ia->price != ib->price) return ia->price - ib->price;
    if (ia->row != ib->row) return ia->row - ib->row;
    return ia->col - ib->col;
}

int parseGrid(char* line, int grid[][1000], int* m, int* n) {
    *m = 0; *n = 0;
    int i = 1, row = 0, col = 0;
    int num = 0;
    
    while (line[i] != '\0' && line[i] != ']') {
        if (line[i] == '[') {
            col = 0;
            i++;
            continue;
        }
        if (line[i] == ']') {
            if (col > 0) {
                grid[row][col] = num;
                col++;
                if (row == 0) *n = col;
                row++;
                num = 0;
            }
            i++;
            continue;
        }
        if (line[i] == ',') {
            if (col >= 0) {
                grid[row][col] = num;
                col++;
                num = 0;
            }
            i++;
            continue;
        }
        if (line[i] >= '0' && line[i] <= '9') {
            num = num * 10 + (line[i] - '0');
        }
        i++;
    }
    *m = row;
    return 1;
}

int main() {
    char line[10000];
    int grid[1000][1000];
    int m, n;
    int pricing[2], start[2], k;
    
    // Read and parse grid
    fgets(line, sizeof(line), stdin);
    parseGrid(line, grid, &m, &n);
    
    // Parse pricing
    fgets(line, sizeof(line), stdin);
    sscanf(line, "[%d,%d]", &pricing[0], &pricing[1]);
    
    // Parse start
    fgets(line, sizeof(line), stdin);
    sscanf(line, "[%d,%d]", &start[0], &start[1]);
    
    // Parse k
    fgets(line, sizeof(line), stdin);
    k = atoi(line);
    
    int low = pricing[0], high = pricing[1];
    int startRow = start[0], startCol = start[1];
    
    // BFS
    QueueItem queue[MAX_SIZE];
    int visited[1000][1000] = {0};
    Item items[MAX_ITEMS];
    int front = 0, rear = 0, itemCount = 0;
    
    queue[rear++] = (QueueItem){startRow, startCol, 0};
    visited[startRow][startCol] = 1;
    
    int directions[4][2] = {{0,1}, {1,0}, {0,-1}, {-1,0}};
    
    while (front < rear) {
        QueueItem curr = queue[front++];
        
        // Check if current cell has item in price range
        if (grid[curr.row][curr.col] >= low && grid[curr.row][curr.col] <= high) {
            items[itemCount++] = (Item){curr.dist, grid[curr.row][curr.col], curr.row, curr.col};
        }
        
        // Explore neighbors
        for (int i = 0; i < 4; i++) {
            int newRow = curr.row + directions[i][0];
            int newCol = curr.col + directions[i][1];
            
            if (newRow >= 0 && newRow < m && newCol >= 0 && newCol < n && 
                !visited[newRow][newCol] && grid[newRow][newCol] != 0) {
                visited[newRow][newCol] = 1;
                queue[rear++] = (QueueItem){newRow, newCol, curr.dist + 1};
            }
        }
    }
    
    // Sort items
    qsort(items, itemCount, sizeof(Item), compare);
    
    // Print result
    printf("[");
    for (int i = 0; i < k && i < itemCount; i++) {
        if (i > 0) printf(",");
        printf("[%d,%d]", items[i].row, items[i].col);
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

⚡ Linearithmic Space

89.0K Views

High Frequency

~25 min Avg. Time

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