CPP concepts

unordered_map in C++

Rohit K — Wed, 03 Sep 2025 06:45:15 GMT

🔹 What is `unordered_map`?

A key → value container from C++ STL.
Similar to map, but does NOT store keys in sorted order.
Keys are stored in buckets using hashing.
Provides average O(1) lookup, insert, erase (faster than map).
Order of keys is unpredictable.

👉 Think of it as a hash table implementation of a dictionary.

🔹 Syntax

unordered_map mp;

Example:

unordered_map<string, int> age;
age["Alice"] = 20;
age["Bob"] = 25;

Storage (order is not guaranteed):

"Bob"   → 25
"Alice" → 20

🔹 Common Operations & Complexity

Operation	Code Example	Avg Time	Worst Time
Insert	`mp[key] = value;` or `mp.insert({key,value});`	O(1)	O(n)
Access (by key)	`mp[key]`	O(1)	O(n)
Search	`mp.find(key)`	O(1)	O(n)
Erase	`mp.erase(key)`	O(1)	O(n)
Size	`mp.size()`	O(1)	O(1)
Iterate	`for (auto &p: mp) ...`	O(n)	O(n)

⚠️ Worst-case O(n) happens if many keys land in the same bucket (hash collisions). But in practice, it’s rare.

🔹 Example

unordered_map<int, string> mp;
mp[30] = "X";
mp[10] = "Y";
mp[20] = "Z";

// Order is not guaranteed!
// Could print: 20→Z, 30→X, 10→Y

🔹 Checking Existence

if (mp.find(20) != mp.end()) {
    cout << "Key 20 found, value = " << mp[20];
}
else {
    cout << "Key 20 not found";
}

🔹 Iteration

for (auto &p : mp) {
    cout << p.first << " → " << p.second << endl;
}

⚠️ Unlike map, iteration order is unpredictable (depends on hashing).

🔹 Characteristics

Unordered → No sorting of keys.
Unique keys → Each key is stored only once.
Underlying data structure → Hash Table.
Fast average operations → O(1).

🔹 Advantages (Pros)

✅ Much faster than map for lookups (average O(1)).
✅ Great for frequency counting, existence check, hash-based problems.
✅ Easy syntax like map.

🔹 Disadvantages (Cons)

❌ Keys are not stored in order → no range queries, no smallest/largest key.
❌ Slightly more memory usage due to hashing buckets.
❌ Worst-case O(n) time (though rare with good hash functions).
❌ Doesn’t work well with custom complex types unless you define a hash function.

🔹 `map` vs `unordered_map`

Feature	`map` (Red-Black Tree)	`unordered_map` (Hash Table)
Order of keys	Sorted	No order
Lookup/Insert/Erase	O(log n)	O(1) average, O(n) worst
Use case	Need ordering, ranges	Just need fast lookups
Memory	Lower	Higher (hash overhead)

🔹 Typical LeetCode Use Cases

Two Sum (store number → index for O(n) solution).

Counting frequency of elements.

  unordered_map<int,int> freq;
  for (int x : nums) freq[x]++;

Checking existence in O(1).
Prefix sums / subarray problems.
Graph adjacency list (fast access).

✅ Summary

unordered_map = Hash table based key-value store.
Operations = O(1) average.
Faster than map if you don’t care about sorting.
Use in LeetCode most of the time unless the problem needs sorted keys.

👉 So:

Use unordered_map by default for speed.
Use map if you specifically need sorted keys or range queries.

📘map in C++

Rohit K — Wed, 03 Sep 2025 06:27:45 GMT

🔹 What is `map`?

A container in C++ (from STL) that stores key → value pairs.
Each key is unique.
Keys are stored in sorted order (ascending by default).
Internally implemented as a balanced binary search tree (Red-Black Tree).

👉 Think of it as a dictionary: word (key) → meaning (value).

🔹 Syntax

map mp;

Example:

map<string, int> age;
age["Alice"] = 20;
age["Bob"] = 25;

Stored as:

"Alice" → 20
"Bob"   → 25

🔹 Key vs Value

Key = used for searching/ordering.
Value = information linked to that key.
In map,
- string = key,
- int = value.

🔹 Common Operations & Complexity

Operation	Code Example	Time Complexity
Insert	`mp[key] = value;` or `mp.insert({key,value});`	O(log n)
Access (by key)	`mp[key]`	O(log n)
Search	`mp.find(key)`	O(log n)
Erase	`mp.erase(key)`	O(log n)
Size	`mp.size()`	O(1)
Iterate	`for (auto &p: mp) ...`	O(n)

🔹 Example

map<int, string> mp;
mp[30] = "X";
mp[10] = "Y";
mp[20] = "Z";

// Stored as sorted by key:
10 → "Y"
20 → "Z"
30 → "X"

🔹 Checking Existence

if (mp.find(20) != mp.end()) {
    cout << "Key 20 found, value = " << mp[20];
}
else {
    cout << "Key 20 not found";
}

🔹 Iteration

for (auto it = mp.begin(); it != mp.end(); it++) {
    cout << it->first << " → " << it->second << endl;
}
// or
for (auto &p : mp) {
    cout << p.first << " → " << p.second << endl;
}

🔹 Characteristics

Sorted order
- Integers sorted numerically.
- Strings sorted lexicographically.
- Custom keys sorted using comparator.
Unique keys only
- If you insert the same key again, it updates the value.
Underlying data structure
- Red-Black Tree (balanced BST).
- This is why all operations are O(log n).

🔹 Advantages (Pros)

✅ Keeps keys sorted automatically
✅ Fast lookup, insert, erase → O(log n)
✅ Works with any data type as key (numbers, strings, pairs, custom structs with comparator)

🔹 Disadvantages (Cons)

❌ Slower than unordered_map (O(1) average)
❌ More memory overhead (tree structure)
❌ If you don’t need sorting, it’s wasteful

🔹 `map` vs `unordered_map`

Feature	`map`	`unordered_map`
Order of keys	Sorted	No order
Complexity	O(log n)	O(1) avg, O(n) worst
Use case	Need order / ranges	Just fast lookups
Internal structure	Red-Black Tree	Hash Table

🔹 Typical LeetCode Use Cases

Counting frequency

  map<int,int> freq;
  for (int x : nums) freq[x]++;

Checking existence
```
  if (mp.find(target) != mp.end()) ...
```
Two Sum problem (using number → index mapping).
Tracking smallest/largest key (since ordered).

✅ Summary

map = ordered key-value container (Red-Black Tree).
Operations = O(log n).
Keys always sorted.
Use when order matters or you need range queries.
Prefer unordered_map for faster average lookups when order doesn’t matter.

CPP concepts

unordered_map in C++

🔹 What is unordered_map?

🔹 Syntax

🔹 Common Operations & Complexity

🔹 Example

🔹 Checking Existence

🔹 Iteration

🔹 Characteristics

🔹 Advantages (Pros)

🔹 Disadvantages (Cons)

🔹 map vs unordered_map

🔹 Typical LeetCode Use Cases

✅ Summary

📘map in C++

🔹 What is map?

🔹 Syntax

🔹 Key vs Value

🔹 Common Operations & Complexity

🔹 Example

🔹 Checking Existence

🔹 Iteration

🔹 Characteristics

🔹 Advantages (Pros)

🔹 Disadvantages (Cons)

🔹 map vs unordered_map

🔹 Typical LeetCode Use Cases

✅ Summary

🔹 What is `unordered_map`?

🔹 `map` vs `unordered_map`

🔹 What is `map`?

🔹 `map` vs `unordered_map`