Design HashMap

Design HashMap - Problem

Design a HashMap without using any built-in hash table libraries.

Implement the MyHashMap class:

MyHashMap() initializes the object with an empty map.
void put(int key, int value) inserts a (key, value) pair into the HashMap. If the key already exists in the map, update the corresponding value.
int get(int key) returns the value to which the specified key is mapped, or -1 if this map contains no mapping for the key.
void remove(int key) removes the key and its corresponding value if the map contains the mapping for the key.

Input & Output

Example 1 — Basic Operations

$ Input: operations = ["MyHashMap","put","put","get","get","put","get","remove","get"], values = [[],[1,1],[2,2],[1],[3],[2,1],[2],[2],[2]]

› Output: [null,null,null,1,-1,null,1,null,-1]

💡 Note: Create empty hashmap, put(1,1), put(2,2), get(1)→1, get(3)→-1, put(2,1), get(2)→1, remove(2), get(2)→-1

Example 2 — Key Updates

$ Input: operations = ["MyHashMap","put","get","put","get"], values = [[],[5,10],[5],[5,20],[5]]

› Output: [null,null,10,null,20]

💡 Note: put(5,10) stores key 5 with value 10, get(5) returns 10, put(5,20) updates key 5 to value 20, get(5) returns 20

Example 3 — Non-existent Keys

$ Input: operations = ["MyHashMap","get","remove","get"], values = [[],[1],[2],[1]]

› Output: [null,-1,null,-1]

💡 Note: Empty hashmap: get(1) returns -1 (not found), remove(2) does nothing, get(1) still returns -1

Constraints

0 ≤ key, value ≤ 10⁶
At most 10⁴ calls will be made to put, get, and remove.

Visualization

Tap to expand

Asked in

a Amazon 45 G Google 38 M Microsoft 32 f Facebook 28

Design a HashMap from scratch using either array with linear search (simple but O(n)) or hash table with chaining (optimal O(1) average). The key insight is using a hash function to map keys to bucket indices for direct access. Best approach: Hash table with chaining. Time: O(1) average, Space: O(n)

Common Approaches

✓ Array of Key-Value Pairs

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

Use a dynamic array to store key-value pairs. For get/put/remove operations, scan through the entire array to find the matching key. Simple but inefficient for large datasets.

Hash Table with Chaining

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

Create an array of buckets where each bucket is a linked list. Use hash function (key % bucket_size) to determine which bucket to use. Handle collisions by chaining entries in the same bucket using linked lists.

Array of Key-Value Pairs — Algorithm Steps

Store key-value pairs in array
For each operation, scan array linearly
Update, add, or remove as needed

Visualization

Tap to expand

Step-by-Step Walkthrough

Store Pairs

Keep key-value pairs in array

Linear Search

Scan through array to find matching key

Operation

Update, return, or remove the pair

Code -

solution.c — C

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

#define MAX_TASKS 1000
#define MAX_LINE 10000

typedef struct {
    int tasks[MAX_TASKS][3]; // [userId, taskId, priority]
    int size;
} TaskManager;

TaskManager* taskManagerCreate(int** tasks, int tasksSize) {
    TaskManager* tm = (TaskManager*)malloc(sizeof(TaskManager));
    tm->size = tasksSize;
    for (int i = 0; i < tasksSize; i++) {
        tm->tasks[i][0] = tasks[i][0];
        tm->tasks[i][1] = tasks[i][1];
        tm->tasks[i][2] = tasks[i][2];
    }
    return tm;
}

void taskManagerAdd(TaskManager* tm, int userId, int taskId, int priority) {
    tm->tasks[tm->size][0] = userId;
    tm->tasks[tm->size][1] = taskId;
    tm->tasks[tm->size][2] = priority;
    tm->size++;
}

void taskManagerEdit(TaskManager* tm, int taskId, int newPriority) {
    for (int i = 0; i < tm->size; i++) {
        if (tm->tasks[i][1] == taskId) {
            tm->tasks[i][2] = newPriority;
            break;
        }
    }
}

void taskManagerRmv(TaskManager* tm, int taskId) {
    for (int i = 0; i < tm->size; i++) {
        if (tm->tasks[i][1] == taskId) {
            for (int j = i; j < tm->size - 1; j++) {
                tm->tasks[j][0] = tm->tasks[j + 1][0];
                tm->tasks[j][1] = tm->tasks[j + 1][1];
                tm->tasks[j][2] = tm->tasks[j + 1][2];
            }
            tm->size--;
            break;
        }
    }
}

int taskManagerExecTop(TaskManager* tm) {
    if (tm->size == 0) return -1;
    
    int maxPriority = -1;
    int maxTaskId = -1;
    int maxIndex = -1;
    
    for (int i = 0; i < tm->size; i++) {
        int userId = tm->tasks[i][0], taskId = tm->tasks[i][1], priority = tm->tasks[i][2];
        if (priority > maxPriority || (priority == maxPriority && taskId > maxTaskId)) {
            maxPriority = priority;
            maxTaskId = taskId;
            maxIndex = i;
        }
    }
    
    int resultUser = tm->tasks[maxIndex][0];
    taskManagerRmv(tm, tm->tasks[maxIndex][1]);
    return resultUser;
}

int parseOperation(char* input, char results[][20]) {
    int count = 0;
    TaskManager* tm = taskManagerCreate(NULL, 0);
    
    // Simple parsing - count operations
    char* ptr = input;
    while (*ptr && count < 10) {
        if (strstr(ptr, "TaskManager")) {
            strcpy(results[count], "null");
            count++;
        } else if (strstr(ptr, "add")) {
            taskManagerAdd(tm, 1, 101, 1);
            strcpy(results[count], "null");
            count++;
        } else if (strstr(ptr, "edit")) {
            taskManagerEdit(tm, 101, 5);
            strcpy(results[count], "null");
            count++;
        } else if (strstr(ptr, "rmv")) {
            taskManagerRmv(tm, 101);
            strcpy(results[count], "null");
            count++;
        } else if (strstr(ptr, "execTop")) {
            int result = taskManagerExecTop(tm);
            if (result == -1) {
                strcpy(results[count], "-1");
            } else {
                sprintf(results[count], "%d", result);
            }
            count++;
        }
        ptr++;
    }
    
    return count;
}

int main() {
    char input[MAX_LINE];
    char results[10][20];
    
    if (fgets(input, MAX_LINE, stdin)) {
        int count = parseOperation(input, results);
        
        printf("[");
        for (int i = 0; i < count; i++) {
            if (i > 0) printf(",");
            printf("%s", results[i]);
        }
        printf("]\n");
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each operation requires scanning through up to n key-value pairs

✓ Linear Growth

Space Complexity

O(n)

Array stores n key-value pairs

⚡ Linearithmic Space

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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Array of Key-Value Pairs — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler