Этот заголовочный файл является частью библиотеки algorithm.
Функции
Немодифицирующие операции над последовательностями | |
(C++11)(C++11)(C++11) |
проверяет, равен ли предикат true для всех, любого или ни одного из элементов в диапазоне (шаблон функции) |
| применяет функцию к диапазону элементов (шаблон функции) | |
(C++17) |
применяет объект функцию к первым n элементам последовательности (шаблон функции) |
| возвращает количество элементов, соответствующих определённым критериям (шаблон функции) | |
| находит первую позицию, в которой два диапазона различаются (шаблон функции) | |
| определяет, одинаковы ли два множества элементов (шаблон функции) | |
(C++11) |
находит первый элемент, соответствущий определённым критериям (шаблон функции) |
| находит последнюю последовательность элементов в определённом диапазоне (шаблон функции) | |
| ищет любой элемент из набора элементов (шаблон функции) | |
| находит первые два соседних элемента, которые равны (или удовлетворяют заданному предикату) (шаблон функции) | |
| ищет диапазон элементов (шаблон функции) | |
| ищет несколько последовательных копий элемента в диапазоне (шаблон функции) | |
Модифицирующие операции над последовательностями | |
(C++11) |
копирует диапазон элементов в новое место (шаблон функции) |
(C++11) |
копирует ряд элементов в новое место (шаблон функции) |
| копирует диапазон элементов в обратном порядке (шаблон функции) | |
(C++11) |
перемещает диапазон элементов в новое место (шаблон функции) |
(C++11) |
перемещает диапазон элементов в новое место в обратном порядке (шаблон функции) |
| присваивает диапазону элементов определённое значение (шаблон функции) | |
| присваивает значение определённому количеству элементов (шаблон функции) | |
| применяет функцию к диапазону элементов, сохраняя результаты в целевом диапазоне (шаблон функции) | |
| присваивает результаты последовательных вызовов функции каждому элементу в диапазоне (шаблон функции) | |
| присваивает результаты последовательных вызовов функции N элементам в диапазоне (шаблон функции) | |
| удаляет элементы, соответствующие определённым критериям (шаблон функции) | |
| копирует диапазон элементов, исключая те, которые соответствуют определённым критериям (шаблон функции) | |
| заменяет другим значением все значения, соответствующие определённым критериям (шаблон функции) | |
| копирует диапазон, заменяя элементы, соответствующие определённым критериям, другим значением (шаблон функции) | |
| меняет местами значения двух объектов (шаблон функции) | |
| меняет местами два диапазона элементов (шаблон функции) | |
| меняет местами элементы, на которые указывают два итератора (шаблон функции) | |
| меняет порядок элементов в диапазоне на обратный (шаблон функции) | |
| создаёт перевёрнутую копию диапазона (шаблон функции) | |
| вращает порядок элементов в диапазоне (шаблон функции) | |
| копирует и вращает диапазон элементов (шаблон функции) | |
(до C++17)(C++11) |
случайным образом переупорядочивает элементы в диапазоне (шаблон функции) |
| удаляет последовательные повторяющиеся элементы в диапазоне (шаблон функции) | |
| создает копию некоторого диапазона элементов, не содержащую последовательных дубликатов (шаблон функции) | |
Операции разделения | |
(C++11) |
определяет, разделён ли диапазон заданным предикатом (шаблон функции) |
| делит диапазон элементов на две группы (шаблон функции) | |
(C++11) |
копирует диапазон, разделяя элементы на две группы (шаблон функции) |
| делит элементы на две группы с сохранением их относительного порядка (шаблон функции) | |
(C++11) |
находит точку раздела разделённого на две группы диапазона (шаблон функции) |
Операции сортировки | |
(C++11) |
проверяет, отсортирован ли диапазон по возрастанию (шаблон функции) |
(C++11) |
находит наиболее длинный отсортированный префиксный поддиапазон (шаблон функции) |
| сортирует диапазон в порядке возрастания (шаблон функции) | |
| сортирует первые N элементов диапазона (шаблон функции) | |
| копирует и частично сортирует диапазон элементов (шаблон функции) | |
| сортирует диапазон элементов, сохраняя порядок между равными элементами (шаблон функции) | |
| частично сортирует заданный диапазон, убедившись, что он разделён заданным элементом (шаблон функции) | |
Операции двоичного поиска (на отсортированных диапазонах) | |
| возвращает итератор на первый элемент не меньший, чем заданное значение (шаблон функции) | |
| возвращает итератор на первый элемент, который больше определённого значения (шаблон функции) | |
| определяет, существует ли элемент в частично упорядоченном диапазоне (шаблон функции) | |
| возвращает диапазон элементов, соответствующих определённому ключу (шаблон функции) | |
Прочие операции на отсортированных диапазонах | |
| объединяет два отсортированных диапазона (шаблон функции) | |
| объединяет два упорядоченных диапазона на месте (шаблон функции) | |
Операции для множеств (на отсортированных диапазонах) | |
возвращает true, если одна последовательность является подпоследовательностью другой (шаблон функции) | |
| вычисляет разницу между двумя наборами (шаблон функции) | |
| вычисляет пересечение двух множеств (шаблон функции) | |
| вычисляет симметричную разницу между двумя наборами (шаблон функции) | |
| вычисляет объединение двух множеств (шаблон функции) | |
Операции над кучей | |
| проверяет, является ли указанный диапазон максимальной кучей (шаблон функции) | |
(C++11) |
находит самый большой поддиапазон, который составляет максимальную кучу (шаблон функции) |
| создаёт максимальную кучу из диапазона элементов (шаблон функции) | |
| добавляет элемент в максимальную кучу (шаблон функции) | |
| удаляет наибольший элемент из максимальной кучи (шаблон функции) | |
| превращает максимальную кучу в диапазон элементов, отсортированных в порядке возрастания (шаблон функции) | |
Операции минимума/максимума | |
| возвращает большее из заданных значений (шаблон функции) | |
| возвращает наибольший элемент в диапазоне (шаблон функции) | |
| возвращает меньшее из заданных значений (шаблон функции) | |
| возвращает наименьший элемент в диапазоне (шаблон функции) | |
(C++11) |
возвращает меньший и больший из двух элементов (шаблон функции) |
(C++11) |
возвращает наименьший и наибольший элементы в диапазоне (шаблон функции) |
(C++17) |
приводит значение к диапазону между парой граничных значений (шаблон функции) |
Операции сравнения | |
| определяет, одинаковы ли два множества элементов (шаблон функции) | |
возвращает true, если один диапазон лексикографически меньше другого (шаблон функции) | |
| сравнивает два диапазона, используя трёхстороннее сравнение (шаблон функции) | |
Операции перестановки | |
(C++11) |
определяет, является ли последовательность перестановкой другой последовательности (шаблон функции) |
| генерирует следующую большую лексикографическую перестановку диапазона элементов (шаблон функции) | |
| генерирует следующую меньшую лексикографическую перестановку диапазона элементов (шаблон функции) | |
Определение
#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);
}