Namespaces
Variants

std:: is_heap

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

bool is_heap ( ExecutionPolicy && policy,

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

bool is_heap ( ExecutionPolicy && policy,

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

Comprueba si [ first , last ) es un heap .

1) La propiedad de montón 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 .

(hasta C++20)

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

(desde C++20)

Contenidos

Parámetros

first, last - el par de iteradores que define el rango de elementos a verificar
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

true si el rango es un heap con respecto al comparador correspondiente, false en caso contrario.

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

Ejecutar este código 
#include <algorithm>
#include <bit>
#include <iostream>
#include <vector>
int main()
{
    std::vector<int> v{3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5, 8, 9, 7, 9};
    std::cout << "inicialmente, v:\n";
    for (const auto& i : v)
        std::cout << i << ' ';
    std::cout << '\n';
    if (!std::is_heap(v.begin(), v.end()))
    {
        std::cout << "creando heap...\n";
        std::make_heap(v.begin(), v.end());
    }
    std::cout << "después de make_heap, v:\n";
    for (auto t{1U}; const auto& i : v)
        std::cout << i << (std::has_single_bit(++t) ? " | " : " ");
    std::cout << '\n';
}

Salida: 

inicialmente, v:
3 1 4 1 5 9 2 6 5 3 5 8 9 7 9
creando heap...
después de make_heap, v:
9 | 6 9 | 5 5 9 7 | 1 1 3 5 8 3 4 2 |

Véase también

(C++11)
encuentra el mayor subrango que es un max heap
(function template)
crea un max heap a partir de un rango de elementos
(function template)
añade un elemento a un max heap
(function template)
elimina el elemento más grande de un max heap
(function template)
convierte un max heap en un rango de elementos ordenados en orden ascendente
(function template)
(C++20)
comprueba si el rango dado es un max heap
(algorithm function object)