std::is_sorted_until

Определено в заголовке `<algorithm>`
	(1)
template< class ForwardIt > ForwardIt is_sorted_until( ForwardIt first, ForwardIt last );		(с C++11) (до C++20)
template< class ForwardIt > constexpr ForwardIt is_sorted_until( ForwardIt first, ForwardIt last );		(с C++20)
template< class ExecutionPolicy, class ForwardIt > ForwardIt is_sorted_until( ExecutionPolicy&& policy, ForwardIt first, ForwardIt last );	(2)	(с C++17)
	(3)
template< class ForwardIt, class Compare > ForwardIt is_sorted_until( ForwardIt first, ForwardIt last, Compare comp );		(с C++11) (до C++20)
template< class ForwardIt, class Compare > constexpr ForwardIt is_sorted_until( ForwardIt first, ForwardIt last, Compare comp );		(с C++20)
template< class ExecutionPolicy, class ForwardIt, class Compare > ForwardIt is_sorted_until( ExecutionPolicy&& policy, ForwardIt first, ForwardIt last, Compare comp );	(4)	(с C++17)

Изучает диапазон [first, last) и находит наибольший диапазон, начинающийся с first, в котором элементы упорядочены в порядке невозрастания.

Последовательность упорядочена по отношению к компаратору comp , если для любого итератора it , указывающего на последовательность, и любого неотрицательного целого числа n , такого что it + n является допустимым итератором, указывающим на элемент последовательности, comp(*(it + n), *it) оценивается как false.

1) Элементы сравниваются с использованием operator<.

3) Элементы сравниваются с использованием заданной бинарной функции сравнения comp.

2,4) Аналогично (1,3), но выполняется в соответствии с policy. Эти перегрузки не участвуют в разрешении перегрузки, если

`std::is_execution_policy_v<std::decay_t<ExecutionPolicy>>` является `true`.	(до C++20)
`std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>>` является `true`.	(с C++20)

Параметры

first, last	-	диапазон элементов для проверки
policy	-	политика выполнения. См. политику выполнения для подробностей.
comp	-	объект-функция сравнения (т.е. объект, удовлетворяющий требованиям Compare), которая возвращает `true` , если первый аргумент меньше (т.е. упорядочен раньше) второго. Подпись функции сравнения должна быть эквивалентна следующей: `bool cmp(const Type1& a, const Type2& b);` Хотя подпись не требует const&, функция не должна изменять передаваемые ей объекты и должна иметь возможность принимать все значения типа (возможно, const) `Type1` и `Type2` независимо от категории значений (следовательно, `Type1&` недопустимо, а также `Type1` за исключением случаев, когда для `Type1` перемещение эквивалентно копированию(с C++11)). Типы Type1 и Type2 должны быть такими, чтобы объект типа ForwardIt можно было разыменовать и затем неявно преобразовать в оба из них.
Требования к типу
-`ForwardIt` должен удовлетворять требованиям LegacyForwardIterator.

Возвращаемое значение

Верхняя граница наибольшего диапазона, начинающегося с first , в котором элементы упорядочены по возрастанию. То есть последний итератор it , для которого диапазон [first, it) упорядочен.

Возвращает last для пустых диапазонов и диапазонов длиной один.

Сложность

Линейная по расстоянию между first и last.

Исключения

Перегрузки с параметром шаблона, названным ExecutionPolicy , сообщают об ошибках следующим образом:

Если выполнение функции, вызванной в рамках алгоритма, вызывает исключение, и ExecutionPolicy является одной из стандартных политик, вызывается std::terminate. Для любой другой ExecutionPolicy, поведение определяется реализацией.
Если алгоритм не может выделить память, выбрасывается std::bad_alloc.

Возможная реализация

См. также реализации в libstdc++ и libc++.

is_sorted_until (1)
template<class ForwardIt> constexpr //< since C++20 ForwardIt is_sorted_until(ForwardIt first, ForwardIt last) { return std::is_sorted_until(first, last, std::less<>()); }
is_sorted_until (2)
template<class ForwardIt, class Compare> constexpr //< since C++20 ForwardIt is_sorted_until(ForwardIt first, ForwardIt last, Compare comp) { if (first != last) { ForwardIt next = first; while (++next != last) { if (comp(next, first)) return next; first = next; } } return last; }

is_sorted_until (1)

template<class ForwardIt>
constexpr //< since C++20
ForwardIt is_sorted_until(ForwardIt first, ForwardIt last)
{
    return std::is_sorted_until(first, last, std::less<>());
}

is_sorted_until (2)

template<class ForwardIt, class Compare>
constexpr //< since C++20
ForwardIt is_sorted_until(ForwardIt first, ForwardIt last, Compare comp)
{
    if (first != last)
    {
        ForwardIt next = first;
        while (++next != last)
        {
            if (comp(*next, *first))
                return next;
            first = next;
        }
    }
    return last;
}

Пример

#include <algorithm>
#include <cassert>
#include <iostream>
#include <iterator>
#include <random>
#include <string>
 
int main()
{
    std::random_device rd;
    std::mt19937 g(rd());
    const int N = 6;
    int nums[N] = {3, 1, 4, 1, 5, 9};
 
    const int min_sorted_size = 4;
 
    for (int sorted_size = 0; sorted_size < min_sorted_size;)
    {
        std::shuffle(nums, nums + N, g);
        int *const sorted_end = std::is_sorted_until(nums, nums + N);
        sorted_size = std::distance(nums, sorted_end);
        assert(sorted_size >= 1);
 
        for (const auto i : nums)
            std::cout << i << ' ';
        std::cout << ": " << sorted_size << " initial sorted elements\n"
                  << std::string(sorted_size * 2 - 1, '^') << '\n';
    }
}

Возможный вывод:

4 1 9 5 1 3 : 1 initial sorted elements
^
4 5 9 3 1 1 : 3 initial sorted elements
^^^^^
9 3 1 4 5 1 : 1 initial sorted elements
^
1 3 5 4 1 9 : 3 initial sorted elements
^^^^^
5 9 1 1 3 4 : 2 initial sorted elements
^^^
4 9 1 5 1 3 : 2 initial sorted elements
^^^
1 1 4 9 5 3 : 4 initial sorted elements
^^^^^^^

См. также

is_sorted (C++11)	проверяет, является ли диапазон отсортированным по возрастанию (шаблон функции)
ranges::is_sorted_until (C++20)	находит наибольший отсортированный поддиапазон (niebloid)

© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/w/cpp/algorithm/is_sorted_until