Custom Hash Map - Problem

Design a hash map from scratch that supports the following operations:

put(key, value): Insert a key-value pair into the hash map. If the key already exists, update its value.
get(key): Return the value associated with the key, or -1 if the key doesn't exist.
remove(key): Remove the key-value pair from the hash map if it exists.

Your implementation should handle collisions using chaining (linked lists). The hash map should automatically resize when the load factor exceeds 0.75.

Implement the CustomHashMap class with the above methods. For this problem, you'll be given a sequence of operations to perform and should return the results of all get operations.

Input & Output

Example 1 — Basic Operations

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

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

💡 Note: 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 — Hash Collisions

$ Input: operations = [["put",17,70],["put",33,80],["get",17],["get",33]]

› Output: [70,80]

💡 Note: Keys 17 and 33 hash to same bucket (17%16=1, 33%16=1), handled by chaining

Example 3 — Update Existing Key

$ Input: operations = [["put",1,10],["put",1,20],["get",1]]

› Output: [20]

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

Constraints

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

Visualization

Tap to expand

Asked in

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

The key insight is using a hash function to distribute keys across buckets, with chaining to handle collisions and automatic resizing to maintain performance. Best approach uses resizing hash table with load factor management. Time: O(1) average, Space: O(n)

Common Approaches

✓ Basic Hash Table with Chaining

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

Create an array of buckets where each bucket is a linked list. Use a hash function to determine which bucket each key belongs to, and handle collisions by chaining in the linked list.

Linear Search Array

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

Use a simple array to store key-value pairs. For each operation, search through the entire array linearly to find the key.

Resizing Hash Table with Load Factor Management

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

Enhanced hash table that monitors load factor (size/capacity) and doubles the table size when it exceeds 0.75, redistributing all keys to maintain efficient performance.

Basic Hash Table with Chaining — Algorithm Steps

Initialize array of empty buckets (linked lists)
Hash key to determine bucket index: hash(key) % bucket_count
Search/insert/delete in the linked list at that bucket
Handle collisions by adding to the chain in the same bucket

Visualization

Tap to expand

Step-by-Step Walkthrough

Hash Function

hash(key) % bucket_count determines bucket

Chain Search

Search linked list in target bucket

Result

Return value if found, -1 if not found

Code -

solution.c — C

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

typedef struct ListNode {
    int key;
    int val;
    struct ListNode* next;
} ListNode;

typedef struct {
    ListNode* buckets[16];
    int size;
    int capacity;
} CustomHashMap;

CustomHashMap* createHashMap() {
    CustomHashMap* map = (CustomHashMap*)malloc(sizeof(CustomHashMap));
    memset(map->buckets, 0, sizeof(map->buckets));
    map->size = 0;
    map->capacity = 16;
    return map;
}

int hash(CustomHashMap* map, int key) {
    return key % map->capacity;
}

void put(CustomHashMap* map, int key, int value) {
    int index = hash(map, key);
    if (!map->buckets[index]) {
        ListNode* node = (ListNode*)malloc(sizeof(ListNode));
        node->key = key;
        node->val = value;
        node->next = NULL;
        map->buckets[index] = node;
        map->size++;
    } else {
        ListNode* curr = map->buckets[index];
        while (curr) {
            if (curr->key == key) {
                curr->val = value;
                return;
            }
            if (!curr->next) break;
            curr = curr->next;
        }
        ListNode* node = (ListNode*)malloc(sizeof(ListNode));
        node->key = key;
        node->val = value;
        node->next = NULL;
        curr->next = node;
        map->size++;
    }
}

int get(CustomHashMap* map, int key) {
    int index = hash(map, key);
    ListNode* curr = map->buckets[index];
    while (curr) {
        if (curr->key == key) return curr->val;
        curr = curr->next;
    }
    return -1;
}

void removeKey(CustomHashMap* map, int key) {
    int index = hash(map, key);
    ListNode* curr = map->buckets[index];
    
    if (!curr) return;
    
    if (curr->key == key) {
        map->buckets[index] = curr->next;
        free(curr);
        map->size--;
        return;
    }
    
    while (curr->next) {
        if (curr->next->key == key) {
            ListNode* toDelete = curr->next;
            curr->next = curr->next->next;
            free(toDelete);
            map->size--;
            return;
        }
        curr = curr->next;
    }
}

int main() {
    CustomHashMap* map = createHashMap();
    
    put(map, 1, 1);
    put(map, 2, 2);
    printf("[%d,%d]\n", get(map, 1), get(map, 3));
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Hash function gives direct bucket access, search within bucket chain is typically short

✓ Linear Growth

Space Complexity

O(n)

Array of buckets plus linked list nodes to store n key-value pairs

⚡ Linearithmic Space

78.0K Views

High Frequency

~35 min Avg. Time

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

Custom Hash Map - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Basic Hash Table with Chaining — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler