std::sort_heap

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

Algorithmenbibliothek

Beschränkte Algorithmen und Algorithmen für Bereiche (C++20)
Beschränkte Algorithmen, z.B. ranges::copy, ranges::sort, ...
Ausführungsrichtlinien (C++17)
is_execution_policy (C++17)   execution::seqexecution::parexecution::par_unseqexecution::unseq (C++17)    (C++17)(C++17)(C++20)	execution::sequenced_policyexecution::parallel_policyexecution::parallel_unsequenced_policyexecution::parallel_unsequenced (C++17)(C++17)(C++17)(C++20)
Nicht-modifizierende Sequenzoperationen Stapeloperationen for_each for_each_n (C++17) Suchoperationen all_ofany_ofnone_of (C++11)                (C++11)(C++11) countcount_if mismatch equal findfind_iffind_if_not (C++11) find_end find_first_of adjacent_find search search_n Modifizierende Sequenzoperationen Kopieroperationen copycopy_if (C++11) copy_backward copy_n (C++11) move (C++11) move_backward (C++11) Tauschoperationen swap iter_swap swap_ranges Transformationsoperationen replacereplace_if transform replace_copyreplace_copy_if Generierungsoperationen fill fill_n generate generate_n Entfernungsoperationen removeremove_if unique remove_copyremove_copy_if unique_copy Ordnungsändernde Operationen reverse reverse_copy rotate rotate_copy random_shuffleshuffle (bis C++17)(C++11) shift_leftshift_right (C++20)(C++20) Stichprobenoperationen sample (C++17)	Sortier- und verwandte Operationen Partitionierungsoperationen partition partition_copy (C++11)   stable_partition is_partitioned (C++11) partition_point (C++11) Sortieroperationen sort stable_sort partial_sort partial_sort_copy is_sorted (C++11) is_sorted_until (C++11) nth_element Binäre Suchoperationen (auf partitionierten Bereichen) lower_bound upper_bound equal_range binary_search Mengenoperationen (auf sortierten Bereichen) includes set_union set_intersection set_difference set_symmetric_difference Zusammenführungsoperationen (auf sortierten Bereichen) merge inplace_merge Heapoperationen push_heap pop_heap make_heap sort_heap is_heap (C++11) is_heap_until (C++11) Minimum/Maximum-Operationen max min minmax (C++11) clamp (C++17) max_element min_element minmax_element (C++11) Lexikographische Vergleichsoperationen lexicographical_compare lexicographical_compare_three_way (C++20) Permutationsoperationen next_permutation prev_permutation is_permutation (C++11) C-Bibliothek qsort bsearch
Numerische Operationen
iota (C++11) inner_product adjacent_difference    accumulate reduce (C++17) transform_reduce (C++17)	partial_sum inclusive_scan (C++17)    exclusive_scan (C++17) transform_inclusive_scan (C++17) transform_exclusive_scan (C++17)
Operationen auf uninitialisiertem Speicher
uninitialized_copy uninitialized_move (C++17)    uninitialized_fill uninitialized_copy_n (C++11) uninitialized_move_n (C++17) uninitialized_fill_n	destroy (C++17) destroy_n (C++17) destroy_at (C++17) construct_at (C++20)       uninitialized_default_construct (C++17) uninitialized_value_construct (C++17) uninitialized_default_construct_n (C++17) uninitialized_value_construct_n (C++17)

 

Definiert in Header <algorithm>
template< class RandomIt > void sort_heap( RandomIt first, RandomIt last );	(1)	(constexpr seit C++20)
template< class RandomIt, class Compare > void sort_heap( RandomIt first, RandomIt last, Compare comp );	(2)	(constexpr seit C++20)

Konvertiert den Heap [first, last) in einen sortierten Bereich. Die Heap-Eigenschaft wird nicht mehr aufrechterhalten.

1) Der Heap ist bezüglich operator<(bis C++20)std::less{}(seit C++20) und wird bezüglich operator<(bis C++20)std::less{}(seit C++20) sortiert.

2) Der Heap ist bezüglich comp und wird bezüglich comp sortiert.

Wenn eine der folgenden Bedingungen erfüllt ist, ist das Verhalten undefiniert

• [first, last) ist kein Heap.

Der Typ von *first ist nicht Swappable.	(bis C++11)
RandomIt ist nicht ValueSwappable. Der Typ von *first ist nicht MoveConstructible. Der Typ von *first ist kein MoveAssignable.	(seit C++11)

Parameter

first, last	-	das Iteratorenpaar, das den binären Heap Bereich der Elemente definiert, um den sortierten Bereich zu erstellen
comp	-	Ein Vergleichsfunktions-Objekt (d.h. ein Objekt, das die Anforderungen an Compare erfüllt), das true zurückgibt, wenn das erste Argument *weniger* als das zweite ist. Die Signatur der Vergleichsfunktion sollte äquivalent zu Folgendem sein bool cmp(const Type1& a, const Type2& b); Obwohl die Signatur nicht const& haben muss, darf die Funktion die übergebenen Objekte nicht modifizieren und muss alle Werte vom Typ (möglicherweise const) Type1 und Type2 unabhängig von der Wertkategorie akzeptieren (daher ist Type1& nicht erlaubt, und auch nicht Type1, es sei denn, für Type1 ist ein Move äquivalent zu einer Kopie(seit C++11)). Die Typen Type1 und Type2 müssen so beschaffen sein, dass ein Objekt vom Typ RandomIt dereferenziert und dann implizit in beide konvertiert werden kann.
Typanforderungen
- RandomIt muss die Anforderungen an einen LegacyRandomAccessIterator erfüllen.
- Compare muss die Anforderungen an Compare erfüllen.

Komplexität

Gegeben sei \(\scriptsize N\)N als std::distance(first, last).

1) Höchstens \(\scriptsize 2N \cdot \log(N)\)2N⋅log(N) Vergleiche mit operator<(bis C++20)std::less{}(seit C++20).

2) Höchstens \(\scriptsize 2N \cdot \log(N)\)2N⋅log(N) Aufrufe der Vergleichsfunktion comp.

Mögliche Implementierung

sort_heap (1)
template<class RandomIt> void sort_heap(RandomIt first, RandomIt last) { while (first != last) std::pop_heap(first, last--); }
sort_heap (2)
template<class RandomIt, class Compare> void sort_heap(RandomIt first, RandomIt last, Compare comp) { while (first != last) std::pop_heap(first, last--, comp); }

Beispiel

Führen Sie diesen Code aus

#include <algorithm>
#include <iostream>
#include <string_view>
#include <vector>
 
void println(std::string_view fmt, const auto& v)
{
    for (std::cout << fmt; const auto &i : v)
        std::cout << i << ' ';
    std::cout << '\n';
}
 
int main()
{
    std::vector<int> v{3, 1, 4, 1, 5, 9};
 
    std::make_heap(v.begin(), v.end());
    println("after make_heap, v: ", v);
 
    std::sort_heap(v.begin(), v.end());
    println("after sort_heap, v: ", v);
}

Ausgabe

after make_heap, v: 9 4 5 1 1 3
after sort_heap, v: 1 1 3 4 5 9

Fehlerberichte

Die folgenden Verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

DR	angewendet auf	Verhalten wie veröffentlicht	Korrigiertes Verhalten
LWG 2444	C++98	höchstens \(\scriptsize N \cdot \log(N)\)N⋅log(N) Vergleiche waren erlaubt	erhöht auf \(\scriptsize 2N \cdot \log(N)\)2N⋅log(N)

Siehe auch

is_heap (C++11)	Prüft, ob der gegebene Bereich ein Max-Heap ist (Funktionstemplate)
is_heap_until (C++11)	Findet den größten Teilbereich, der ein Max-Heap ist (Funktionstemplate)
make_heap	Erstellt aus einem Bereich von Elementen einen Max-Heap (Funktionstemplate)
pop_heap	Entfernt das größte Element aus einem Max-Heap (Funktionstemplate)
push_heap	Fügt ein Element zu einem Max-Heap hinzu (Funktionstemplate)
ranges::sort_heap (C++20)	Verwandelt einen Max-Heap in einen aufsteigend sortierten Bereich von Elementen (Algorithmus-Funktionsobjekt)