vector

Dynamic array that can grow and shrink in size.

#include <vector>
vector<int> v = {1, 2, 3};
v.push_back(4);        // Add element
v.pop_back();         // Remove last element
v.size();            // Get size
v.empty();           // Check if empty
v[0];               // Access element
                

list

Doubly linked list implementation.

#include <list>
list<int> lst = {1, 2, 3};
lst.push_back(4);     // Add to end
lst.push_front(0);    // Add to front
lst.pop_back();      // Remove from end
lst.pop_front();     // Remove from front
                

deque

Double-ended queue with dynamic array implementation.

#include <deque>
deque<int> dq = {1, 2, 3};
dq.push_back(4);     // Add to end
dq.push_front(0);    // Add to front
dq.pop_back();      // Remove from end
dq.pop_front();     // Remove from front
                

set

Sorted unique elements.

#include <set>
set<int> s = {3, 1, 2, 1};  // Stores: {1, 2, 3}
s.insert(4);         // Insert element
s.erase(1);         // Remove element
s.count(2);         // Count occurrences (0 or 1)
s.find(3);          // Find element
                

map

Sorted key-value pairs with unique keys.

#include <map>
map<string, int> m;
m["apple"] = 1;
m["banana"] = 2;
m.count("apple");    // Check if key exists
m.erase("banana");   // Remove key-value pair
                

multiset & multimap

Allow duplicate elements/keys.

#include <set>
#include <map>
multiset<int> ms = {1, 1, 2, 2, 3};
multimap<string, int> mm;
mm.insert({"apple", 1});
mm.insert({"apple", 2});
                

unordered_set & unordered_map

Hash table implementations with O(1) average time complexity.

#include <unordered_set>
#include <unordered_map>
unordered_set<int> us = {3, 1, 2};
unordered_map<string, int> um;
um["fast"] = 1;     // O(1) insertion
us.find(2);         // O(1) lookup
                

Sorting Algorithms

#include <algorithm>
vector<int> v = {3, 1, 4, 1, 5};
sort(v.begin(), v.end());                    // Sort ascending
sort(v.begin(), v.end(), greater<int>());    // Sort descending
// Custom sort
sort(v.begin(), v.end(), 
     [](int a, int b) { return a > b; });    // Lambda function
                

Binary Search

// On sorted containers:
binary_search(v.begin(), v.end(), 3);    // Returns bool
lower_bound(v.begin(), v.end(), 3);      // First element >= value
upper_bound(v.begin(), v.end(), 3);      // First element > value
                

Other Common Algorithms

// Min/Max
*max_element(v.begin(), v.end());
*min_element(v.begin(), v.end());

// Sum
accumulate(v.begin(), v.end(), 0);

// Count
count(v.begin(), v.end(), 1);

// Find
find(v.begin(), v.end(), 5);

// Reverse
reverse(v.begin(), v.end());

// Next permutation
next_permutation(v.begin(), v.end());