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

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