Namespaces
Variants

std:: pop_heap

From cppreference.net
Algorithm library
Constrained algorithms and algorithms on ranges (C++20)
Constrained algorithms, e.g. ranges::copy , ranges::sort , ...
Execution policies (C++17)
Non-modifying sequence operations
Batch operations
(C++17)
Search operations
Modifying sequence operations
Copy operations
(C++11)
(C++11)
Swap operations
Transformation operations
Generation operations
Removing operations
Order-changing operations
(until C++17) (C++11)
(C++20) (C++20)
Sampling operations
(C++17)

Sorting and related operations
Partitioning operations
Sorting operations
Binary search operations
(on partitioned ranges)
Set operations (on sorted ranges)
Merge operations (on sorted ranges)
Heap operations
Minimum/maximum operations
Lexicographical comparison operations
Permutation operations
C library
Numeric operations
Operations on uninitialized memory
Definiert im Header <algorithm>
template < class RandomIt >
void pop_heap ( RandomIt first, RandomIt last ) ;
(1) (constexpr seit C++20)
template < class RandomIt, class Compare >
void pop_heap ( RandomIt first, RandomIt last, Compare comp ) ;
(2) (constexpr seit C++20)

Tauscht den Wert an der Position first mit dem Wert an der Position last - 1 aus und macht den Teilbereich [ first , last - 1 ) zu einem Heap. Dies hat den Effekt, dass das erste Element aus dem Heap [ first , last ) entfernt wird.

1) [ first , last ) ist ein Heap bezüglich operator < (bis C++20) std:: less { } (seit C++20) .
2) [ first , last ) ist ein Heap bezüglich comp .

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

  • [ first , last ) ist leer.
  • [ first , last ) ist kein Heap bezüglich des entsprechenden Vergleichsoperators.
(bis C++11)
(seit C++11)

Inhaltsverzeichnis

Parameter

first, last - Das Paar von Iteratoren, das den nicht-leeren Bereich der binären Heap-Elemente definiert, die modifiziert werden sollen (Wurzelelement extrahieren)
comp - Vergleichsfunktionsobjekt (d.h. ein Objekt, das die Anforderungen von Compare erfüllt), das true zurückgibt, wenn das erste Argument kleiner als das zweite ist.

Die Signatur der Vergleichsfunktion sollte äquivalent zu Folgender sein:

bool cmp ( const Type1 & a, const Type2 & b ) ;

Obwohl die Signatur nicht const & benötigt, darf die Funktion die übergebenen Objekte nicht modifizieren und muss alle Werte der Typen (möglicherweise const) Type1 und Type2 unabhängig von der Wertkategorie akzeptieren können (daher ist Type1 & nicht erlaubt , ebenso wenig wie Type1 , es sei denn, für Type1 ist eine Verschiebung ä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 von LegacyRandomAccessIterator erfüllen.
-
Compare muss die Anforderungen von Compare erfüllen.

Komplexität

Gegeben N als std:: distance ( first, last ) :

1) Höchstens 2log(N) Vergleiche unter Verwendung von operator < (bis C++20) std:: less { } (seit C++20) .
2) Höchstens 2log(N) Anwendungen der Vergleichsfunktion comp .

Beispiel

#include <algorithm>
#include <iostream>
#include <string_view>
#include <type_traits>
#include <vector>
void println(std::string_view rem, const auto& v)
{
    std::cout << rem;
    if constexpr (std::is_scalar_v<std::decay_t<decltype(v)>>)
        std::cout << v;
    else
        for (int e : v)
            std::cout << e << ' ';
    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);
    std::pop_heap(v.begin(), v.end()); // moves the largest to the end
    println("after pop_heap:  ", v);
    int largest = v.back();
    println("largest element: ", largest);
    v.pop_back(); // actually removes the largest element
    println("after pop_back:  ", v);
}

Ausgabe:

after make_heap: 9 5 4 1 1 3
after pop_heap:  5 3 4 1 1 9
largest element: 9
after pop_back:  5 3 4 1 1

Fehlerberichte

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

DR Angewendet auf Verhalten wie veröffentlicht Korrektes Verhalten
LWG 1205 C++98 das Verhalten war unklar, falls [ first , last ) leer ist das Verhalten ist in diesem Fall undefiniert

Siehe auch

fügt ein Element zu einem Max-Heap hinzu
(Funktions-Template)
(C++11)
prüft, ob der gegebene Bereich ein Max-Heap ist
(Funktions-Template)
findet den größten Teilbereich, der ein Max-Heap ist
(Funktions-Template)
erstellt einen Max-Heap aus einem Elementebereich
(Funktions-Template)
wandelt einen Max-Heap in einen aufsteigend sortierten Elementebereich um
(Funktions-Template)
entfernt das größte Element aus einem Max-Heap
(Algorithmus-Funktionsobjekt)