Namespaces
Variants

std::ranges::is_heap

De es.cppreference.net
 
 
Biblioteca de algoritmos
Algoritmos restringidos y algoritmos sobre rangos (C++20)
Algoritmos restringidos, p.ej. ranges::copy, ranges::sort, ...
Operaciones de secuencia no modificadoras    
Operaciones por lotes
(C++17)
Operaciones de búsqueda
Operaciones de secuencia modificadoras
Operaciones de copia
(C++11)
(C++11)
Operaciones de intercambio
Operaciones de transformación
Operaciones de generación
Operaciones de eliminación
Operaciones de cambio de orden
(hasta C++17)(C++11)
(C++20)(C++20)
Operaciones de muestreo
(C++17)

Operaciones de ordenación y relacionadas
Operaciones de particionado
(C++11)    

Operaciones de ordenación
Operaciones de búsqueda binaria
(en rangos particionados)
Operaciones de conjuntos (en rangos ordenados)
Operaciones de fusión (en rangos ordenados)
Operaciones de montículo
Operaciones de mínimo/máximo
(C++11)
(C++17)
Operaciones de comparación lexicográfica
Operaciones de permutación


 
Algoritmos restringidos
Todos los nombres en este menú pertenecen al espacio de nombres std::ranges
Operaciones de secuencia no modificadoras
Operaciones de secuencia modificadoras
Operaciones de particionado
Operaciones de ordenación
Operaciones de búsqueda binaria (en rangos ordenados)
       
       
Operaciones de conjuntos (en rangos ordenados)
Operaciones de montículo
Operaciones de mínimo/máximo
       
       
Operaciones de permutación
Operaciones de pliegue
Operaciones sobre almacenamiento no inicializado
Tipos de retorno
 
Definido en el encabezado <algorithm>
Firma de llamada
template< std::random_access_iterator I, std::sentinel_for<I> S,
          class Proj = std::identity,
          std::indirect_strict_weak_order
              <std::projected<I, Proj>> Comp = ranges::less >
constexpr bool is_heap( I first, S last, Comp comp = {}, Proj proj = {} );
(1) (desde C++20)
template< ranges::random_access_range R, class Proj = std::identity,
          std::indirect_strict_weak_order
              <std::projected
                   <ranges::iterator_t<R>, Proj>> Comp = ranges::less >
constexpr bool is_heap( R&& r, Comp comp = {}, Proj proj = {} );
(2) (desde C++20)

Comprueba si el rango especificado representa un montículo con respecto a comp y proj.

1) El rango especificado es [first, last).
2) El rango especificado es r.

Las entidades similares a funciones descritas en esta página son objetos función de algoritmo (conocidos informalmente como niebloids), es decir:

Parámetros

first, last - el par iterador-centinela que define el rango de elementos a examinar
r - el range de elementos a examinar
comp - comparador a aplicar a los elementos proyectados
proj - proyección a aplicar a los elementos

Valor de retorno

1) ranges:: is_heap_until ( first, last, comp, proj ) == last
2) ranges:: is_heap_until ( r, comp, proj ) == ranges:: end ( r )

Complejidad

O(N) aplicaciones de comp y proj , donde N es:

1) ranges:: distance ( first, last )

Implementación posible

struct is_heap_fn
{
    template<std::random_access_iterator I, std::sentinel_for<I> S,
             class Proj = std::identity,
             std::indirect_strict_weak_order
                 <std::projected<I, Proj>> Comp = ranges::less>
    constexpr bool operator()(I first, S last, Comp comp = {}, Proj proj = {}) const
    {
        return (last == ranges::is_heap_until(first, last,
                                              std::move(comp), std::move(proj)));
    }
    template<ranges::random_access_range R, class Proj = std::identity,
             std::indirect_strict_weak_order
                 <std::projected<ranges::iterator_t<R>, Proj>> Comp = ranges::less>
    constexpr bool operator()(R&& r, Comp comp = {}, Proj proj = {}) const
    {
        return (*this)(ranges::begin(r), ranges::end(r),
                       std::move(comp), std::move(proj));
    }
};
inline constexpr is_heap_fn is_heap{};

Ejemplo

#include <algorithm>
#include <bit>
#include <cmath>
#include <iostream>
#include <vector>
void out(const auto& what, int n = 1)
{
    while (n-- > 0)
        std::cout << what;
}
void draw_heap(const auto& v)
{
    auto bails = [](int n, int w)
    {
        auto b = [](int w) { out("┌"), out("─", w), out("┴"), out("─", w), out("┐"); };
        n /= 2;
        if (!n)
            return;
        for (out(' ', w); n-- > 0;)
            b(w), out(' ', w + w + 1);
        out('\n');
    };
    auto data = [](int n, int w, auto& first, auto last)
    {
        for (out(' ', w); n-- > 0 && first != last; ++first)
            out(*first), out(' ', w + w + 1);
        out('\n');
    };
    auto tier = [&](int t, int m, auto& first, auto last)
    {
        const int n{1 << t};
        const int w{(1 << (m - t - 1)) - 1};
        bails(n, w), data(n, w, first, last);
    };
    const int m{static_cast<int>(std::ceil(std::log2(1 + v.size())))};
    auto first{v.cbegin()};
    for (int i{}; i != m; ++i)
        tier(i, m, first, v.cend());
}
int main()
{
    std::vector<int> v{3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5, 8, 9, 7, 9, 3, 2, 3, 8};
    out("inicialmente, v:\n");
    for (auto i : v)
        std::cout << i << ' ';
    out('\n');
    if (!std::ranges::is_heap(v))
    {
        out("creando montón...\n");
        std::ranges::make_heap(v);
    }
    out("después de make_heap, v:\n");
    for (auto t{1U}; auto i : v)
        std::cout << i << (std::has_single_bit(++t) ? " │ " : " ");
    out("\n" "el árbol binario correspondiente es:\n");
    draw_heap(v);
}

Salida:

inicialmente, v:
3 1 4 1 5 9 2 6 5 3 5 8 9 7 9 3 2 3 8
creando heap...
después de make_heap, v:
9 │ 8 9 │ 6 5 8 9 │ 3 5 3 5 3 4 7 2 │ 1 2 3 1
el árbol binario correspondiente es:
               9
       ┌───────┴───────┐
       8               9
   ┌───┴───┐       ┌───┴───┐
   6       5       8       9
 ┌─┴─┐   ┌─┴─┐   ┌─┴─┐   ┌─┴─┐
 3   5   3   5   3   4   7   2
┌┴┐ ┌┴┐ ┌┴┐ ┌┴┐ ┌┴┐ ┌┴┐ ┌┴┐ ┌┴┐
1 2 3 1

Véase también

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