Design HashMap - Practice Coding Problems

Design HashMap - Problem

Design Your Own HashMap from Scratch!

Your mission is to build a fully functional HashMap data structure without using any built-in hash table libraries. This is a fundamental challenge that tests your understanding of how hash tables work under the hood.

You need to implement the MyHashMap class with these operations:

MyHashMap() - Initialize an empty hash map
put(int key, int value) - Insert or update a key-value pair
get(int key) - Return the value for a key, or -1 if not found
remove(int key) - Delete a key and its value if it exists

Example Usage:

MyHashMap hashMap = new MyHashMap();
hashMap.put(1, 1);          // Map is now [[1,1]]
hashMap.put(2, 2);          // Map is now [[1,1], [2,2]]
hashMap.get(1);             // Returns 1
hashMap.get(3);             // Returns -1 (not found)
hashMap.put(2, 1);          // Map is now [[1,1], [2,1]] (updated)
hashMap.get(2);             // Returns 1
hashMap.remove(2);          // Map is now [[1,1]]
hashMap.get(2);             // Returns -1 (removed)

Input & Output

basic_operations.py — Python

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

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

💡 Note: Initialize empty hashmap, insert (1,1) and (2,2), get key 1 returns 1, get key 3 returns -1 (not found), update key 2 to value 1, get key 2 returns 1, remove key 2, get key 2 returns -1 (removed)

collision_handling.py — Python

$ Input: ["MyHashMap", "put", "put", "put", "get", "get", "get"] [[], [1, 10], [1001, 20], [2001, 30], [1], [1001], [2001]]

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

💡 Note: Keys 1, 1001, 2001 all hash to same bucket (assuming bucket size 1000), but chaining handles collisions correctly

edge_cases.py — Python

$ Input: ["MyHashMap", "remove", "get", "put", "put", "put", "get", "remove", "get", "remove", "get"] [[], [1], [1], [0, 0], [1, 1], [0, 5], [0], [0], [0], [1], [1]]

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

💡 Note: Remove from empty map, get from empty map, insert with key 0, update key 0, remove and get operations on existing keys

Visualization

Tap to expand

Understanding the Visualization

Hash Function Magic

Transform any key into a bucket index using modulo: hash(key) = key % bucket_count

Direct Access

Use the hash value to jump directly to the correct bucket, no searching needed

Handle Collisions

When multiple keys map to same bucket, chain them together in a list

Maintain Performance

With good hash distribution, each bucket stays small, keeping operations fast

Key Takeaway

🎯 Key Insight: The hash function acts like a perfect librarian - it instantly knows exactly where to look for any book (key), transforming an O(n) search into O(1) direct access!

Time & Space Complexity

Time Complexity

⏱️

O(1)

Hash function gives direct bucket access. With good distribution, each bucket has few items on average

✓ Linear Growth

Space Complexity

O(n)

Space for n key-value pairs plus fixed bucket array overhead

⚡ Linearithmic Space

Constraints

0 ≤ key, value ≤ 10⁶
At most 10⁴ calls will be made to put, get, and remove
Keys and values are non-negative integers

Asked in

G Google 42 a Amazon 38 ⊞ Microsoft 31 f Meta 26

The optimal solution uses a hash table with chaining to achieve O(1) average time complexity. Create an array of buckets, use a hash function (key % bucket_count) to map keys to specific buckets, and handle collisions by storing multiple key-value pairs in each bucket as a list. This approach provides fast access while gracefully handling hash collisions.

Common Approaches

Approach	Time	Space	Notes
✓ Hash Table with Chaining (Optimal)	O(1)	O(n)	Use hash function to map keys to buckets, handle collisions with chaining
Array-Based Linear Search	O(n)	O(n)	Store all key-value pairs in a simple array and search linearly

Hash Table with Chaining (Optimal) — Algorithm Steps

Create an array of buckets (each bucket is a list of key-value pairs)
Use hash function: hash(key) = key % bucket_count to find bucket index
For get(): hash the key, search only in that bucket's list
For put(): hash the key, update if exists in bucket, otherwise append to bucket
For remove(): hash the key, find and remove from that specific bucket

Visualization

Tap to expand

Step-by-Step Walkthrough

Hash the key

Calculate key % bucket_count to get bucket index

Access bucket

Go directly to the calculated bucket

Search in bucket

Search only within that bucket's chain

Code -

solution.c — C

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

#define SIZE 1000

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

typedef struct {
    Node* buckets[SIZE];
} MyHashMap;

int hash(int key) {
    return key % SIZE;
}

MyHashMap* myHashMapCreate() {
    MyHashMap* obj = (MyHashMap*)malloc(sizeof(MyHashMap));
    for (int i = 0; i < SIZE; i++) {
        obj->buckets[i] = NULL;
    }
    return obj;
}

void myHashMapPut(MyHashMap* obj, int key, int value) {
    int bucketIdx = hash(key);
    Node* head = obj->buckets[bucketIdx];
    
    // Search for existing key in this bucket
    Node* curr = head;
    while (curr) {
        if (curr->key == key) {
            curr->value = value;  // Update existing
            return;
        }
        curr = curr->next;
    }
    
    // Key not found, add new node to front of bucket
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->key = key;
    newNode->value = value;
    newNode->next = head;
    obj->buckets[bucketIdx] = newNode;
}

int myHashMapGet(MyHashMap* obj, int key) {
    int bucketIdx = hash(key);
    Node* curr = obj->buckets[bucketIdx];
    
    // Search in the specific bucket
    while (curr) {
        if (curr->key == key) {
            return curr->value;
        }
        curr = curr->next;
    }
    return -1;  // Not found
}

void myHashMapRemove(MyHashMap* obj, int key) {
    int bucketIdx = hash(key);
    Node* head = obj->buckets[bucketIdx];
    
    if (!head) return;
    
    // If head node has the key
    if (head->key == key) {
        obj->buckets[bucketIdx] = head->next;
        free(head);
        return;
    }
    
    // Search in the rest of the bucket
    Node* curr = head;
    while (curr->next) {
        if (curr->next->key == key) {
            Node* toDelete = curr->next;
            curr->next = toDelete->next;
            free(toDelete);
            return;
        }
        curr = curr->next;
    }
}

void myHashMapFree(MyHashMap* obj) {
    for (int i = 0; i < SIZE; i++) {
        Node* curr = obj->buckets[i];
        while (curr) {
            Node* next = curr->next;
            free(curr);
            curr = next;
        }
    }
    free(obj);
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Hash function gives direct bucket access. With good distribution, each bucket has few items on average

✓ Linear Growth

Space Complexity

O(n)

Space for n key-value pairs plus fixed bucket array overhead

⚡ Linearithmic Space

Constraints

0 ≤ key, value ≤ 10⁶
At most 10⁴ calls will be made to put, get, and remove
Keys and values are non-negative integers

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Hash Table with Chaining (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler