Заголовочный файл стандартной библиотеки <algorithm>

 

C++

Поддержка компилятором

Автономные и размещённые реализации

Язык

Стандартная библиотека

Заголовки стандартной библиотеки

Требования к именованию

Макросы тестирования функциональности (C++20)

Поддержка языка

Библиотека концептов (C++20)

Библиотека метапрограммирования (C++11)

Библиотека диагностики

Библиотека общих утилит

Библиотека строк

Библиотека контейнеров

Библиотека итераторов

Библиотека диапазонов (C++20)

Библиотека алгоритмов

Библиотека численных данных

Библиотека ввода/вывода

Библиотека локализаций

Регулярные выражения (C++11)

Атомарные операции (C++11)

Библиотека поддержки конкуренции (C++11)

Библиотека файловой системы (C++17)

Технические спецификации

Указатель символов

Внешние библиотеки

 

Заголовочные файлы стандартной библиотеки

Языковая поддержка
<cstddef> <cstdlib> <version> (C++20) <limits> <climits>	<cfloat> <cstdint> (C++11) <stdfloat> (C++23) <new> <typeinfo>	<source_location> (C++20) <exception> <initializer_list> (C++11) <compare> (C++20)	<coroutine> (C++20) <csignal> <csetjmp> <cstdarg>
Концепты
<concepts> (C++20)
Диагностика
<stdexcept> <stacktrace> (C++23)	<cassert>	<cerrno>	<system_error> (C++11)
Управление памятью
<memory>	<memory_resource> (C++17)	<scoped_allocator> (C++11)
Метапрограммирование
<type_traits> (C++11)	<ratio> (C++11)
Общие утилиты
<utility> <tuple> (C++11) <optional> (C++17) <variant> (C++17)	<any> (C++17) <expected> (C++23) <bitset>	<functional> <typeindex> (C++11) <execution> (C++17)	<charconv> (C++17) <format> (C++20) <bit> (C++20)
Строки
<string_view> (C++17) <string>	<cctype> <cwctype>	<cstring> <cwchar>	<cuchar> (C++11)
Контейнеры
<array> (C++11) <deque> <forward_list> (C++11) <list>	<vector> <map> <set> <unordered_map> (C++11)	<unordered_set> (C++11) <queue> <stack> <flat_map> (C++23)	<flat_set> (C++23) <span> (C++20) <mdspan> (C++23)
Итераторы
<iterator>
Диапазоны
<ranges> (C++20)	<generator> (C++23)
Алгоритмы
<algorithm>	<numeric>
Числа
<cfenv> (C++11) <complex>	<random> (C++11) <valarray>	<cmath>	<numbers> (C++20)
Время
<chrono> (C++11)	<ctime>
Локализация
<locale>	<clocale>	<codecvt> (C++11/17*)
Ввод/вывод
<iosfwd> <iostream> <ios> <streambuf>	<istream> <ostream> <iomanip> <print> (C++23)	<sstream> <spanstream> (C++23) <fstream> <syncstream> (C++20)	<filesystem> (C++17) <cstdio> <cinttypes> (C++11) <strstream> (C++98*)
Регулярные выражения
<regex> (C++11)
Поддержка конкуренции
<stop_token> (C++20) <thread> (C++11) <atomic> (C++11)	<stdatomic.h> (C++23) <mutex> (C++11) <shared_mutex> (C++14)	<condition_variable> (C++11)   <semaphore> (C++20) <latch> (C++20)	<barrier> (C++20) <future> (C++11)
Совместимость с C
<cstdbool> (C++11/17/20*)   <ccomplex> (C++11/17/20*)	<ctgmath> (C++11/17/20*)	<cstdalign> (C++11/17/20*)	<ciso646> (до C++20)

 

See More

Этот заголовочный файл является частью библиотеки algorithm.

Функции

Немодифицирующие операции над последовательностями
all_ofany_ofnone_of (C++11)(C++11)(C++11)	проверяет, равен ли предикат true для всех, любого или ни одного из элементов в диапазоне (шаблон функции)
for_each	применяет функцию к диапазону элементов (шаблон функции)
for_each_n (C++17)	применяет объект функцию к первым n элементам последовательности (шаблон функции)
countcount_if	возвращает количество элементов, соответствующих определённым критериям (шаблон функции)
mismatch	находит первую позицию, в которой два диапазона различаются (шаблон функции)
equal	определяет, одинаковы ли два множества элементов (шаблон функции)
findfind_iffind_if_not (C++11)	находит первый элемент, соответствущий определённым критериям (шаблон функции)
find_end	находит последнюю последовательность элементов в определённом диапазоне (шаблон функции)
find_first_of	ищет любой элемент из набора элементов (шаблон функции)
adjacent_find	находит первые два соседних элемента, которые равны (или удовлетворяют заданному предикату) (шаблон функции)
search	ищет диапазон элементов (шаблон функции)
search_n	ищет несколько последовательных копий элемента в диапазоне (шаблон функции)
Модифицирующие операции над последовательностями
copycopy_if (C++11)	копирует диапазон элементов в новое место (шаблон функции)
copy_n (C++11)	копирует ряд элементов в новое место (шаблон функции)
copy_backward	копирует диапазон элементов в обратном порядке (шаблон функции)
move (C++11)	перемещает диапазон элементов в новое место (шаблон функции)
move_backward (C++11)	перемещает диапазон элементов в новое место в обратном порядке (шаблон функции)
fill	присваивает диапазону элементов определённое значение (шаблон функции)
fill_n	присваивает значение определённому количеству элементов (шаблон функции)
transform	применяет функцию к диапазону элементов, сохраняя результаты в целевом диапазоне (шаблон функции)
generate	присваивает результаты последовательных вызовов функции каждому элементу в диапазоне (шаблон функции)
generate_n	присваивает результаты последовательных вызовов функции N элементам в диапазоне (шаблон функции)
removeremove_if	удаляет элементы, соответствующие определённым критериям (шаблон функции)
remove_copyremove_copy_if	копирует диапазон элементов, исключая те, которые соответствуют определённым критериям (шаблон функции)
replacereplace_if	заменяет другим значением все значения, соответствующие определённым критериям (шаблон функции)
replace_copyreplace_copy_if	копирует диапазон, заменяя элементы, соответствующие определённым критериям, другим значением (шаблон функции)
swap	меняет местами значения двух объектов (шаблон функции)
swap_ranges	меняет местами два диапазона элементов (шаблон функции)
iter_swap	меняет местами элементы, на которые указывают два итератора (шаблон функции)
reverse	меняет порядок элементов в диапазоне на обратный (шаблон функции)
reverse_copy	создаёт перевёрнутую копию диапазона (шаблон функции)
rotate	вращает порядок элементов в диапазоне (шаблон функции)
rotate_copy	копирует и вращает диапазон элементов (шаблон функции)
random_shuffleshuffle (до C++17)(C++11)	случайным образом переупорядочивает элементы в диапазоне (шаблон функции)
unique	удаляет последовательные повторяющиеся элементы в диапазоне (шаблон функции)
unique_copy	создает копию некоторого диапазона элементов, не содержащую последовательных дубликатов (шаблон функции)
Операции разделения
is_partitioned (C++11)	определяет, разделён ли диапазон заданным предикатом (шаблон функции)
partition	делит диапазон элементов на две группы (шаблон функции)
partition_copy (C++11)	копирует диапазон, разделяя элементы на две группы (шаблон функции)
stable_partition	делит элементы на две группы с сохранением их относительного порядка (шаблон функции)
partition_point (C++11)	находит точку раздела разделённого на две группы диапазона (шаблон функции)
Операции сортировки
is_sorted (C++11)	проверяет, отсортирован ли диапазон по возрастанию (шаблон функции)
is_sorted_until (C++11)	находит наиболее длинный отсортированный префиксный поддиапазон (шаблон функции)
sort	сортирует диапазон в порядке возрастания (шаблон функции)
partial_sort	сортирует первые N элементов диапазона (шаблон функции)
partial_sort_copy	копирует и частично сортирует диапазон элементов (шаблон функции)
stable_sort	сортирует диапазон элементов, сохраняя порядок между равными элементами (шаблон функции)
nth_element	частично сортирует заданный диапазон, убедившись, что он разделён заданным элементом (шаблон функции)
Операции двоичного поиска (на отсортированных диапазонах)
lower_bound	возвращает итератор на первый элемент не меньший, чем заданное значение (шаблон функции)
upper_bound	возвращает итератор на первый элемент, который больше определённого значения (шаблон функции)
binary_search	определяет, существует ли элемент в частично упорядоченном диапазоне (шаблон функции)
equal_range	возвращает диапазон элементов, соответствующих определённому ключу (шаблон функции)
Прочие операции на отсортированных диапазонах
merge	объединяет два отсортированных диапазона (шаблон функции)
inplace_merge	объединяет два упорядоченных диапазона на месте (шаблон функции)
Операции для множеств (на отсортированных диапазонах)
includes	возвращает true, если одна последовательность является подпоследовательностью другой (шаблон функции)
set_difference	вычисляет разницу между двумя наборами (шаблон функции)
set_intersection	вычисляет пересечение двух множеств (шаблон функции)
set_symmetric_difference	вычисляет симметричную разницу между двумя наборами (шаблон функции)
set_union	вычисляет объединение двух множеств (шаблон функции)
Операции над кучей
is_heap	проверяет, является ли указанный диапазон максимальной кучей (шаблон функции)
is_heap_until (C++11)	находит самый большой поддиапазон, который составляет максимальную кучу (шаблон функции)
make_heap	создаёт максимальную кучу из диапазона элементов (шаблон функции)
push_heap	добавляет элемент в максимальную кучу (шаблон функции)
pop_heap	удаляет наибольший элемент из максимальной кучи (шаблон функции)
sort_heap	превращает максимальную кучу в диапазон элементов, отсортированных в порядке возрастания (шаблон функции)
Операции минимума/максимума
max	возвращает большее из заданных значений (шаблон функции)
max_element	возвращает наибольший элемент в диапазоне (шаблон функции)
min	возвращает меньшее из заданных значений (шаблон функции)
min_element	возвращает наименьший элемент в диапазоне (шаблон функции)
minmax (C++11)	возвращает меньший и больший из двух элементов (шаблон функции)
minmax_element (C++11)	возвращает наименьший и наибольший элементы в диапазоне (шаблон функции)
clamp (C++17)	приводит значение к диапазону между парой граничных значений (шаблон функции)
Операции сравнения
equal	определяет, одинаковы ли два множества элементов (шаблон функции)
lexicographical_compare	возвращает true, если один диапазон лексикографически меньше другого (шаблон функции)
lexicographical_compare_three_way (C++20)	сравнивает два диапазона, используя трёхстороннее сравнение (шаблон функции)
Операции перестановки
is_permutation (C++11)	определяет, является ли последовательность перестановкой другой последовательности (шаблон функции)
next_permutation	генерирует следующую большую лексикографическую перестановку диапазона элементов (шаблон функции)
prev_permutation	генерирует следующую меньшую лексикографическую перестановку диапазона элементов (шаблон функции)

Определение

#include <initializer_list>

namespace std {
    // немодифицирующие операции над последовательностями
    template <class InputIter, class Pred>
        bool all_of(InputIter first, InputIter last, Pred pred);
    template <class InputIter, class Pred>
        bool any_of(InputIter first, InputIter last, Pred pred);
    template <class InputIter, class Pred>
        bool none_of(InputIter first, InputIter last, Pred pred);

    template<class InputIter, class Function>
        Function for_each(InputIter first, InputIter last, Function f);
    template<class InputIter, class Size, class Function>
        InputIter for_each_n(InputIter first, Size n, Function f);

    template<class InputIter, class T>
        InputIter find(InputIter first, InputIter last,
                           const T& value);
    template<class InputIter, class Pred>
        InputIter find_if(InputIter first, InputIter last,
                              Pred pred);
    template<class InputIter, class Pred>
        InputIter find_if_not(InputIter first, InputIter last,
                                  Pred pred);

    template<class ForwardIter1, class ForwardIter2>
        ForwardIter1
        find_end(ForwardIter1 first1, ForwardIter1 last1,
                 ForwardIter2 first2, ForwardIter2 last2);
    template<class ForwardIter1, class ForwardIter2,
             class BinaryPred>
        ForwardIter1
        find_end(ForwardIter1 first1, ForwardIter1 last1,
                 ForwardIter2 first2, ForwardIter2 last2,
                 BinaryPred pred);

    template<class InputIter, class ForwardIter>
        InputIter
        find_first_of(InputIter first1, InputIter last1,
                      ForwardIter first2, ForwardIter last2);
    template<class InputIter, class ForwardIter,
             class BinaryPred>
        InputIter
        find_first_of(InputIter first1, InputIter last1,
                      ForwardIter first2, ForwardIter last2,
                      BinaryPred pred);

    template<class ForwardIter>
        ForwardIter adjacent_find(ForwardIter first,
                                      ForwardIter last);
    template<class ForwardIter, class BinaryPred>
        ForwardIter adjacent_find(ForwardIter first,
                                      ForwardIter last,
                                      BinaryPred pred);
    template<class InputIter, class T>
        typename iterator_traits<InputIter>::difference_type
        count(InputIter first, InputIter last, const T& value);
    template<class InputIter, class Pred>
        typename iterator_traits<InputIter>::difference_type
        count_if(InputIter first, InputIter last, Pred pred);

    template<class InputIter1, class InputIter2>
        pair<InputIter1, InputIter2>
        mismatch(InputIter1 first1, InputIter1 last1,
                 InputIter2 first2);
    template<class InputIter1, class InputIter2, class BinaryPred>
        pair<InputIter1, InputIter2>
        mismatch(InputIter1 first1, InputIter1 last1,
                 InputIter2 first2, BinaryPred pred);

    template<class InputIter1, class InputIter2>
        bool equal(InputIter1 first1, InputIter1 last1,
                   InputIter2 first2);
    template<class InputIter1, class InputIter2, class BinaryPred>
        bool equal(InputIter1 first1, InputIter1 last1,
                   InputIter2 first2, BinaryPred pred);

    template<class ForwardIter1, class ForwardIter2>
        bool is_permutation(ForwardIter1 first1, ForwardIter1 last1,
                            ForwardIter2 first2);
    template<class ForwardIter1, class ForwardIter2,
    class BinaryPred>
        bool is_permutation(ForwardIter1 first1, ForwardIter1 last1,
                            ForwardIter2 first2, BinaryPred pred);

    template<class ForwardIter1, class ForwardIter2>
        ForwardIter1 search(
            ForwardIter1 first1, ForwardIter1 last1,
            ForwardIter2 first2, ForwardIter2 last2);
    template<class ForwardIter1, class ForwardIter2,
             class BinaryPred>
        ForwardIter1 search(
            ForwardIter1 first1, ForwardIter1 last1,
            ForwardIter2 first2, ForwardIter2 last2,
            BinaryPred pred);

    template<class ForwardIter, class Size, class T>
        ForwardIter search_n(ForwardIter first, ForwardIter last,
                                 Size count, const T& value);
    template<class ForwardIter, class Size, class T, class BinaryPred>
        ForwardIter1 search_n(ForwardIter first, ForwardIter last,
                                  Size count, const T& value,
                                  BinaryPred pred);

    // модифицирующие операции над последовательностями

    // копирование
    template<class InputIter, class OutputIter>
        OutputIter copy(InputIter first, InputIter last,
                            OutputIter result);
    template<class InputIter, class Size, class OutputIter>
        OutputIter copy_n(InputIter first, Size n,
                              OutputIter result);
    template<class InputIter, class OutputIter, class Pred>
        OutputIter copy_if(InputIter first, InputIter last,
                               OutputIter result, Pred pred);
    template<class BidirectionalIter1, class BidirectionalIter2>
        BidirectionalIter2 copy_backward(
            BidirectionalIter1 first, BidirectionalIter1 last,
            BidirectionalIter2 result);

    // перемещение
    template<class InputIter, class OutputIter>
        OutputIter move(InputIter first, InputIter last,
                            OutputIter result);
    template<class BidirectionalIter1, class BidirectionalIter2>
        BidirectionalIter2 move_backward(
            BidirectionalIter1 first, BidirectionalIter1 last,
            BidirectionalIter2 result);

    // обмен
    template<class ForwardIter1, class ForwardIter2>
        ForwardIter2 swap_ranges(ForwardIter1 first1,
                                     ForwardIter1 last1, ForwardIter2 first2);
    template<class ForwardIter1, class ForwardIter2>
        void iter_swap(ForwardIter1 a, ForwardIter2 b);
    template<class InputIter, class OutputIter, class UnaryOperation>
        OutputIter transform(InputIter first, InputIter last,
                                 OutputIter result, UnaryOperation op);

    template<class InputIter1, class InputIter2, class OutputIter,
             class BinaryOperation>
        OutputIter transform(InputIter1 first1, InputIter1 last1,
                                 InputIter2 first2, OutputIter result,
                                 BinaryOperation binary_op);

    template<class ForwardIter, class T>
        void replace(ForwardIter first, ForwardIter last,
                     const T& old_value, const T& new_value);
    template<class ForwardIter, class Pred, class T>
        void replace_if(ForwardIter first, ForwardIter last,
                        Pred pred, const T& new_value);
    template<class InputIter, class OutputIter, class T>
        OutputIter replace_copy(InputIter first, InputIter last,
                                    OutputIter result,
                                    const T& old_value, const T& new_value);
    template<class InputIter, class OutputIter, class Pred, class T>
        OutputIter replace_copy_if(InputIter first, InputIter last,
                                       OutputIter result,
                                       Pred pred, const T& new_value);

    template<class ForwardIter, class T>
        void fill(ForwardIter first, ForwardIter last, const T& value);
    template<class OutputIter, class Size, class T>
        OutputIter fill_n(OutputIter first, Size n, const T& value);
    template<class ForwardIter, class Generator>
        void generate(ForwardIter first, ForwardIter last,
                      Generator gen);
    template<class OutputIter, class Size, class Generator>
        OutputIter generate_n(OutputIter first, Size n, Generator gen);

    template<class ForwardIter, class T>
        ForwardIter remove(ForwardIter first, ForwardIter last,
                               const T& value);
    template<class ForwardIter, class Pred>
        ForwardIter remove_if(ForwardIter first, ForwardIter last,
                                  Pred pred);
    template<class InputIter, class OutputIter, class T>
        OutputIter remove_copy(InputIter first, InputIter last,
                                   OutputIter result, const T& value);
    template<class InputIter, class OutputIter, class Pred>
        OutputIter remove_copy_if(InputIter first, InputIter last,
                                      OutputIter result, Pred pred);

    template<class ForwardIter>
        ForwardIter unique(ForwardIter first, ForwardIter last);
    template<class ForwardIter, class BinaryPred>
        ForwardIter unique(ForwardIter first, ForwardIter last,
                               BinaryPred pred);
    template<class InputIter, class OutputIter>
        OutputIter unique_copy(InputIter first, InputIter last,
                                   OutputIter result);
    template<class InputIter, class OutputIter, class BinaryPred>
        OutputIter unique_copy(InputIter first, InputIter last,
                                   OutputIter result, BinaryPred pred);

    template<class BidirectionalIter>
        void reverse(BidirectionalIter first, BidirectionalIter last);
    template<class BidirectionalIter, class OutputIter>
        OutputIter reverse_copy(BidirectionalIter first,
                                    BidirectionalIter last,
                                    OutputIter result);

    template<class ForwardIter>
        ForwardIter rotate(ForwardIter first, ForwardIter middle,
                               ForwardIter last);
    template<class ForwardIter, class OutputIter>
        OutputIter rotate_copy(
            ForwardIter first, ForwardIter middle,
            ForwardIter last, OutputIter result);

    template<class RandomAccessIter>
        void random_shuffle(RandomAccessIter first,
                            RandomAccessIter last);
    template<class RandomAccessIter, class RandomNumberGenerator>
        void random_shuffle(RandomAccessIter first,
                            RandomAccessIter last,
                            RandomNumberGenerator&& rand);
    template<class RandomAccessIter, class UniformRandomNumberGenerator>
        void shuffle(RandomAccessIter first,
                     RandomAccessIter last,
                     UniformRandomNumberGenerator&& rand);

    // разделение
    template <class InputIter, class Pred>
        bool is_partitioned(InputIter first, InputIter last, Pred pred);

    template<class ForwardIter, class Pred>
        ForwardIter partition(ForwardIter first,
                                  ForwardIter last,
                                  Pred pred);

    template<class BidirectionalIter, class Pred>
        BidirectionalIter stable_partition(BidirectionalIter first,
                                               BidirectionalIter last,
                                               Pred pred);

    template <class InputIter, class OutputIter1,
              class OutputIter2, class Pred>
        pair<OutputIter1, OutputIter2>
        partition_copy(InputIter first, InputIter last,
                       OutputIter1 out_true, OutputIter2 out_false,
                       Pred pred);

    template<class ForwardIter, class Pred>
        ForwardIter partition_point(ForwardIter first,
                                        ForwardIter last,
                                        Pred pred);

    // операции сортировки и связанные

    // сортировка
    template<class RandomAccessIter>
        void sort(RandomAccessIter first, RandomAccessIter last);
    template<class RandomAccessIter, class Compare>
        void sort(RandomAccessIter first, RandomAccessIter last,
                  Compare comp);

    template<class RandomAccessIter>
        void stable_sort(RandomAccessIter first, RandomAccessIter last);
    template<class RandomAccessIter, class Compare>
        void stable_sort(RandomAccessIter first, RandomAccessIter last,
                         Compare comp);

    template<class RandomAccessIter>
        void partial_sort(RandomAccessIter first,
                          RandomAccessIter middle,
                          RandomAccessIter last);
    template<class RandomAccessIter, class Compare>
        void partial_sort(RandomAccessIter first,
                          RandomAccessIter middle,
                          RandomAccessIter last, Compare comp);
    template<class InputIter, class RandomAccessIter>
        RandomAccessIter partial_sort_copy(
            InputIter first, InputIter last,
            RandomAccessIter result_first,
            RandomAccessIter result_last);
    template<class InputIter, class RandomAccessIter, class Compare>
        RandomAccessIter partial_sort_copy(
            InputIter first, InputIter last,
            RandomAccessIter result_first,
            RandomAccessIter result_last,
            Compare comp);

    template<class ForwardIter>
        bool is_sorted(ForwardIter first, ForwardIter last);
    template<class ForwardIter, class Compare>
        bool is_sorted(ForwardIter first, ForwardIter last,
                       Compare comp);
    template<class ForwardIter>
        ForwardIter is_sorted_until(ForwardIter first, ForwardIter last);
    template<class ForwardIter, class Compare>
        ForwardIter is_sorted_until(ForwardIter first, ForwardIter last,
                                        Compare comp);

    template<class RandomAccessIter>
        void nth_element(RandomAccessIter first, RandomAccessIter nth,
                         RandomAccessIter last);
    template<class RandomAccessIter, class Compare>
        void nth_element(RandomAccessIter first, RandomAccessIter nth,
                         RandomAccessIter last, Compare comp);

    // бинарный поиск
    template<class ForwardIter, class T>
        ForwardIter lower_bound(ForwardIter first, ForwardIter last,
                                    const T& value);
    template<class ForwardIter, class T, class Compare>
        ForwardIter lower_bound(ForwardIter first, ForwardIter last,
                                    const T& value, Compare comp);

    template<class ForwardIter, class T>
        ForwardIter upper_bound(ForwardIter first, ForwardIter last,
                                    const T& value);
    template<class ForwardIter, class T, class Compare>
        ForwardIter upper_bound(ForwardIter first, ForwardIter last,
                                    const T& value, Compare comp);

    template<class ForwardIter, class T>
        pair<ForwardIter, ForwardIter>
        equal_range(ForwardIter first, ForwardIter last,
                    const T& value);
    template<class ForwardIter, class T, class Compare>
        pair<ForwardIter, ForwardIter>
        equal_range(ForwardIter first, ForwardIter last,
                    const T& value, Compare comp);

    template<class ForwardIter, class T>
        bool binary_search(ForwardIter first, ForwardIter last,
                           const T& value);
    template<class ForwardIter, class T, class Compare>
        bool binary_search(ForwardIter first, ForwardIter last,
                           const T& value, Compare comp);

    // слияние
    template<class InputIter1, class InputIter2, class OutputIter>
        OutputIter merge(InputIter1 first1, InputIter1 last1,
                             InputIter2 first2, InputIter2 last2,
                             OutputIter result);
    template<class InputIter1, class InputIter2, class OutputIter,
            class Compare>
        OutputIter merge(InputIter1 first1, InputIter1 last1,
                             InputIter2 first2, InputIter2 last2,
                             OutputIter result, Compare comp);

    template<class BidirectionalIter>
        void inplace_merge(BidirectionalIter first,
                           BidirectionalIter middle,
                           BidirectionalIter last);
    template<class BidirectionalIter, class Compare>
        void inplace_merge(BidirectionalIter first,
                           BidirectionalIter middle,
                           BidirectionalIter last, Compare comp);

    // операции над множествами
    template<class InputIter1, class InputIter2>
        bool includes(InputIter1 first1, InputIter1 last1,
                      InputIter2 first2, InputIter2 last2);
    template<class InputIter1, class InputIter2, class Compare>
        bool includes(
            InputIter1 first1, InputIter1 last1,
            InputIter2 first2, InputIter2 last2, Compare comp);

    template<class InputIter1, class InputIter2, class OutputIter>
        OutputIter set_union(InputIter1 first1, InputIter1 last1,
                                 InputIter2 first2, InputIter2 last2,
                                 OutputIter result);
    template<class InputIter1, class InputIter2, class OutputIter,
             class Compare>
        OutputIter set_union(InputIter1 first1, InputIter1 last1,
                                 InputIter2 first2, InputIter2 last2,
                                 OutputIter result, Compare comp);

    template<class InputIter1, class InputIter2, class OutputIter>
        OutputIter set_intersection(
            InputIter1 first1, InputIter1 last1,
            InputIter2 first2, InputIter2 last2,
            OutputIter result);
    template<class InputIter1, class InputIter2, class OutputIter,
             class Compare>
        OutputIter set_intersection(
            InputIter1 first1, InputIter1 last1,
            InputIter2 first2, InputIter2 last2,
            OutputIter result, Compare comp);

    template<class InputIter1, class InputIter2, class OutputIter>
        OutputIter set_difference(
            InputIter1 first1, InputIter1 last1,
            InputIter2 first2, InputIter2 last2,
            OutputIter result);
    template<class InputIter1, class InputIter2, class OutputIter,
             class Compare>
        OutputIter set_difference(
            InputIter1 first1, InputIter1 last1,
            InputIter2 first2, InputIter2 last2,
            OutputIter result, Compare comp);

    template<class InputIter1, class InputIter2, class OutputIter>
        OutputIter set_symmetric_difference(
            InputIter1 first1, InputIter1 last1,
            InputIter2 first2, InputIter2 last2,
            OutputIter result);
    template<class InputIter1, class InputIter2, class OutputIter,
             class Compare>
        OutputIter set_symmetric_difference(
            InputIter1 first1, InputIter1 last1,
            InputIter2 first2, InputIter2 last2,
            OutputIter result, Compare comp);

    // операции над кучей
    template<class RandomAccessIter>
        void push_heap(RandomAccessIter first, RandomAccessIter last);
    template<class RandomAccessIter, class Compare>
        void push_heap(RandomAccessIter first, RandomAccessIter last,
                       Compare comp);
    template<class RandomAccessIter>
        void pop_heap(RandomAccessIter first, RandomAccessIter last);
    template<class RandomAccessIter, class Compare>
        void pop_heap(RandomAccessIter first, RandomAccessIter last,
                      Compare comp);

    template<class RandomAccessIter>
        void make_heap(RandomAccessIter first, RandomAccessIter last);
    template<class RandomAccessIter, class Compare>
        void make_heap(RandomAccessIter first, RandomAccessIter last,
                       Compare comp);

    template<class RandomAccessIter>
        void sort_heap(RandomAccessIter first, RandomAccessIter last);
    template<class RandomAccessIter, class Compare>
        void sort_heap(RandomAccessIter first, RandomAccessIter last,
                       Compare comp);

    template<class RandomAccessIter>
        bool is_heap(RandomAccessIter first, RandomAccessIter last);
    template<class RandomAccessIter, class Compare>
        bool is_heap(RandomAccessIter first, RandomAccessIter last, Compare comp);
    template<class RandomAccessIter>
        RandomAccessIter
            is_heap_until(RandomAccessIter first, RandomAccessIter last);
    template<class RandomAccessIter, class Compare>
        RandomAccessIter
            is_heap_until(RandomAccessIter first, RandomAccessIter last,
                                           Compare comp);

    // минимум и максимум
    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 ForwardIter>
        ForwardIter min_element(ForwardIter first, ForwardIter last);
    template<class ForwardIter, class Compare>
        ForwardIter min_element(ForwardIter first, ForwardIter last,
                                    Compare comp);

    template<class ForwardIter>
        ForwardIter max_element(ForwardIter first, ForwardIter last);
    template<class ForwardIter, class Compare>
        ForwardIter max_element(ForwardIter first, ForwardIter last,
                                    Compare comp);

    template<class ForwardIter>
        pair<ForwardIter, ForwardIter>
        minmax_element(ForwardIter first, ForwardIter last);
    template<class ForwardIter, class Compare>
        pair<ForwardIter, ForwardIter>
        minmax_element(ForwardIter first, ForwardIter last, Compare comp);

    template<class InputIter1, class InputIter2>
        bool lexicographical_compare(
            InputIter1 first1, InputIter1 last1,
            InputIter2 first2, InputIter2 last2);
    template<class InputIter1, class InputIter2, class Compare>
        bool lexicographical_compare(
            InputIter1 first1, InputIter1 last1,
            InputIter2 first2, InputIter2 last2,
            Compare comp);

    // перестановки
    template<class BidirectionalIter>
        bool next_permutation(BidirectionalIter first,
                              BidirectionalIter last);
    template<class BidirectionalIter, class Compare>
        bool next_permutation(BidirectionalIter first,
                              BidirectionalIter last, Compare comp);

    template<class BidirectionalIter>
        bool prev_permutation(BidirectionalIter first,
                              BidirectionalIter last);
    template<class BidirectionalIter, class Compare>
        bool prev_permutation(BidirectionalIter first,
                              BidirectionalIter last, Compare comp);
}