In this article, I'll summarize the 40 most common C++ STL algorithms I have come across.

Search and predicates:

These are functions that search through a container for a single element or a sequence.

find:

Finds the first occurrence of a value in a range.

std::vector<int> v = {1, 2, 3, 4, 5};
auto it = std::find(v.begin(), v.end(), 3);

search:

Searches for a subsequence within a range.

std::vector<int> haystack = {1, 2, 3, 4, 5, 6, 7};
std::vector<int> needle = {3, 4, 5};
auto it = std::search(haystack.begin(), haystack.end(), needle.begin(), needle.end());

binary_search:

Checks if a value exists in a sorted range using binary search.

std::vector<int> v = {1, 2, 3, 4, 5};  // Must be sorted
bool found = std::binary_search(v.begin(), v.end(), 3);

find_end:

Finds the last occurrence of a subsequence within a range.

std::vector<int> haystack = {1, 2, 3, 1, 2, 3, 4};
std::vector<int> needle = {1, 2, 3};
auto it = std::find_end(haystack.begin(), haystack.end(), needle.begin(), needle.end());

find_if:

Finds the first element that satisfies a predicate.

std::vector<int> v = {1, 2, 3, 4, 5};
auto it = std::find_if(v.begin(), v.end(), [](int x) { return x % 2 == 0; });

all_of:

Checks if all elements satisfy a predicate.

std::vector<int> v = {2, 4, 6, 8, 10};
bool allEven = std::all_of(v.begin(), v.end(), [](int x) { return x % 2 == 0; });

any_of:

Checks if at least one element satisfies a predicate.

std::vector<int> v = {1, 3, 5, 6, 9};
bool hasEven = std::any_of(v.begin(), v.end(), [](int x) { return x % 2 == 0; });

none_of:

Checks if no element satisfies a predicate.

std::vector<int> v = {1, 3, 5, 7, 9};
bool noEven = std::none_of(v.begin(), v.end(), [](int x) { return x % 2 == 0; });

Transforms, mutations and samples:

These functions mutate the input container either in-place or out-of-place.

transform:

Applies a function to each element in a range and stores the results.

std::vector<int> v = {1, 2, 3, 4, 5};
std::vector<int> result(v.size());
std::transform(v.begin(), v.end(), result.begin(), [](int x) { return x * 2; });

for_each:

Applies a function to each element in a range.

std::vector<int> v = {1, 2, 3, 4, 5};
std::for_each(v.begin(), v.end(), [](int& x) { x *= 2; });

reduce:

Reduces a range of elements to a single value.

std::vector<int> v = {1, 2, 3, 4, 5};
int sum = std::reduce(v.begin(), v.end());
int product = std::reduce(v.begin(), v.end(), 1, std::multiplies<>());

replace:

Replaces all occurrences of a value with another value.

std::vector<int> v = {1, 2, 3, 2, 5};
std::replace(v.begin(), v.end(), 2, 9);

replace_if:

Replaces all elements that satisfy a predicate.

std::vector<int> v = {1, 2, 3, 4, 5};
std::replace_if(v.begin(), v.end(), [](int x) { return x % 2 == 0; }, 0);

shuffle:

Randomly reorders elements in a range.

std::vector<int> v = {1, 2, 3, 4, 5};
std::random_device rd;
std::mt19937 g(rd());
std::shuffle(v.begin(), v.end(), g);

rotate:

Rotates the elements in a range.

std::vector<int> v = {1, 2, 3, 4, 5};
std::rotate(v.begin(), v.begin() + 2, v.end()); // Results in {3, 4, 5, 1, 2}

reverse:

Reverses the order of elements in a range.

std::vector<int> v = {1, 2, 3, 4, 5};
std::reverse(v.begin(), v.end()); // Results in {5, 4, 3, 2, 1}

swap_ranges:

Swaps elements between two ranges.

std::vector<int> v1 = {1, 2, 3};
std::vector<int> v2 = {4, 5, 6};
std::swap_ranges(v1.begin(), v1.end(), v2.begin());

sample:

Selects n random elements from a range.

std::vector<int> v = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
std::vector<int> sample(3);
std::random_device rd;
std::mt19937 g(rd());
std::sample(v.begin(), v.end(), sample.begin(), 3, g);

count:

Counts elements equal to a value in a range.

std::vector<int> v = {1, 2, 2, 3, 2, 4, 5};
int twos = std::count(v.begin(), v.end(), 2);

Sort and partition:

These functions are helpful for sorting.

sort:

Sorts elements in a range.

std::vector<int> v = {5, 3, 1, 4, 2};
std::sort(v.begin(), v.end());
// Sort descending
std::sort(v.begin(), v.end(), std::greater<>());

partition:

Reorders elements so those satisfying a predicate come first.

std::vector<int> v = {1, 2, 3, 4, 5, 6, 7, 8, 9};
auto it = std::partition(v.begin(), v.end(), [](int x) { return x % 2 == 0; });

Copy and move:

Although not always required, these functions help to copy and move items.

copy:

Copies elements from one range to another.

std::vector<int> src = {1, 2, 3, 4, 5};
std::vector<int> dest(5);
std::copy(src.begin(), src.end(), dest.begin());

move:

Moves elements from one range to another.

std::vector<std::string> src = {"apple", "banana", "cherry"};
std::vector<std::string> dest(3);
std::move(src.begin(), src.end(), dest.begin());

Numerics:

These functions perform numerical operations.

iota:

Fills a range with incremental values.

std::vector<int> v(5);
std::iota(v.begin(), v.end(), 10); // Results in {10, 11, 12, 13, 14}

min:

Returns the smaller of two values.

int result = std::min(42, 24);

max:

Returns the larger of two values.

int result = std::max(42, 24);

min_element:

Finds the smallest element in a range.

std::vector<int> v = {5, 3, 1, 4, 2};
auto it = std::min_element(v.begin(), v.end());

max_element:

Finds the largest element in a range.

std::vector<int> v = {5, 3, 1, 4, 2};
auto it = std::max_element(v.begin(), v.end());

clamp:

Constrains a value between a pair of boundary values.

int result = std::clamp(75, 0, 100); // 75
int result2 = std::clamp(-5, 0, 100); // 0
int result3 = std::clamp(200, 0, 100); // 100

gcd:

Computes the greatest common divisor of two integers. There is equivalent lcm function as well.

int result = std::gcd(24, 36); // 12

Set operations:

These are set operations that are applied to containers.

union:

Constructs a sorted union of two sorted ranges.

std::vector<int> v1 = {1, 2, 3, 4, 5};
std::vector<int> v2 = {4, 5, 6, 7, 8};
std::vector<int> result(10);
auto it = std::set_union(v1.begin(), v1.end(), v2.begin(), v2.end(), result.begin());
result.resize(it - result.begin());

intersection:

Constructs a sorted intersection of two sorted ranges.

std::vector<int> v1 = {1, 2, 3, 4, 5};
std::vector<int> v2 = {4, 5, 6, 7, 8};
std::vector<int> result(5);
auto it = std::set_intersection(v1.begin(), v1.end(), v2.begin(), v2.end(), result.begin());
result.resize(it - result.begin());

difference:

Constructs a sorted difference of two sorted ranges.

std::vector<int> v1 = {1, 2, 3, 4, 5};
std::vector<int> v2 = {4, 5, 6, 7, 8};
std::vector<int> result(5);
auto it = std::set_difference(v1.begin(), v1.end(), v2.begin(), v2.end(), result.begin());
result.resize(it - result.begin());

merge:

Merges two sorted ranges into one sorted range.

std::vector<int> v1 = {1, 3, 5};
std::vector<int> v2 = {2, 4, 6};
std::vector<int> result(6);
std::merge(v1.begin(), v1.end(), v2.begin(), v2.end(), result.begin());

includes:

Tests whether a sorted range includes all elements from another sorted range.

std::vector<int> v1 = {1, 2, 3, 4, 5};
std::vector<int> v2 = {2, 3, 4};
bool included = std::includes(v1.begin(), v1.end(), v2.begin(), v2.end());

Heap operations:

These are operations specific to heap.

make_heap:

Creates a heap from a range.

std::vector<int> v = {3, 1, 4, 1, 5, 9};
std::make_heap(v.begin(), v.end());

push_heap:

Adds an element to a heap.

std::vector<int> v = {3, 1, 4, 1, 5, 9};
std::make_heap(v.begin(), v.end());
v.push_back(6);
std::push_heap(v.begin(), v.end());

pop_heap:

Removes the largest element from a heap.

std::vector<int> v = {3, 1, 4, 1, 5, 9};
std::make_heap(v.begin(), v.end());
std::pop_heap(v.begin(), v.end());
int largest = v.back();
v.pop_back();

sort_heap:

Sorts elements of a heap.

std::vector<int> v = {3, 1, 4, 1, 5, 9};
std::make_heap(v.begin(), v.end());
std::sort_heap(v.begin(), v.end());

is_heap:

Checks if a range is a heap.

std::vector<int> v = {9, 5, 4, 1, 1, 3};
bool isHeap = std::is_heap(v.begin(), v.end());