std::ranges:: sort_heap

Sortiert die Elemente im angegebenen Bereich bezüglich comp und proj , wobei der Bereich ursprünglich einen Heap bezüglich comp und proj darstellt. Der sortierte Bereich behält die Heap-Eigenschaft nicht mehr bei.

Wenn der angegebene Bereich kein Heap in Bezug auf comp und proj ist, ist das Verhalten undefiniert.

Die auf dieser Seite beschriebenen funktionsähnlichen Entitäten sind Algorithm Function Objects (informell bekannt als Niebloids ), das heißt:

• Explizite Template-Argumentlisten können beim Aufruf keiner von ihnen angegeben werden.
• Keiner von ihnen ist sichtbar für argument-dependent lookup .
• Wenn einer von ihnen durch normal unqualified lookup als Name links vom Funktionsaufrufoperator gefunden wird, wird argument-dependent lookup unterdrückt.

Parameter

Rückgabewert

Komplexität

Höchstens \(\scriptsize 2N \cdot \log(N)\) 2N⋅log(N) Anwendungen von comp und \(\scriptsize 4N \cdot \log(N)\) 4N⋅log(N) Anwendungen von proj , wobei \(\scriptsize N \) N ist:

Mögliche Implementierung

struct sort_heap_fn
{
    template<std::random_access_iterator I, std::sentinel_for<I> S,
             class Comp = ranges::less, class Proj = std::identity>
        requires std::sortable<I, Comp, Proj>
    constexpr I operator()(I first, S last, Comp comp = {}, Proj proj = {}) const
    {
        auto ret{ranges::next(first, last)};
        for (auto last{ret}; first != last; --last)
            ranges::pop_heap(first, last, comp, proj);
        return ret;
    }
    template<ranges::random_access_range R,
             class Comp = ranges::less, class Proj = std::identity>
        requires std::sortable<ranges::iterator_t<R>, Comp, Proj>
    constexpr ranges::borrowed_iterator_t<R>
        operator()(R&& r, Comp comp = {}, Proj proj = {}) const
    {
        return (*this)(ranges::begin(r), ranges::end(r), std::move(comp), std::move(proj));
    }
};
inline constexpr sort_heap_fn sort_heap{};

`-Tags wurde gemäß den Anweisungen nicht übersetzt, da es sich um C++-Code handelt. Die HTML-Struktur und -Attribute bleiben ebenfalls unverändert.

Beispiel

#include <algorithm>
#include <array>
#include <iostream>
void print(auto const& rem, const auto& v)
{
    std::cout << rem;
    for (const auto i : v)
        std::cout << i << ' ';
    std::cout << '\n';
}
int main()
{
    std::array v{3, 1, 4, 1, 5, 9};
    print("original array:  ", v);
    std::ranges::make_heap(v);
    print("after make_heap: ", v);
    std::ranges::sort_heap(v);
    print("after sort_heap: ", v);
}

original array:  3 1 4 1 5 9
after make_heap: 9 5 4 1 1 3
after sort_heap: 1 1 3 4 5 9

Siehe auch