Namespaces
Variants

std:: is_heap_until

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
(C++11)
is_heap_until
(C++11)
Minimum/maximum operations
Lexicographical comparison operations
Permutation operations
C library
Numeric operations
Operations on uninitialized memory
Definido en el encabezado <algorithm>
template < class RandomIt >
RandomIt is_heap_until ( RandomIt first, RandomIt last ) ;
(1) (desde C++11)
(constexpr desde C++20)
template < class ExecutionPolicy, class RandomIt >

RandomIt is_heap_until ( ExecutionPolicy && policy,

RandomIt first, RandomIt last ) ;
(2) (desde C++17)
template < class RandomIt, class Compare >
RandomIt is_heap_until ( RandomIt first, RandomIt last, Compare comp ) ;
(3) (desde C++11)
(constexpr desde C++20)
template < class ExecutionPolicy, class RandomIt, class Compare >

RandomIt is_heap_until ( ExecutionPolicy && policy,

RandomIt first, RandomIt last, Compare comp ) ;
(4) (desde C++17)

Examina el rango [ first , last ) y encuentra el rango más grande que comienza en first que es un heap .

1) La propiedad de heap que se debe verificar es con respecto a operator < (until C++20) std:: less { } (since C++20) .
3) La propiedad del montón que se debe verificar es con respecto a comp .
2,4) Igual que (1,3) , pero ejecutado de acuerdo con la policy .
Estas sobrecargas participan en la resolución de sobrecarga solo si se satisfacen todas las siguientes condiciones:

std:: is_execution_policy_v < std:: decay_t < ExecutionPolicy >> es true .

(until C++20)

std:: is_execution_policy_v < std:: remove_cvref_t < ExecutionPolicy >> es true .

(since C++20)

Contenidos

Parámetros

first, last - el par de iteradores que definen el rango de elementos a examinar
policy - la política de ejecución a utilizar
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 (desde 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 .

Valor de retorno

El último iterador it para el cual el rango [ first , it ) es un heap.

Complejidad

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

1,2) O(N) comparaciones usando operator < (hasta C++20) std:: less { } (desde C++20) .
3,4) O(N) aplicaciones de la función de comparación comp .

Excepciones

Las sobrecargas con un parámetro de plantilla llamado ExecutionPolicy reportan errores de la siguiente manera:

  • Si la ejecución de una función invocada como parte del algoritmo lanza una excepción y ExecutionPolicy es uno de los standard policies , std::terminate es llamado. Para cualquier otro ExecutionPolicy , el comportamiento está definido por la implementación.
  • Si el algoritmo falla al asignar memoria, std::bad_alloc es lanzado.

Ejemplo

#include <algorithm>
#include <iostream>
#include <vector>
int main()
{
    std::vector<int> v{3, 1, 4, 1, 5, 9};
    std::make_heap(v.begin(), v.end());
    // probablemente desordene el heap
    v.push_back(2);
    v.push_back(6);
    auto heap_end = std::is_heap_until(v.begin(), v.end());
    std::cout << "all of v:  ";
    for (const auto& i : v)
        std::cout << i << ' ';
    std::cout << '\n';
    std::cout << "only heap: ";
    for (auto i = v.begin(); i != heap_end; ++i)
        std::cout << *i << ' ';
    std::cout << '\n';
}

Salida:

all of v:  9 5 4 1 1 3 2 6
only heap: 9 5 4 1 1 3 2

Véase también

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