Namespaces
Variants
Views
Actions

Standard library header <algorithm>

From cppreference.com
< cpp‎ | header

This header is part of the algorithm library.

Contents

[edit] Functions

Non-modifying sequence operations
(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) [edit]
applies a function to a range of elements
(function template) [edit]
returns the number of elements satisfying specific criteria
(function template) [edit]
finds the first position where two ranges differ
(function template) [edit]
determines if two sets of elements are the same
(function template) [edit]
finds the first element satisfying specific criteria
(function template) [edit]
finds the last sequence of elements in a certain range
(function template) [edit]
searches for any one of a set of elements
(function template) [edit]
finds the first two adjacent items that are equal (or satisfy a given predicate)
(function template) [edit]
searches for a range of elements
(function template) [edit]
searches for a number consecutive copies of an element in a range
(function template) [edit]
Modifying sequence operations
copies a range of elements to a new location
(function template) [edit]
(C++11)
copies a number of elements to a new location
(function template) [edit]
copies a range of elements in backwards order
(function template) [edit]
(C++11)
moves a range of elements to a new location
(function template) [edit]
moves a range of elements to a new location in backwards order
(function template) [edit]
assigns a range of elements a certain value
(function template) [edit]
assigns a value to a number of elements
(function template) [edit]
applies a function to a range of elements
(function template) [edit]
saves the result of a function in a range
(function template) [edit]
saves the result of N applications of a function
(function template) [edit]
removes elements satisfying specific criteria
(function template) [edit]
copies a range of elements omitting those that satisfy specific criteria
(function template) [edit]
replaces all values satisfying specific criteria with another value
(function template) [edit]
copies a range, replacing elements satisfying specific criteria with another value
(function template) [edit]
swaps the values of two objects
(function template) [edit]
swaps two ranges of elements
(function template) [edit]
swaps the elements pointed to by two iterators
(function template) [edit]
reverses the order elements in a range
(function template) [edit]
creates a copy of a range that is reversed
(function template) [edit]
rotates the order of elements in a range
(function template) [edit]
copies and rotate a range of elements
(function template) [edit]
randomly re-orders elements in a range
(function template) [edit]
removes consecutive duplicate elements in a range
(function template) [edit]
creates a copy of some range of elements that contains no consecutive duplicates
(function template) [edit]
Partitioning operations
determines if the range is partitioned by the given predicate
(function template) [edit]
divides a range of elements into two groups
(function template) [edit]
copies a range dividing the elements into two groups
(function template) [edit]
divides elements into two groups while preserving their relative order
(function template) [edit]
locates the partition point of a partitioned range
(function template) [edit]
Sorting operations (on sorted ranges)
(C++11)
checks whether a range is sorted into ascending order
(function template) [edit]
finds the largest sorted subrange
(function template) [edit]
sorts a range into ascending order
(function template) [edit]
sorts the first N elements of a range
(function template) [edit]
copies and partially sorts a range of elements
(function template) [edit]
sorts a range of elements while preserving order between equal elements
(function template) [edit]
partially sorts the given range making sure that it is partitioned by the given element
(function template) [edit]
Binary search operations (on sorted ranges)
returns an iterator to the first element not less than the given value
(function template) [edit]
returns an iterator to the first element greater than a certain value
(function template) [edit]
determines if an element exists in a certain range
(function template) [edit]
returns range of elements matching a specific key
(function template) [edit]
Set operations (on sorted ranges)
merges two sorted ranges
(function template) [edit]
merges two ordered ranges in-place
(function template) [edit]
returns true if one set is a subset of another
(function template) [edit]
computes the difference between two sets
(function template) [edit]
computes the intersection of two sets
(function template) [edit]
computes the symmetric difference between two sets
(function template) [edit]
computes the union of two sets
(function template) [edit]
Heap operations
(C++11)
checks if the given range is a max heap
(function template) [edit]
finds the largest subrange that is a max heap
(function template) [edit]
creates a max heap out of a range of elements
(function template) [edit]
adds an element to a max heap
(function template) [edit]
removes the largest element from a max heap
(function template) [edit]
turns a max heap into a range of elements sorted in ascending order
(function template) [edit]
Minimum/maximum operations
returns the larger of two elements
(function template) [edit]
returns the largest element in a range
(function template) [edit]
returns the smaller of two elements
(function template) [edit]
returns the smallest element in a range
(function template) [edit]
(C++11)
returns the larger and the smaller of two elements
(function template) [edit]
returns the smallest and the largest element in a range
(function template) [edit]
returns true if one range is lexicographically less than another
(function template) [edit]
determines if a sequence is a permutation of another sequence
(function template) [edit]
generates the next greater lexicographic permutation of a range of elements
(function template) [edit]
generates the next smaller lexicographic permutation of a range of elements
(function template) [edit]

[edit] 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);
}