Hash Sets

Say you have a long list of email addresses. You want to know if one email is already in it. With a plain list you have to walk through every item and compare them one by one. That gets slow when the list grows. A hash set fixes this. A hash set is a collection that stores only unique values. It lets you check “is this value here?” almost instantly.

🎯 What Is a Hash Set?

A hash set is a container that holds a group of values. Every value appears only once. You cannot have two copies of the same value inside it.

The “hash” part means it uses a hashing trick inside. It runs your value through a small function. That function turns the value into a number. The number points to the slot where the value lives. So when you ask “is this value here?”, the set jumps straight to the right slot. It does not check everything.

That is why the main jobs of a set are fast on average:

• add a value
• contains check if a value is present
• remove a value

All three take O(1) time on average. O(1) means the time stays the same no matter how big the set gets.

🤔 Hash Set vs Hash Map

People mix these up, so let us clear it now. Both use the same hashing idea inside. The difference is what they store.

• A hash map stores key and value pairs. Like a name to a phone number. You look up a key and get back its value.
• A hash set stores keys only. There is no value attached. You only ask one thing. Is this key in here or not?

So a set is like a map where you threw away the values and kept only the keys.

🛠️ Where We Use a Hash Set

A hash set shines in a few everyday jobs. Here is when you reach for one:

• Remove duplicates. You have a list with repeated items. Drop them all into a set and the repeats vanish on their own. A set refuses copies, so this just works.
• Fast membership check. You need to ask “have I seen this before?” again and again. A set answers each time in O(1). A plain list would have to scan everything.

You will see both of these in interview problems all the time. Things like “find the first repeated number” or “does this array have any duplicates” become easy with a set.

📝 Steps to Use a Hash Set

Every language gives you a built-in set. So you do not build one from scratch. The pattern is the same everywhere.

1. Create an empty set.
2. Add values into it with an add or insert call. Adding a value that is already there does nothing, so no duplicates form.
3. Ask if a value is present with a contains or membership check. You get back true or false.
4. Remove a value when you no longer need it.
5. To remove duplicates from a list, put every list item into a set, then read the set back out.

Now let us see this work in real code.

💻 Hash Set in Code

The demo below does the same thing in every language. It adds a few fruit names. It checks membership. Then it takes a list with repeats and squeezes it down to unique values using a set.

#include <stdio.h>

// Returns 1 if value is already in the set array, else 0.
int contains(int set[], int size, int value) {
    for (int i = 0; i < size; i++) {
        if (set[i] == value) return 1;
    }
    return 0;
}

// Adds value only if it is not already present. Returns new size.
int add(int set[], int size, int value) {
    if (!contains(set, size, value)) {
        set[size] = value;
        size++;
    }
    return size;
}

int main(void) {
    int set[100];
    int size = 0;

    // Remove duplicates from a list using the set.
    int list[] = {3, 5, 3, 7, 5, 9, 7};
    int n = 7;
    for (int i = 0; i < n; i++) {
        size = add(set, size, list[i]);
    }

    printf("Is 5 present? %s\n", contains(set, size, 5) ? "yes" : "no");
    printf("Is 8 present? %s\n", contains(set, size, 8) ? "yes" : "no");

    printf("Unique values: ");
    for (int i = 0; i < size; i++) {
        printf("%d ", set[i]);
    }
    printf("\n");
    return 0;
}

Is 5 present? yes
Is 8 present? no
Unique values: 3 5 7 9

#include <iostream>
#include <unordered_set>
#include <vector>
using namespace std;

int main() {
    unordered_set<string> fruits;

    // Add values. Inserting a duplicate does nothing.
    fruits.insert("apple");
    fruits.insert("banana");
    fruits.insert("apple"); // ignored, already there

    // Membership check with count: returns 1 if present, else 0.
    cout << "Has apple? " << (fruits.count("apple") ? "yes" : "no") << endl;
    cout << "Has mango? " << (fruits.count("mango") ? "yes" : "no") << endl;

    // Remove duplicates from a list by dropping it into a set.
    vector<int> list = {3, 5, 3, 7, 5, 9, 7};
    unordered_set<int> unique(list.begin(), list.end());
    cout << "Unique count: " << unique.size() << endl;

    return 0;
}

Has apple? yes
Has mango? no
Unique count: 4

import java.util.HashSet;
import java.util.Arrays;
import java.util.List;

public class HashSetDemo {
    public static void main(String[] args) {
        HashSet<String> fruits = new HashSet<>();

        // Add values. The duplicate apple is ignored.
        fruits.add("apple");
        fruits.add("banana");
        fruits.add("apple");

        // Membership check returns true or false.
        System.out.println("Has apple? " + fruits.contains("apple"));
        System.out.println("Has mango? " + fruits.contains("mango"));

        // Remove duplicates from a list using a set.
        List<Integer> list = Arrays.asList(3, 5, 3, 7, 5, 9, 7);
        HashSet<Integer> unique = new HashSet<>(list);
        System.out.println("Unique count: " + unique.size());
    }
}

Has apple? true
Has mango? false
Unique count: 4

def main():
    fruits = set()

    # Add values. Adding apple twice keeps just one.
    fruits.add("apple")
    fruits.add("banana")
    fruits.add("apple")

    # Membership check with the in keyword.
    print("Has apple?", "apple" in fruits)
    print("Has mango?", "mango" in fruits)

    # Remove duplicates from a list by wrapping it in a set.
    numbers = [3, 5, 3, 7, 5, 9, 7]
    unique = set(numbers)
    print("Unique count:", len(unique))

main()

Has apple? True
Has mango? False
Unique count: 4

function main() {
  const fruits = new Set();

  // Add values. The second apple is ignored.
  fruits.add("apple");
  fruits.add("banana");
  fruits.add("apple");

  // Membership check with has returns true or false.
  console.log("Has apple?", fruits.has("apple"));
  console.log("Has mango?", fruits.has("mango"));

  // Remove duplicates from a list by passing it into a Set.
  const list = [3, 5, 3, 7, 5, 9, 7];
  const unique = new Set(list);
  console.log("Unique count:", unique.size);
}

main();

Has apple? true
Has mango? false
Unique count: 4

⏱️ Time Complexity

The built-in sets in C++, Java, Python, and JavaScript all use real hashing inside. So the main jobs are fast on average. They run in O(1) time. The C version above is the odd one out, since it scans an array each time.

⚠️ Common Mistakes

A few things trip people up with sets. Watch out for these:

• Expecting an order. A hash set does not keep your values in the order you added them. If you print it, the order can look random. When you need order, use a list or an ordered set type.
• Trusting a set to hold duplicates. It never will. If you actually need to count how many times each value appears, use a hash map, not a set.
• Removing a value that is not there. In some languages this throws an error. Python’s discard and JavaScript’s delete are safe, but be careful with methods that assume the value exists.
• Putting changeable items inside. In Python a set can only hold things that do not change, like numbers and strings. A list cannot go inside a set because it can change.

🧩 What You’ve Learned

• ✅ A hash set stores only unique values, with no duplicates allowed.
• ✅ Its three main jobs, add, contains, and remove, are O(1) on average thanks to hashing.
• ✅ A set stores keys only, while a hash map stores key and value pairs.
• ✅ Sets are perfect for removing duplicates and fast membership checks.
• ✅ Each language ships a built-in: C++ unordered_set, Java HashSet, Python set, JavaScript Set, while C makes you build your own.
• ✅ A set does not keep insertion order, so never rely on it.

🚀 What’s Next?

• Hash Maps and Dictionaries
• Introduction to Hashing