Design HashSet

Design HashSet - Problem

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

Implement MyHashSet class:

MyHashSet() Initializes the MyHashSet object.
void add(key) Inserts the value key into the HashSet.
bool contains(key) Returns whether the value key exists in the HashSet or not.
void remove(key) Removes the value key in the HashSet. If key does not exist in the HashSet, do nothing.

Your implementation should handle typical hash set operations efficiently.

Input & Output

Example 1 — Basic Operations

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

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

💡 Note: Initialize empty set, add 1 and 2, check if 1 exists (true), check if 3 exists (false), add 2 again (no change), check if 2 exists (true), remove 2, check if 2 exists (false)

Example 2 — Remove Non-existent

$ Input: operations = ["MyHashSet", "add", "remove", "contains"], values = [[], [5], [10], [5]]

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

💡 Note: Add 5 to set, try to remove 10 (doesn't exist, no change), check if 5 exists (true)

Example 3 — Duplicate Adds

$ Input: operations = ["MyHashSet", "add", "add", "contains"], values = [[], [7], [7], [7]]

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

💡 Note: Add 7, add 7 again (no change since sets don't allow duplicates), check if 7 exists (true)

Constraints

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

Visualization

Tap to expand

Asked in

G Google 35 f Facebook 28 a Amazon 25 M Microsoft 22

The key insight is using a hash function to distribute keys across buckets for efficient operations. The hash table with chaining approach provides O(1) average time complexity by using an array of buckets where each bucket handles collisions with a list. For limited key ranges, the boolean array approach gives true O(1) operations. Time: O(1) average, Space: O(n)

Common Approaches

✓ Bit Array Approach

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

For problems with limited key range (e.g., 0 to 10^6), use a boolean array where index represents the key and value represents presence. This gives true O(1) operations with minimal overhead.

Dynamic Array Approach

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

Use a simple array to store all keys. For add operations, append to the array if not present. For contains and remove, search through the entire array linearly.

Hash Table with Chaining

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

Create a fixed-size array of buckets where each bucket is a list. Use a hash function to map keys to bucket indices. Handle collisions using chaining (linked lists).

Bit Array Approach — Algorithm Steps

Create boolean array of size equal to max possible key
add(key): set array[key] = true
contains(key): return array[key]
remove(key): set array[key] = false

Visualization

Tap to expand

Step-by-Step Walkthrough

Direct Mapping

Key directly maps to array index

Set/Unset

Simply toggle boolean at that index

Instant Lookup

Return boolean value at index

Code -

solution.c — C

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

#define SIZE 1000001
#define MAX_LINE 10000
#define MAX_OPS 1000

typedef struct {
    bool data[SIZE];
} MyHashSet;

MyHashSet* myHashSetCreate() {
    MyHashSet* obj = (MyHashSet*)calloc(1, sizeof(MyHashSet));
    return obj;
}

void myHashSetAdd(MyHashSet* obj, int key) {
    if (key < SIZE) {
        obj->data[key] = true;
    }
}

void myHashSetRemove(MyHashSet* obj, int key) {
    if (key < SIZE) {
        obj->data[key] = false;
    }
}

bool myHashSetContains(MyHashSet* obj, int key) {
    if (key < SIZE) {
        return obj->data[key];
    }
    return false;
}

void myHashSetFree(MyHashSet* obj) {
    free(obj);
}

int parseOperations(char* line, char operations[][20]) {
    int count = 0;
    char* token = strtok(line, "[]\",");
    while (token != NULL && count < MAX_OPS) {
        if (strlen(token) > 0) {
            strcpy(operations[count], token);
            count++;
        }
        token = strtok(NULL, "[]\",");
    }
    return count;
}

int parseValues(char* line, int values[][10], int* valueCounts) {
    int arrayCount = 0;
    char* ptr = line;
    
    while (*ptr && arrayCount < MAX_OPS) {
        if (*ptr == '[') {
            ptr++;
            valueCounts[arrayCount] = 0;
            
            while (*ptr && *ptr != ']') {
                if (*ptr >= '0' && *ptr <= '9') {
                    int num = strtol(ptr, &ptr, 10);
                    values[arrayCount][valueCounts[arrayCount]] = num;
                    valueCounts[arrayCount]++;
                } else {
                    ptr++;
                }
            }
            arrayCount++;
        }
        ptr++;
    }
    return arrayCount;
}

int main() {
    char line1[MAX_LINE], line2[MAX_LINE];
    char operations[MAX_OPS][20];
    int values[MAX_OPS][10];
    int valueCounts[MAX_OPS];
    
    fgets(line1, MAX_LINE, stdin);
    fgets(line2, MAX_LINE, stdin);
    
    int opCount = parseOperations(line1, operations);
    int valCount = parseValues(line2, values, valueCounts);
    
    MyHashSet* hashset = myHashSetCreate();
    
    printf("[null");
    
    for (int i = 1; i < opCount; i++) {
        if (strcmp(operations[i], "add") == 0) {
            if (i < valCount && valueCounts[i] > 0) {
                myHashSetAdd(hashset, values[i][0]);
            }
            printf(",null");
        } else if (strcmp(operations[i], "remove") == 0) {
            if (i < valCount && valueCounts[i] > 0) {
                myHashSetRemove(hashset, values[i][0]);
            }
            printf(",null");
        } else if (strcmp(operations[i], "contains") == 0) {
            bool result = false;
            if (i < valCount && valueCounts[i] > 0) {
                result = myHashSetContains(hashset, values[i][0]);
            }
            printf(",%s", result ? "true" : "false");
        }
    }
    
    printf("]\n");
    
    myHashSetFree(hashset);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Direct array access for all operations

✓ Linear Growth

Space Complexity

O(k)

Boolean array of size k where k is the maximum possible key value

✓ Linear Space

125.0K Views

Medium Frequency

~25 min Avg. Time

1.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

Bit Array Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler