Collapse All Levels Collapse Top Level Expand Top Level Expand All Levels
News Featured Articles Beginner's Guide to C++ Lists
@hackingcpp About Privacy Home
    Contents A-Z
    A-B
    C
    D-E
    F
    G-H
    I
    L
    M
    N
    P
    R
    S
    T
    U-Z

    Standard Library Algorithms Standard Algorithms Algorithms

    New to C++'s standard library algorithms?  ⇒  Short Introduction
    C++20 variants taking single range object as inputs

    Non-Modifying Operations Non-Modifying Non-Mod.

    Existence Queries Existence

    returns true if predicate check yields true for any element in the input range; otherwise returns false
    returns true if predicate check yields true for all elements in the input range; otherwise returns false
    returns true if predicate check yields false for all elements in the input range; otherwise returns false
    returns the number of elements equal to value
    returns the number of elements for which predicate condition yields true

    Finding / Locating Elements Locate

    Find Single Elements
    find the 1st matching position of a single element that compares equal to value
    find the 1st matching position of a single element for which predicate f is true
    find the 1st matching position of a single element for which predicate f is false
    find the 1st matching position in range s of any element contained in range w

    find the 1st matching position in range s of any element contained in range w

    Find Consecutive Runs of Equal Elements
    find the starting position of a run of at least 2 consecutive identical elements
    find the starting position of a run of at least n consecutive identical elements equal to value
    Find Subranges
    searches for the first occurrence of range 2 inside range 1
    find last occurrence of range 2 inside range 1

    Comparing Ranges Compare

    returns true if all elements in both ranges are equal; otherwise returns false
    returns a pair of iterators to the first mismatching elements in 2 ranges
    returns true if range 1 is lexicographically less than range 2
    compares 2 ranges using 3-way comparisons and returns the result as a value of the strongest applicable comparsion category

    Binary Search of Sorted Ranges Binary Search Binary Search

    returns true if the input range contains an element equivalent to value; otherwise returns false; input range must be sorted
    returns the position of the first element greater than value; input range must be sorted
    returns the position of the first element not smaller than value; input range must be sorted
    returns an iterator range of all elements equivalent to value; input range must be sorted
    return true if sorted range 2 was found inside sorted range 1; input ranges must be sorted

    Minimum / Maximum Min/Max

    returns an iterator to the smallest element; the 2nd version uses compare for comparing elements, while the 1st version uses operator<
    returns an iterator to the largest element; the 2nd version uses compare for comparing elements, while the 1st version uses operator<
    returns a pair of iterators to both the smallest and largest elements; the 2nd version uses comp for comparing elements, while the 1st version uses operator<

    min/max/minmax/clamp

    (a, b) →  a if (a < b) is true, b otherwise

    (a, b, f(o,o)→bool) →  a if f(a,b) is true, b otherwise

    ({v1,v2,v3, …}) →  smallest value C++11

    (a, b) →  b if (a < b) is true, a otherwise

    (a, b, f(o,o)→bool) →  b if f(a,b) is true, a otherwise

    ({v1,v2,v3,…}) →  largest value C++11

    (a, b) →  { smallest , largest }

    (a, b, f(o,o)→bool) →  { smallest , largest }

    ({v1,v2,v3, …}) →  { smallest , largest }

    C++11  custom comparison function/object: f(a,b) must return true if a should be ordered before b

    (value,hi,lo) → clamped_value

    (value,hi,lo,f(o,o)→bool) → clamped_value

    C++17  clamps value in the interval given by hi and lo; the second version uses f to compare values instead of operator<

    Structural Properties Structural

    returns true if the input range is sorted and false otherwise; the 2nd version uses compare for comparing elements, while the 1st version uses operator<
    returns the first position where the input range is no longer sorted; the 2nd version uses compare for comparing elements, while the 1st version uses operator<
    returns true if the input range is partitioned according to predicate f and false otherwise
    returns the start of the partition of elements for which predicate f; yields false; the input range must be partitioned according to f
    return true if range 2 is a permutation of range 1, i.e., both ranges must contain the same elements, but not necessarily in the same order
    returns true if the input range is a max heap and false otherwise
    returns the first position where the input range is no longer a max heap

    Traversing Ranges Traversal

    applies predicate f to all elements in the input range [begin, end)
    applies predicate f to all elements in the input range [begin, begin+n)

    Copying / Moving / Swapping Elements Copy/Move/Swap Copy/Move

    copies all elements in the input range to a target (range) beginning at target_begin and returns an iterator one behind the last target value; the target must be able to recieve distance(begin,end) many elements
    copies all elements in the range starting at begin to a target (range) beginning at target_begin and returns an iterator one behind the last target value; the target must be able to recieve n elements
    copies all elements in the input range to a target (range) ending at target_end and returns an iterator to the first target value; the target must be able to recieve distance(begin,end) many elements
    copies all elements in the input range for which select yields true to a target (range) beginning at tgt and returns an iterator one behind the last target value; the target must be able to recieve the copied elements
    moves all elements in the input range to a target (range) beginning at target_begin and returns an iterator one behind the last target value; the target must be able to recieve distance(begin,end) many elements
    moves all elements in the input range to a target (range) ending at target_end and returns an iterator to the first target value; the target must be able to recieve distance(begin,end) many elements
    Random Sampling
    Selects n elements (without replacement) with equal probability from an input population range using a random_generator (uniform random bit engine) and writes them to an output range.
    Swapping

    Reordering Elements Reordering Reorder

    Shifting Shift

    reverses the order of the elements in the input range
    copies all elements in the input range to an output (range) beginning at out and returns an iterator one behind the last output value; the output must be able to recieve distance(begin,end) many elements
    performs a cyclic left rotation: elements in the range [begin, new_first) are put behind end (in their original order) so that new_fist
    Shift Randomly Randomly

    Sorting Sort

    returns true if the input range is sorted and false otherwise; the 2nd version uses compare for comparing elements, while the 1st version uses operator<
    returns the first position where the input range is no longer sorted; the 2nd version uses compare for comparing elements, while the 1st version uses operator<

    Partitioning Partition

    returns true if the input range is partitioned according to predicate f and false otherwise

    Permutations Permute

    return true if range 2 is a permutation of range 1, i.e., both ranges must contain the same elements, but not necessarily in the same order

    Heap Operations Heaps

    for using contiguous containers (std::array, std::vector, …) as a max heap, i.e., a (conceptual) binary tree where each parent has a larger value than its children

    learn more…

    returns true if the input range is a max heap and false otherwise
    returns the first position where the input range is no longer a max heap

    Modifying Elements Modify

    Changing / Replacing Values

    Removing Remove

    Sorted Range Operations Sorted Ranges

    Sorted Ranges As Sets

    Numeric Operations Numeric Operations Numeric

    #include <numeric>

    Reductions Reduce

    prefer C++17's reduce over accumulate

    prefer C++17's reduce over accumulate
    prefer C++17's transform_reduce over inner_product

    prefer C++17's transform_reduce over inner_product

    Scans (Prefix Sums) Scan

    prefer C++17's inclusive_scan over partial_sum

    prefer C++17's inclusive_scan over partial_sum

    Range & Iterator Utilities Range Utilities Utilities

    applies predicate f to all elements in the input range [begin, end)
    applies predicate f to all elements in the input range [begin, begin+n)

    Legend (Parameter Iconography)

    Beginner's Guide Articles Guide Articles

    Overview Sheet (click/zoom)

    Related …

    Last updated: 2021-02-21

    Comments