std::ranges::is_sorted_until

template< std::forward_iterator I, std::sentinel_for<I> S,
          class Proj = std::identity,
          std::indirect_strict_weak_order<std::projected<I, Proj>>
              Comp = ranges::less >
constexpr I
    is_sorted_until( I first, S last, Comp comp = {}, Proj proj = {} );

template< std::forward_range R, class Proj = std::identity,
          std::indirect_strict_weak_order<
              std::projected<ranges::iterator_t<R>, Proj>>
                  Comp = ranges::less >
constexpr ranges::borrowed_iterator_t<R>
    is_sorted_until( R&& r, Comp comp = {}, Proj proj = {} );

Untersucht den Bereich [first, last) und findet den größten Bereich, der bei first beginnt, in dem die Elemente in nicht absteigender Reihenfolge sortiert sind.

Eine Sequenz ist sortiert bezüglich eines Vergleichs comp, wenn für jeden Iterator it, der auf die Sequenz zeigt, und jede nicht-negative ganze Zahl n, so dass it + n ein gültiger Iterator ist, der auf ein Element der Sequenz zeigt, std::invoke(comp, std::invoke(proj, *(it + n)), std::invoke(proj, *it)) ergibt false.

Die auf dieser Seite beschriebenen funktionsähnlichen Entitäten sind Algorithmus-Funktionsobjekte (informell bekannt als niebloids), das heißt:

• Explizite Template-Argumentlisten können beim Aufrufen keiner von ihnen angegeben werden.
• Keine von ihnen sind sichtbar für die argumentabhängige Suche.
• Wenn eine von ihnen durch normale unqualifizierte Suche als der Name links vom Funktionsaufrufoperator gefunden wird, wird die argumentabhängige Suche unterdrückt.

Parameter

Rückgabewert

Die obere Schranke des größten Bereichs, beginnend bei first , in dem die Elemente in nicht-absteigender Reihenfolge sortiert sind. Das heißt, der letzte Iterator it , für den der Bereich [ first , it ) sortiert ist.

Komplexität

Linear in der Entfernung zwischen first und last .

Mögliche Implementierung

struct is_sorted_until_fn
{
    template<std::forward_iterator I, std::sentinel_for<I> S,
             class Proj = std::identity,
             std::indirect_strict_weak_order<std::projected<I, Proj>>
                 Comp = ranges::less>
    constexpr I operator()(I first, S last, Comp comp = {}, Proj proj = {}) const
    {
        if (first == last)
            return first;
        for (auto next = first; ++next != last; first = next)
            if (std::invoke(comp, std::invoke(proj, *next), std::invoke(proj, *first)))
                return next;
        return first;
    }
    template<ranges::forward_range R, class Proj = std::identity,
             std::indirect_strict_weak_order<
                 std::projected<ranges::iterator_t<R>, Proj>> Comp = ranges::less>
    constexpr ranges::borrowed_iterator_t<R>
        operator()(R&& r, Comp comp = {}, Proj proj = {}) const
    {
        return (*this)(ranges::begin(r), ranges::end(r), std::ref(comp), std::ref(proj));
    }
};
inline constexpr is_sorted_until_fn is_sorted_until;

Hinweise

ranges::is_sorted_until gibt einen Iterator zurück, der gleich last für leere Bereiche und Bereiche der Länge eins ist.

Beispiel

#include <array>
#include <algorithm>
#include <iostream>
#include <iterator>
#include <random>
int main()
{
    std::random_device rd;
    std::mt19937 g {rd()};
    std::array nums {3, 1, 4, 1, 5, 9};
    constexpr int min_sorted_size = 4;
    int sorted_size = 0;
    do
    {
        std::ranges::shuffle(nums, g);
        const auto sorted_end = std::ranges::is_sorted_until(nums);
        sorted_size = std::ranges::distance(nums.begin(), sorted_end);
        std::ranges::copy(nums, std::ostream_iterator<int>(std::cout, " "));
        std::cout << " : " << sorted_size << " leading sorted element(s)\n";
    }
    while (sorted_size < min_sorted_size);
}

4 1 9 5 1 3  : 1 leading sorted element(s)
4 5 9 3 1 1  : 3 leading sorted element(s)
9 3 1 4 5 1  : 1 leading sorted element(s)
1 3 5 4 1 9  : 3 leading sorted element(s)
5 9 1 1 3 4  : 2 leading sorted element(s)
4 9 1 5 1 3  : 2 leading sorted element(s)
1 1 4 9 5 3  : 4 leading sorted element(s)

Siehe auch