Design HashSet - Practice Coding Problems

Design HashSet - Problem

Design a HashSet without using built-in hash table libraries.

Your mission is to implement a MyHashSet class from scratch that provides the core functionality of a hash set data structure. A HashSet is a collection that stores unique elements and provides fast insertion, deletion, and lookup operations.

Implement the following methods:
• add(key) - Inserts the value key into the HashSet
• contains(key) - Returns true if the value key exists in the HashSet, false otherwise
• remove(key) - Removes the value key from the HashSet (no-op if key doesn't exist)

This problem tests your understanding of hash functions, collision handling, and fundamental data structure design principles.

Input & Output

example_1.py — Basic Operations

$ Input: ["MyHashSet", "add", "add", "contains", "contains", "add", "contains", "remove", "contains"] [[], [1], [2], [1], [3], [2], [2], [2], [2]]

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

💡 Note: MyHashSet is initialized, add(1), add(2), contains(1) returns true, contains(3) returns false, add(2) does nothing since 2 already exists, contains(2) returns true, remove(2), contains(2) returns false

example_2.py — Duplicate Handling

$ Input: ["MyHashSet", "add", "add", "add", "contains"] [[], [5], [5], [5], [5]]

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

💡 Note: Adding the same element multiple times should only store it once. The set should still contain the element after multiple add operations.

example_3.py — Remove Non-existent

$ Input: ["MyHashSet", "remove", "add", "remove", "remove", "contains"] [[], [1], [1], [1], [1], [1]]

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

💡 Note: Removing a non-existent element should do nothing. After removing an element that was added, contains should return false.

Visualization

Tap to expand

Understanding the Visualization

Design Hash Function

Create a function that maps book IDs to specific sections (buckets) evenly

Handle Collisions

When multiple books map to the same section, store them as a list within that section

Optimize Access

Each operation now only searches within the relevant section, not the entire library

Key Takeaway

🎯 Key Insight: Hash functions transform O(n) searches into O(1) operations by intelligently distributing data across multiple buckets, like organizing a library into sections for instant book location.

Time & Space Complexity

Time Complexity

⏱️

O(1)

Average case O(1) due to hash function distributing elements evenly across buckets. Worst case O(n) if all elements hash to same bucket

✓ Linear Growth

Space Complexity

O(n + k)

O(n) for storing n elements plus O(k) for k buckets array

⚡ Linearithmic Space

Constraints

0 ≤ key ≤ 10⁶
At most 10⁴ calls will be made to add, remove, and contains

Asked in

G Google 43 a Amazon 38 f Meta 29 ⊞ Microsoft 25 Apple 18

The optimal solution uses a hash table with separate chaining to achieve O(1) average-case time complexity. By using a hash function to distribute elements across buckets and handling collisions with linked lists, we can efficiently implement all three operations. The key insight is that hash functions transform the search problem from O(n) linear scan to O(1) direct access.

Common Approaches

Approach	Time	Space	Notes
✓ Hash Table with Chaining (Optimal)	O(1)	O(n + k)	Use hash function to distribute elements across buckets with collision handling
Brute Force (Linear Search Array)	O(n)	O(n)	Store all elements in a simple array and search linearly

Hash Table with Chaining (Optimal) — Algorithm Steps

Create an array of buckets (each bucket is a list)
Design a hash function: hash(key) = key % bucket_count
For add(): Hash the key, go to corresponding bucket, add if not exists
For contains(): Hash the key, search only in the corresponding bucket
For remove(): Hash the key, remove from the corresponding bucket

Visualization

Tap to expand

Step-by-Step Walkthrough

Hash Function

Calculate hash(key) = key % bucket_count to find target bucket

Bucket Access

Go directly to the calculated bucket index

Collision Handling

Multiple elements in same bucket are stored as a list

Code -

solution.c — C

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

#define SIZE 1000
#define MAX_BUCKET_SIZE 100

typedef struct {
    int data[MAX_BUCKET_SIZE];
    int count;
} Bucket;

typedef struct {
    Bucket buckets[SIZE];
} MyHashSet;

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

MyHashSet* myHashSetCreate() {
    MyHashSet* obj = (MyHashSet*)malloc(sizeof(MyHashSet));
    for (int i = 0; i < SIZE; i++) {
        obj->buckets[i].count = 0;
    }
    return obj;
}

bool containsInBucket(Bucket* bucket, int key) {
    for (int i = 0; i < bucket->count; i++) {
        if (bucket->data[i] == key) {
            return true;
        }
    }
    return false;
}

void myHashSetAdd(MyHashSet* obj, int key) {
    int bucketIndex = hash(key);
    Bucket* bucket = &obj->buckets[bucketIndex];
    if (!containsInBucket(bucket, key) && bucket->count < MAX_BUCKET_SIZE) {
        bucket->data[bucket->count++] = key;
    }
}

void myHashSetRemove(MyHashSet* obj, int key) {
    int bucketIndex = hash(key);
    Bucket* bucket = &obj->buckets[bucketIndex];
    for (int i = 0; i < bucket->count; i++) {
        if (bucket->data[i] == key) {
            for (int j = i; j < bucket->count - 1; j++) {
                bucket->data[j] = bucket->data[j + 1];
            }
            bucket->count--;
            break;
        }
    }
}

bool myHashSetContains(MyHashSet* obj, int key) {
    int bucketIndex = hash(key);
    return containsInBucket(&obj->buckets[bucketIndex], key);
}

int main() {
    MyHashSet* hashSet = myHashSetCreate();
    myHashSetAdd(hashSet, 1);
    printf("%d\n", myHashSetContains(hashSet, 1));  // 1
    myHashSetAdd(hashSet, 2);
    printf("%d\n", myHashSetContains(hashSet, 2));  // 1
    myHashSetRemove(hashSet, 1);
    printf("%d\n", myHashSetContains(hashSet, 1));  // 0
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Average case O(1) due to hash function distributing elements evenly across buckets. Worst case O(n) if all elements hash to same bucket

✓ Linear Growth

Space Complexity

O(n + k)

O(n) for storing n elements plus O(k) for k buckets array

⚡ Linearithmic Space

Constraints

0 ≤ key ≤ 10⁶
At most 10⁴ calls will be made to add, remove, and contains

89.5K Views

High Frequency

~15 min Avg. Time

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