DEV Community: Dushyant Singh Rao

Comparing `std::set` and `std::unordered_set` in C++

Dushyant Singh Rao — Thu, 03 Jul 2025 06:22:40 +0000

import Image from 'next/image'

🚀 Introduction

C++ gives you two powerful tools to store unique values: std::set and std::unordered_set. Both avoid duplicates, but the way they work under the hood—and how fast they are—differs quite a bit.

This post breaks down the differences in a way that’s easy to understand. Whether you’re coding for performance or clarity, you’ll know exactly which one to choose by the end.

🏗️ Under the Hood: How They Work

🔧 `std::set`

Internally built on a Red-Black Tree, which is a kind of balanced binary search tree.
Automatically keeps elements sorted in ascending order.
All basic operations—insert, find, erase—run in O(log n) time.

Imagine a bookshelf where books are always arranged in alphabetical order. That’s how std::set behaves.

⚡ `std::unordered_set`

Uses a hash table under the hood.
Doesn't guarantee any specific order of elements.
Offers average-case O(1) time for inserts, lookups, and deletions.

Think of it like tossing items into labeled bins. You can grab them quickly, but they're not arranged in any particular order.

👍 Pros & 👎 Cons

Feature	`std::set` (Red-Black Tree)	`std::unordered_set` (Hash Table)
Time Complexity	O(log n) — consistent and predictable	O(1) average, O(n) worst-case (collisions)
Element Order	Maintains ascending order	No order guaranteed
Memory Usage	More efficient in memory	Slightly heavier due to hash buckets
Supports Range Ops?	Yes — lower/upper bounds, etc.	No
Security	Safe from DoS via hash attacks	Vulnerable if custom hash is poor
Custom Key Support	Works if `<` is defined	Needs `std::hash` + `==`

🧪 Performance in Real Life

For small datasets, std::set can actually be faster because it avoids hash setup overhead.
For large datasets, std::unordered_set shines with blazing fast average-time operations.
If you're working in real-time systems, std::set is more reliable thanks to its consistent performance.

Example Benchmark:

🧩 Quick Code Comparison

`std::set` Example

#include <set>
std::set<int> s;
s.insert(5);
s.insert(1);
s.insert(3);
// Automatically sorted: 1, 3, 5

`std::unordered_set` Example

#include <unordered_set>
std::unordered_set<int> us;
us.insert(5);
us.insert(1);
us.insert(3);
// No guaranteed order: could be 5, 1, 3

When Should You Use Each?

Use `std::set` when:

You care about the elements being sorted
You need functions like lower_bound() or upper_bound()
You’re in a real-time or security-sensitive environment

Use `std::unordered_set` when:

You want maximum performance
You’re storing lots of data and don’t care about order
You’ve defined good hash functions (or are using built-in types)

Summary

std::set is perfect when you need order, reliability, and predictability. It's slower than its counterpart, but consistent.

std::unordered_set is the go-to for raw speed and high-performance applications—just make sure you understand its hash-based limitations.

Need more STL breakdowns like this? Let me know which container you'd like explained next!

HTTP for beginner

Dushyant Singh Rao — Fri, 11 Apr 2025 19:11:56 +0000

http are just a set of protocols

state less protocol :
every time you visit a page, you are a new user.

session : stored state between frontend and backend
cookie : Is just a information

I need to send data to browser form server
http Header: client
Browser Info
date time
cookie to store

request response architecture:
browser ---------------> server
(GET,POST)--> <--(200,404)

response code [ 200, 404 ]
->what action to perform (GET,POST,DELETE)
->where to perform "http://example.com/auth
->was it done

HTTP/2:
http means http2
http/1.1 is a fallback(substitute) & is still used
uses compressions
uses multiplexing (many files at same time)
uses encryption (https)

In AWS, we don't use http for internal communication

TCP protocols

Dushyant Singh Rao — Thu, 10 Apr 2025 11:04:43 +0000

TCP (Transmission Control Protocol) is a connection-oriented, reliable protocol used to establish a communication channel between two devices, ensuring data is transmitted accurately and in the correct order. It's a crucial part of the TCP/IP protocol suite, working alongside IP (Internet Protocol) to facilitate data transfer over networks.

How TCP Works:

Connection Establishment: The sender and receiver establish a connection using the three-way handshake.

Data Segmentation: The sender breaks the data into segments, adds TCP headers, and sends them across the network.

Data Transmission: IP handles the routing of these segments across the network.

Reassembly: The receiver reassembles the segments into the original data stream.

Acknowledgement: TCP uses acknowledgements (ACKs) to confirm that segments have been received correctly, and retransmits lost or corrupted segments.

Connection Termination: Once the data transmission is complete, the connection is terminated using a four-way handshake

React Fundamentals

Dushyant Singh Rao — Wed, 09 Apr 2025 14:23:13 +0000

React Basics You Should Know

Let's begin with understanding how to create elements in React using the React.createElement method.

As we can see in the example below, the element nested is essentially a virtual representation of a nested HTML structure. In this case, a

contains an

element as its child.

In React, we create such elements using:

React.createElement('type of tag', { attributes like 'id', 'className' }, children);

Now, what do you think will happen if we console.log(heading)?

You might guess that it will print an actual HTML element—but in reality, it logs a JavaScript object that represents that element. This object is what React uses to manage and render the UI efficiently.

All of this abstraction is handled behind the scenes by React.

Here’s an example (App.js):

const nested = 
  React.createElement(
    'div', 
    { id: 'parent' }, 
    React.createElement('h1', { id: 'child' }, 'This is child')
  );

const root = ReactDOM.createRoot(document.getElementById('root'));
root.render(nested);

JSX Introduction

While **React.createElement **is useful to understand what happens behind the scenes, writing complex UIs using it can quickly become verbose and hard to read. This is where JSX comes in.

JSX (JavaScript XML) is a syntax extension for JavaScript that looks similar to HTML. It allows you to write UI elements in a more intuitive and readable way.

Here’s the same example using JSX:

const nested = (
  <div id="parent">
    <h1 id="child">This is child</h1>
  </div>
);

Under the hood, this JSX code is compiled to the same **React.createElement **call you saw earlier:

React.createElement(
  'div', 
  { id: 'parent' }, 
  React.createElement('h1', { id: 'child' }, 'This is child')
);

Using JSX makes your code cleaner, especially when you start building components with multiple nested elements.

connected components

Dushyant Singh Rao — Sat, 05 Apr 2025 09:46:08 +0000

connected components

What Are Connected Components?
In graph theory, a connected component is a group of nodes where there is a path between any two nodes in the group, and no path exists from nodes in one component to any node in another component.

If you imagine a social network, a connected component is like a group of people who all know each other, directly or indirectly — but no one in that group knows anyone in a different group.

In simple language they are groups of connected nodes

Example: Number of Islands (LeetCode 200)

Input:
[
['1','1','0','0','0'],
['1','1','0','0','0'],
['0','0','1','0','0'],
['0','0','0','1','1']
]

'1' represents land
'0' represents water

They are all in same grid but different chunks of ones can be referred as nodes and collectively in this example as island

You treat this grid as a graph, where each land cell ('1') is a node, and it’s connected to adjacent land cells (up, down, left, right).

Your task: Count how many such connected land groups exist.

class Solution {
public:
    void bfs(vector<vector<char>>& grid, vector<vector<int>>& visited, int i, int j) {
        int n = grid.size();{% embed  %}
        int m = grid[0].size();
        queue<pair<int, int>> q;
        visited[i][j] = 1;
        q.push({i, j});

        int dx[] = {1, -1, 0, 0};
        int dy[] = {0, 0, 1, -1};

        while (!q.empty()) {
            int x = q.front().first;
            int y = q.front().second;
            q.pop();

            for (int d = 0; d < 4; ++d) {
                int nx = x + dx[d];
                int ny = y + dy[d];

                if (nx >= 0 && nx < n && ny >= 0 && ny < m &&
                    grid[nx][ny] == '1' && !visited[nx][ny]) {
                    visited[nx][ny] = 1;
                    q.push({nx, ny});
                }
            }
        }
    }

    int numIslands(vector<vector<char>>& grid) {
        int n = grid.size();
        int m = grid[0].size();
        vector<vector<int>> visited(n, vector<int>(m, 0));
        int count = 0;

        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < m; ++j) {
                if (grid[i][j] == '1' && !visited[i][j]) {
                    bfs(grid, visited, i, j);
                    count++;
                }
            }
        }
        return count;
    }
};

in hindi

Isme extra space use ki gayi hai but bina visited ke bhi ho sakta hai magar esa mana jata hai agar apko koi data diya jata hai to use na chade
data may lost to uski copy ban le parantu app usme grid[j][j] = '0' karke bhi visited ka track rakh sakte hai yadi apko extra space acchi nahi lagi to

DEV Community: Dushyant Singh Rao

Comparing `std::set` and `std::unordered_set` in C++

🚀 Introduction

🏗️ Under the Hood: How They Work

🔧 std::set

⚡ std::unordered_set

👍 Pros & 👎 Cons

🧪 Performance in Real Life

Example Benchmark:

🧩 Quick Code Comparison

std::set Example

std::unordered_set Example

When Should You Use Each?

Use std::set when:

Use std::unordered_set when:

Summary

HTTP for beginner

TCP protocols

How TCP Works:

React Fundamentals

React Basics You Should Know

element as its child.

JSX Introduction

connected components

connected components

🔧 `std::set`

⚡ `std::unordered_set`

`std::set` Example

`std::unordered_set` Example

Use `std::set` when:

Use `std::unordered_set` when: