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
Definido en el encabezado <algorithm>
template < class RandomIt >
void pop_heap ( RandomIt first, RandomIt last ) ;
(1) (constexpr desde C++20)
template < class RandomIt, class Compare >
void pop_heap ( RandomIt first, RandomIt last, Compare comp ) ;
(2) (constexpr desde C++20)

Intercambia el valor en la posición first y el valor en la posición last - 1 y convierte el subrango [ first , last - 1 ) en un heap. Esto tiene el efecto de eliminar el primer elemento del heap [ first , last ) .

1) [ first , last ) es un heap con respecto a operator < (hasta C++20) std:: less { } (desde C++20) .
2) [ first , last ) es un montículo con respecto a comp .

Si se satisface cualquiera de las siguientes condiciones, el comportamiento es indefinido:

  • [ first , last ) está vacío.
  • [ first , last ) no es un heap con respecto al comparador correspondiente.
(hasta C++11)
(desde C++11)

Contenidos

Parámetros

first, last - el par de iteradores que define el rango no vacío del montículo binario de elementos a modificar (extraer elemento raíz)
comp - objeto función de comparación (es decir, un objeto que satisface los requisitos de Compare ) que devuelve true si el primer argumento es menor que el segundo.

La firma de la función de comparación debe ser equivalente a la siguiente:

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

Aunque la firma no necesita tener const & , la función no debe modificar los objetos pasados a ella y debe poder aceptar todos los valores de tipo (posiblemente const) Type1 y Type2 independientemente de la categoría de valor (por lo tanto, Type1 & no está permitido , ni tampoco Type1 a menos que para Type1 un movimiento sea equivalente a una copia (since C++11) ).
Los tipos Type1 y Type2 deben ser tales que un objeto de tipo RandomIt pueda ser desreferenciado y luego convertido implícitamente a ambos.

Requisitos de tipo
-
RandomIt debe cumplir con los requisitos de LegacyRandomAccessIterator .
-
Compare debe cumplir con los requisitos de Compare .

Complejidad

Dado N como std:: distance ( first, last ) :

1) Como máximo 2log(N) comparaciones usando operator < (until C++20) std:: less { } (since C++20) .
2) Como máximo 2log(N) aplicaciones de la función de comparación comp .

Ejemplo

#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()); // mueve el mayor al final
    println("after pop_heap:  ", v);
    int largest = v.back();
    println("largest element: ", largest);
    v.pop_back(); // elimina realmente el elemento mayor
    println("after pop_back:  ", v);
}

Salida:

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

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

DR Se aplica a Comportamiento publicado Comportamiento correcto
LWG 1205 C++98 el comportamiento no estaba claro si [ first , last ) está vacío el comportamiento no está definido en este caso

Véase también

añade un elemento a un max heap
(plantilla de función)
(C++11)
verifica si el rango dado es un max heap
(plantilla de función)
encuentra el mayor subrango que es un max heap
(plantilla de función)
crea un max heap a partir de un rango de elementos
(plantilla de función)
convierte un max heap en un rango de elementos ordenados en orden ascendente
(plantilla de función)
elimina el elemento más grande de un max heap
(objeto función de algoritmo)