Standard library header <algorithm>

 

C++

Language

Standard library headers

Concepts

Utilities library

Strings library

Containers library

Algorithms library

Iterators library

Numerics library

Input/output library

Localizations library

Regular expressions library (C++11)

Atomic operations library (C++11)

Thread support library (C++11)

 

Standard Library header files

Language Support
<cstddef> <limits> <climits> <cfloat> <cstdint> <new> <typeinfo> <exception> <ciso646>	<initializer_list> <csignal> <csetjmp> <cstdalign> <cstdarg> <cstdbool> <cstdlib> <ctime>
Diagnostics
<stdexcept> <cassert>	<cerrno> <system_error>
General utilities
<utility> <tuple> <bitset> <memory> <cstdlib> <cstring> <functional>	<type_traits> <ratio> <chrono> <ctime> <scoped_allocator> <typeindex>
Strings
<string> <cctype> <cwctype> <cstring>	<cwchar> <cstdlib> <cuchar>
Localization
<locale> <codectv> <clocale>

Containers
<array> <deque> <forward_list> <list> <vector>	<map> <set> <unordered_map> <unordered_set> <queue> <stack>
Iterators
<iterator>
Algorithms
<algorithm>	<cstdlib>
Numerics
<cfenv> <complex> <random> <valarray>	<numeric> <cmath> <ctgmath> <cstdlib>
Input/Output
<iosfwd> <iostream> <ios> <streambuf> <istream> <ostream>	<iomanip> <sstream> <fstream> <cstdio> <cinttypes>
Regular expressions
<regex>
Thread support
<thread> <mutex> <atomic>	<shared_mutex> <condition_variable> <future>

 

This header is part of the algorithm library.

Functions

Non-modifying sequence operations
all_ofany_ofnone_of (C++11)(C++11)(C++11)	checks if a predicate is true for all, any or none of the elements in a range (function template)
for_each	applies a function to a range of elements (function template)
countcount_if	returns the number of elements satisfying specific criteria (function template)
mismatch	finds the first position where two ranges differ (function template)
equal	determines if two sets of elements are the same (function template)
findfind_iffind_if_not (C++11)	finds the first element satisfying specific criteria (function template)
find_end	finds the last sequence of elements in a certain range (function template)
find_first_of	searches for any one of a set of elements (function template)
adjacent_find	finds the first two adjacent items that are equal (or satisfy a given predicate) (function template)
search	searches for a range of elements (function template)
search_n	searches for a number consecutive copies of an element in a range (function template)
Modifying sequence operations
copycopy_if (C++11)	copies a range of elements to a new location (function template)
copy_n (C++11)	copies a number of elements to a new location (function template)
copy_backward	copies a range of elements in backwards order (function template)
move (C++11)	moves a range of elements to a new location (function template)
move_backward (C++11)	moves a range of elements to a new location in backwards order (function template)
fill	assigns a range of elements a certain value (function template)
fill_n	assigns a value to a number of elements (function template)
transform	applies a function to a range of elements (function template)
generate	saves the result of a function in a range (function template)
generate_n	saves the result of N applications of a function (function template)
removeremove_if	removes elements satisfying specific criteria (function template)
remove_copyremove_copy_if	copies a range of elements omitting those that satisfy specific criteria (function template)
replacereplace_if	replaces all values satisfying specific criteria with another value (function template)
replace_copyreplace_copy_if	copies a range, replacing elements satisfying specific criteria with another value (function template)
swap	swaps the values of two objects (function template)
swap_ranges	swaps two ranges of elements (function template)
iter_swap	swaps the elements pointed to by two iterators (function template)
reverse	reverses the order elements in a range (function template)
reverse_copy	creates a copy of a range that is reversed (function template)
rotate	rotates the order of elements in a range (function template)
rotate_copy	copies and rotate a range of elements (function template)
random_shuffleshuffle  (C++11)	randomly re-orders elements in a range (function template)
unique	removes consecutive duplicate elements in a range (function template)
unique_copy	creates a copy of some range of elements that contains no consecutive duplicates (function template)
Partitioning operations
is_partitioned (C++11)	determines if the range is partitioned by the given predicate (function template)
partition	divides a range of elements into two groups (function template)
partition_copy (C++11)	copies a range dividing the elements into two groups (function template)
stable_partition	divides elements into two groups while preserving their relative order (function template)
partition_point (C++11)	locates the partition point of a partitioned range (function template)
Sorting operations (on sorted ranges)
is_sorted (C++11)	checks whether a range is sorted into ascending order (function template)
is_sorted_until (C++11)	finds the largest sorted subrange (function template)
sort	sorts a range into ascending order (function template)
partial_sort	sorts the first N elements of a range (function template)
partial_sort_copy	copies and partially sorts a range of elements (function template)
stable_sort	sorts a range of elements while preserving order between equal elements (function template)
nth_element	partially sorts the given range making sure that it is partitioned by the given element (function template)
Binary search operations (on sorted ranges)
lower_bound	returns an iterator to the first element not less than the given value (function template)
upper_bound	returns an iterator to the first element greater than a certain value (function template)
binary_search	determines if an element exists in a certain range (function template)
equal_range	returns range of elements matching a specific key (function template)
Set operations (on sorted ranges)
merge	merges two sorted ranges (function template)
inplace_merge	merges two ordered ranges in-place (function template)
includes	returns true if one set is a subset of another (function template)
set_difference	computes the difference between two sets (function template)
set_intersection	computes the intersection of two sets (function template)
set_symmetric_difference	computes the symmetric difference between two sets (function template)
set_union	computes the union of two sets (function template)
Heap operations
is_heap (C++11)	checks if the given range is a max heap (function template)
is_heap_until (C++11)	finds the largest subrange that is a max heap (function template)
make_heap	creates a max heap out of a range of elements (function template)
push_heap	adds an element to a max heap (function template)
pop_heap	removes the largest element from a max heap (function template)
sort_heap	turns a max heap into a range of elements sorted in ascending order (function template)
Minimum/maximum operations
max	returns the larger of two elements (function template)
max_element	returns the largest element in a range (function template)
min	returns the smaller of two elements (function template)
min_element	returns the smallest element in a range (function template)
minmax (C++11)	returns the larger and the smaller of two elements (function template)
minmax_element (C++11)	returns the smallest and the largest element in a range (function template)
lexicographical_compare	returns true if one range is lexicographically less than another (function template)
is_permutation (C++11)	determines if a sequence is a permutation of another sequence (function template)
next_permutation	generates the next greater lexicographic permutation of a range of elements (function template)
prev_permutation	generates the next smaller lexicographic permutation of a range of elements (function template)

Synopsis

#include <initializer_list>
namespace std
{
    // non-modifying sequence operations:
    template <class InputIterator, class Predicate>
        bool all_of(InputIterator first, InputIterator last, Predicate pred);
    template <class InputIterator, class Predicate>
        bool any_of(InputIterator first, InputIterator last, Predicate pred);
    template <class InputIterator, class Predicate>
        bool none_of(InputIterator first, InputIterator last, Predicate pred);
 
    template<class InputIterator, class Function>
        Function for_each(InputIterator first, InputIterator last, Function f);
 
    template<class InputIterator, class T>
        InputIterator find(InputIterator first, InputIterator last,
                           const T& value);
    template<class InputIterator, class Predicate>
        InputIterator find_if(InputIterator first, InputIterator last,
                              Predicate pred);
    template<class InputIterator, class Predicate>
        InputIterator find_if_not(InputIterator first, InputIterator last,
                                  Predicate pred);
 
    template<class ForwardIterator1, class ForwardIterator2>
        ForwardIterator1
        find_end(ForwardIterator1 first1, ForwardIterator1 last1,
                 ForwardIterator2 first2, ForwardIterator2 last2);
    template<class ForwardIterator1, class ForwardIterator2,
             class BinaryPredicate>
        ForwardIterator1
        find_end(ForwardIterator1 first1, ForwardIterator1 last1,
                 ForwardIterator2 first2, ForwardIterator2 last2,
                 BinaryPredicate pred);
 
    template<class InputIterator, class ForwardIterator>
        InputIterator
        find_first_of(InputIterator first1, InputIterator last1,
                      ForwardIterator first2, ForwardIterator last2);
    template<class InputIterator, class ForwardIterator,
             class BinaryPredicate>
        InputIterator
        find_first_of(InputIterator first1, InputIterator last1,
                      ForwardIterator first2, ForwardIterator last2,
                      BinaryPredicate pred);
 
    template<class ForwardIterator>
        ForwardIterator adjacent_find(ForwardIterator first,
                                      ForwardIterator last);
    template<class ForwardIterator, class BinaryPredicate>
        ForwardIterator adjacent_find(ForwardIterator first,
                                      ForwardIterator last,
                                      BinaryPredicate pred);
    template<class InputIterator, class T>
        typename iterator_traits<InputIterator>::difference_type
        count(InputIterator first, InputIterator last, const T& value);
    template<class InputIterator, class Predicate>
        typename iterator_traits<InputIterator>::difference_type
        count_if(InputIterator first, InputIterator last, Predicate pred);
 
    template<class InputIterator1, class InputIterator2>
        pair<InputIterator1, InputIterator2>
        mismatch(InputIterator1 first1, InputIterator1 last1,
                 InputIterator2 first2);
    template<class InputIterator1, class InputIterator2, class BinaryPredicate>
        pair<InputIterator1, InputIterator2>
        mismatch(InputIterator1 first1, InputIterator1 last1,
                 InputIterator2 first2, BinaryPredicate pred);
 
    template<class InputIterator1, class InputIterator2>
        bool equal(InputIterator1 first1, InputIterator1 last1,
                   InputIterator2 first2);
    template<class InputIterator1, class InputIterator2, class BinaryPredicate>
        bool equal(InputIterator1 first1, InputIterator1 last1,
                   InputIterator2 first2, BinaryPredicate pred);
 
    template<class ForwardIterator1, class ForwardIterator2>
        bool is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
                            ForwardIterator2 first2);
    template<class ForwardIterator1, class ForwardIterator2,
    class BinaryPredicate>
        bool is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
                            ForwardIterator2 first2, BinaryPredicate pred);
 
    template<class ForwardIterator1, class ForwardIterator2>
        ForwardIterator1 search(
            ForwardIterator1 first1, ForwardIterator1 last1,
            ForwardIterator2 first2, ForwardIterator2 last2);
    template<class ForwardIterator1, class ForwardIterator2,
             class BinaryPredicate>
        ForwardIterator1 search(
            ForwardIterator1 first1, ForwardIterator1 last1,
            ForwardIterator2 first2, ForwardIterator2 last2,
            BinaryPredicate pred);
 
    template<class ForwardIterator, class Size, class T>
        ForwardIterator search_n(ForwardIterator first, ForwardIterator last,
                                 Size count, const T& value);
    template<class ForwardIterator, class Size, class T, class BinaryPredicate>
        ForwardIterator1 search_n(ForwardIterator first, ForwardIterator last,
                                  Size count, const T& value,
                                  BinaryPredicate pred);
 
    // modifying sequence operations:
 
    // copy:
    template<class InputIterator, class OutputIterator>
        OutputIterator copy(InputIterator first, InputIterator last,
                            OutputIterator result);
    template<class InputIterator, class Size, class OutputIterator>
        OutputIterator copy_n(InputIterator first, Size n,
                              OutputIterator result);
    template<class InputIterator, class OutputIterator, class Predicate>
        OutputIterator copy_if(InputIterator first, InputIterator last,
                               OutputIterator result, Predicate pred);
    template<class BidirectionalIterator1, class BidirectionalIterator2>
        BidirectionalIterator2 copy_backward(
            BidirectionalIterator1 first, BidirectionalIterator1 last,
            BidirectionalIterator2 result);
 
    // move:
    template<class InputIterator, class OutputIterator>
        OutputIterator move(InputIterator first, InputIterator last,
                            OutputIterator result);
    template<class BidirectionalIterator1, class BidirectionalIterator2>
        BidirectionalIterator2 move_backward(
            BidirectionalIterator1 first, BidirectionalIterator1 last,
            BidirectionalIterator2 result);
 
    // swap:
    template<class ForwardIterator1, class ForwardIterator2>
        ForwardIterator2 swap_ranges(ForwardIterator1 first1,
                                     ForwardIterator1 last1, ForwardIterator2 first2);
    template<class ForwardIterator1, class ForwardIterator2>
        void iter_swap(ForwardIterator1 a, ForwardIterator2 b);
    template<class InputIterator, class OutputIterator, class UnaryOperation>
        OutputIterator transform(InputIterator first, InputIterator last,
                                 OutputIterator result, UnaryOperation op);
 
    template<class InputIterator1, class InputIterator2, class OutputIterator,
             class BinaryOperation>
        OutputIterator transform(InputIterator1 first1, InputIterator1 last1,
                                 InputIterator2 first2, OutputIterator result,
                                 BinaryOperation binary_op);
 
    template<class ForwardIterator, class T>
        void replace(ForwardIterator first, ForwardIterator last,
                     const T& old_value, const T& new_value);
    template<class ForwardIterator, class Predicate, class T>
        void replace_if(ForwardIterator first, ForwardIterator last,
                        Predicate pred, const T& new_value);
    template<class InputIterator, class OutputIterator, class T>
        OutputIterator replace_copy(InputIterator first, InputIterator last,
                                    OutputIterator result,
                                    const T& old_value, const T& new_value);
    template<class InputIterator, class OutputIterator, class Predicate, class T>
        OutputIterator replace_copy_if(InputIterator first, InputIterator last,
                                       OutputIterator result,
                                       Predicate pred, const T& new_value);
 
    template<class ForwardIterator, class T>
        void fill(ForwardIterator first, ForwardIterator last, const T& value);
    template<class OutputIterator, class Size, class T>
        OutputIterator fill_n(OutputIterator first, Size n, const T& value);
    template<class ForwardIterator, class Generator>
        void generate(ForwardIterator first, ForwardIterator last,
                      Generator gen);
    template<class OutputIterator, class Size, class Generator>
        OutputIterator generate_n(OutputIterator first, Size n, Generator gen);
 
    template<class ForwardIterator, class T>
        ForwardIterator remove(ForwardIterator first, ForwardIterator last,
                               const T& value);
    template<class ForwardIterator, class Predicate>
        ForwardIterator remove_if(ForwardIterator first, ForwardIterator last,
                                  Predicate pred);
    template<class InputIterator, class OutputIterator, class T>
        OutputIterator remove_copy(InputIterator first, InputIterator last,
                                   OutputIterator result, const T& value);
    template<class InputIterator, class OutputIterator, class Predicate>
        OutputIterator remove_copy_if(InputIterator first, InputIterator last,
                                      OutputIterator result, Predicate pred);
 
    template<class ForwardIterator>
        ForwardIterator unique(ForwardIterator first, ForwardIterator last);
    template<class ForwardIterator, class BinaryPredicate>
        ForwardIterator unique(ForwardIterator first, ForwardIterator last,
                               BinaryPredicate pred);
    template<class InputIterator, class OutputIterator>
        OutputIterator unique_copy(InputIterator first, InputIterator last,
                                   OutputIterator result);
    template<class InputIterator, class OutputIterator, class BinaryPredicate>
        OutputIterator unique_copy(InputIterator first, InputIterator last,
                                   OutputIterator result, BinaryPredicate pred);
 
    template<class BidirectionalIterator>
        void reverse(BidirectionalIterator first, BidirectionalIterator last);
    template<class BidirectionalIterator, class OutputIterator>
        OutputIterator reverse_copy(BidirectionalIterator first,
                                    BidirectionalIterator last,
                                    OutputIterator result);
 
    template<class ForwardIterator>
        ForwardIterator rotate(ForwardIterator first, ForwardIterator middle,
                               ForwardIterator last);
    template<class ForwardIterator, class OutputIterator>
        OutputIterator rotate_copy(
            ForwardIterator first, ForwardIterator middle,
            ForwardIterator last, OutputIterator result);
 
    template<class RandomAccessIterator>
        void random_shuffle(RandomAccessIterator first,
                            RandomAccessIterator last);
    template<class RandomAccessIterator, class RandomNumberGenerator>
        void random_shuffle(RandomAccessIterator first,
                            RandomAccessIterator last,
                            RandomNumberGenerator&& rand);
    template<class RandomAccessIterator, class UniformRandomNumberGenerator>
        void shuffle(RandomAccessIterator first,
                     RandomAccessIterator last,
                     UniformRandomNumberGenerator&& rand);
 
    // partitions:
    template <class InputIterator, class Predicate>
        bool is_partitioned(InputIterator first, InputIterator last, Predicate pred);
 
    template<class ForwardIterator, class Predicate>
        ForwardIterator partition(ForwardIterator first,
                                  ForwardIterator last,
                                  Predicate pred);
 
    template<class BidirectionalIterator, class Predicate>
        BidirectionalIterator stable_partition(BidirectionalIterator first,
                                               BidirectionalIterator last,
                                               Predicate pred);
 
    template <class InputIterator, class OutputIterator1,
              class OutputIterator2, class Predicate>
        pair<OutputIterator1, OutputIterator2>
        partition_copy(InputIterator first, InputIterator last,
                       OutputIterator1 out_true, OutputIterator2 out_false,
                       Predicate pred);
 
    template<class ForwardIterator, class Predicate>
        ForwardIterator partition_point(ForwardIterator first,
                                        ForwardIterator last,
                                        Predicate pred);
 
    // sorting and related operations:
 
    // sorting:
    template<class RandomAccessIterator>
        void sort(RandomAccessIterator first, RandomAccessIterator last);
    template<class RandomAccessIterator, class Compare>
        void sort(RandomAccessIterator first, RandomAccessIterator last,
                  Compare comp);
 
    template<class RandomAccessIterator>
        void stable_sort(RandomAccessIterator first, RandomAccessIterator last);
    template<class RandomAccessIterator, class Compare>
        void stable_sort(RandomAccessIterator first, RandomAccessIterator last,
                         Compare comp);
 
    template<class RandomAccessIterator>
        void partial_sort(RandomAccessIterator first,
                          RandomAccessIterator middle,
                          RandomAccessIterator last);
    template<class RandomAccessIterator, class Compare>
        void partial_sort(RandomAccessIterator first,
                          RandomAccessIterator middle,
                          RandomAccessIterator last, Compare comp);
    template<class InputIterator, class RandomAccessIterator>
        RandomAccessIterator partial_sort_copy(
            InputIterator first, InputIterator last,
            RandomAccessIterator result_first,
            RandomAccessIterator result_last);
    template<class InputIterator, class RandomAccessIterator, class Compare>
        RandomAccessIterator partial_sort_copy(
            InputIterator first, InputIterator last,
            RandomAccessIterator result_first,
            RandomAccessIterator result_last,
            Compare comp);
 
    template<class ForwardIterator>
        bool is_sorted(ForwardIterator first, ForwardIterator last);
    template<class ForwardIterator, class Compare>
        bool is_sorted(ForwardIterator first, ForwardIterator last,
                       Compare comp);
    template<class ForwardIterator>
        ForwardIterator is_sorted_until(ForwardIterator first, ForwardIterator last);
    template<class ForwardIterator, class Compare>
        ForwardIterator is_sorted_until(ForwardIterator first, ForwardIterator last,
                                        Compare comp);
 
    template<class RandomAccessIterator>
        void nth_element(RandomAccessIterator first, RandomAccessIterator nth,
                         RandomAccessIterator last);
    template<class RandomAccessIterator, class Compare>
        void nth_element(RandomAccessIterator first, RandomAccessIterator nth,
                         RandomAccessIterator last, Compare comp);
    // binary search:
    template<class ForwardIterator, class T>
        ForwardIterator lower_bound(ForwardIterator first, ForwardIterator last,
                                    const T& value);
    template<class ForwardIterator, class T, class Compare>
        ForwardIterator lower_bound(ForwardIterator first, ForwardIterator last,
                                    const T& value, Compare comp);
 
    template<class ForwardIterator, class T>
        ForwardIterator upper_bound(ForwardIterator first, ForwardIterator last,
                                    const T& value);
    template<class ForwardIterator, class T, class Compare>
        ForwardIterator upper_bound(ForwardIterator first, ForwardIterator last,
                                    const T& value, Compare comp);
 
    template<class ForwardIterator, class T>
        pair<ForwardIterator, ForwardIterator>
        equal_range(ForwardIterator first, ForwardIterator last,
                    const T& value);
    template<class ForwardIterator, class T, class Compare>
        pair<ForwardIterator, ForwardIterator>
        equal_range(ForwardIterator first, ForwardIterator last,
                    const T& value, Compare comp);
 
    template<class ForwardIterator, class T>
        bool binary_search(ForwardIterator first, ForwardIterator last,
                           const T& value);
    template<class ForwardIterator, class T, class Compare>
        bool binary_search(ForwardIterator first, ForwardIterator last,
                           const T& value, Compare comp);
 
    // merge:
    template<class InputIterator1, class InputIterator2, class OutputIterator>
        OutputIterator merge(InputIterator1 first1, InputIterator1 last1,
                             InputIterator2 first2, InputIterator2 last2,
                             OutputIterator result);
    template<class InputIterator1, class InputIterator2, class OutputIterator,
            class Compare>
        OutputIterator merge(InputIterator1 first1, InputIterator1 last1,
                             InputIterator2 first2, InputIterator2 last2,
                             OutputIterator result, Compare comp);
 
    template<class BidirectionalIterator>
        void inplace_merge(BidirectionalIterator first,
                           BidirectionalIterator middle,
                           BidirectionalIterator last);
    template<class BidirectionalIterator, class Compare>
        void inplace_merge(BidirectionalIterator first,
                           BidirectionalIterator middle,
                           BidirectionalIterator last, Compare comp);
 
    // set operations:
    template<class InputIterator1, class InputIterator2>
        bool includes(InputIterator1 first1, InputIterator1 last1,
                      InputIterator2 first2, InputIterator2 last2);
    template<class InputIterator1, class InputIterator2, class Compare>
        bool includes(
            InputIterator1 first1, InputIterator1 last1,
            InputIterator2 first2, InputIterator2 last2, Compare comp);
 
    template<class InputIterator1, class InputIterator2, class OutputIterator>
        OutputIterator set_union(InputIterator1 first1, InputIterator1 last1,
                                 InputIterator2 first2, InputIterator2 last2,
                                 OutputIterator result);
    template<class InputIterator1, class InputIterator2, class OutputIterator,
             class Compare>
        OutputIterator set_union(InputIterator1 first1, InputIterator1 last1,
                                 InputIterator2 first2, InputIterator2 last2,
                                 OutputIterator result, Compare comp);
 
    template<class InputIterator1, class InputIterator2, class OutputIterator>
        OutputIterator set_intersection(
            InputIterator1 first1, InputIterator1 last1,
            InputIterator2 first2, InputIterator2 last2,
            OutputIterator result);
    template<class InputIterator1, class InputIterator2, class OutputIterator,
             class Compare>
        OutputIterator set_intersection(
            InputIterator1 first1, InputIterator1 last1,
            InputIterator2 first2, InputIterator2 last2,
            OutputIterator result, Compare comp);
 
    template<class InputIterator1, class InputIterator2, class OutputIterator>
        OutputIterator set_difference(
            InputIterator1 first1, InputIterator1 last1,
            InputIterator2 first2, InputIterator2 last2,
            OutputIterator result);
    template<class InputIterator1, class InputIterator2, class OutputIterator,
             class Compare>
        OutputIterator set_difference(
            InputIterator1 first1, InputIterator1 last1,
            InputIterator2 first2, InputIterator2 last2,
            OutputIterator result, Compare comp);
 
    template<class InputIterator1, class InputIterator2, class OutputIterator>
        OutputIterator set_symmetric_difference(
            InputIterator1 first1, InputIterator1 last1,
            InputIterator2 first2, InputIterator2 last2,
            OutputIterator result);
    template<class InputIterator1, class InputIterator2, class OutputIterator,
             class Compare>
        OutputIterator set_symmetric_difference(
            InputIterator1 first1, InputIterator1 last1,
            InputIterator2 first2, InputIterator2 last2,
            OutputIterator result, Compare comp);
 
    // heap operations:
    template<class RandomAccessIterator>
        void push_heap(RandomAccessIterator first, RandomAccessIterator last);
    template<class RandomAccessIterator, class Compare>
        void push_heap(RandomAccessIterator first, RandomAccessIterator last,
                       Compare comp);
    template<class RandomAccessIterator>
        void pop_heap(RandomAccessIterator first, RandomAccessIterator last);
    template<class RandomAccessIterator, class Compare>
        void pop_heap(RandomAccessIterator first, RandomAccessIterator last,
                      Compare comp);
 
    template<class RandomAccessIterator>
        void make_heap(RandomAccessIterator first, RandomAccessIterator last);
    template<class RandomAccessIterator, class Compare>
        void make_heap(RandomAccessIterator first, RandomAccessIterator last,
                       Compare comp);
 
    template<class RandomAccessIterator>
        void sort_heap(RandomAccessIterator first, RandomAccessIterator last);
    template<class RandomAccessIterator, class Compare>
        void sort_heap(RandomAccessIterator first, RandomAccessIterator last,
                       Compare comp);
 
    template<class RandomAccessIterator>
        bool is_heap(RandomAccessIterator first, RandomAccessIterator last);
    template<class RandomAccessIterator, class Compare>
        bool is_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp);
    template<class RandomAccessIterator>
        RandomAccessIterator is_heap_until(RandomAccessIterator first, RandomAccessIterator last);
    template<class RandomAccessIterator, class Compare>
        RandomAccessIterator is_heap_until(RandomAccessIterator first, RandomAccessIterator last,
                                           Compare comp);
    // minimum and maximum:
    template<class T> const T& min(const T& a, const T& b);
    template<class T, class Compare>
        const T& min(const T& a, const T& b, Compare comp);
    template<class T>
        T min(initializer_list<T> t);
    template<class T, class Compare>
        T min(initializer_list<T> t, Compare comp);
 
    template<class T> const T& max(const T& a, const T& b);
    template<class T, class Compare>
        const T& max(const T& a, const T& b, Compare comp);
    template<class T>
        T max(initializer_list<T> t);
    template<class T, class Compare>
        T max(initializer_list<T> t, Compare comp);
 
    template<class T> pair<const T&, const T&> minmax(const T& a, const T& b);
    template<class T, class Compare>
        pair<const T&, const T&> minmax(const T& a, const T& b, Compare comp);
    template<class T>
        pair<T, T> minmax(initializer_list<T> t);
    template<class T, class Compare>
        pair<T, T> minmax(initializer_list<T> t, Compare comp);
 
    template<class ForwardIterator>
        ForwardIterator min_element(ForwardIterator first, ForwardIterator last);
    template<class ForwardIterator, class Compare>
        ForwardIterator min_element(ForwardIterator first, ForwardIterator last,
                                    Compare comp);
 
    template<class ForwardIterator>
        ForwardIterator max_element(ForwardIterator first, ForwardIterator last);
    template<class ForwardIterator, class Compare>
        ForwardIterator max_element(ForwardIterator first, ForwardIterator last,
                                    Compare comp);
 
    template<class ForwardIterator>
        pair<ForwardIterator, ForwardIterator>
        minmax_element(ForwardIterator first, ForwardIterator last);
    template<class ForwardIterator, class Compare>
        pair<ForwardIterator, ForwardIterator>
        minmax_element(ForwardIterator first, ForwardIterator last, Compare comp);
 
    template<class InputIterator1, class InputIterator2>
        bool lexicographical_compare(
            InputIterator1 first1, InputIterator1 last1,
            InputIterator2 first2, InputIterator2 last2);
    template<class InputIterator1, class InputIterator2, class Compare>
        bool lexicographical_compare(
            InputIterator1 first1, InputIterator1 last1,
            InputIterator2 first2, InputIterator2 last2,
            Compare comp);
 
    // permutations:
    template<class BidirectionalIterator>
        bool next_permutation(BidirectionalIterator first,
                              BidirectionalIterator last);
    template<class BidirectionalIterator, class Compare>
        bool next_permutation(BidirectionalIterator first,
                              BidirectionalIterator last, Compare comp);
 
    template<class BidirectionalIterator>
        bool prev_permutation(BidirectionalIterator first,
                              BidirectionalIterator last);
    template<class BidirectionalIterator, class Compare>
        bool prev_permutation(BidirectionalIterator first,
                              BidirectionalIterator last, Compare comp);
}