Codestin Search App

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

Constraints

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

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!

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

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

Constraints

Visualization

Related Problems

Common Approaches

Hash Table with Chaining (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler