Namespaces
Variants

std::ranges::is_heap_until

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 modificantes    
Operaciones por lotes
(C++17)
Operaciones de búsqueda
Operaciones de secuencia modificantes
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)

Ordenamiento y operaciones relacionadas
Operaciones de particionamiento
(C++11)    

Operaciones de ordenamiento
Operaciones de búsqueda binaria
(en rangos particionados)
Operaciones de conjunto (en rangos ordenados)
Operaciones de mezcla (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 modificantes
Operaciones de secuencia modificantes
Operaciones de particionamiento
Operaciones de ordenamiento
Operaciones de búsqueda binaria (en rangos ordenados)
       
       
Operaciones de conjunto (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 I is_heap_until( 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 ranges::borrowed_iterator_t<R>
    is_heap_until( R&& r, Comp comp = {}, Proj proj = {} );
(2) (desde C++20)

Dentro del rango especificado, encuentra el rango más largo que, comenzando desde el inicio del rango especificado y 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 (informalmente conocidos como niebloids), es decir:

Parámetros

first, last - el rango de elementos a examinar
r - el rango de elementos a examinar
pred - predicado a aplicar a los elementos proyectados
proj - proyección a aplicar a los elementos

Valor de retorno

El último iterador iter en el rango especificado para el cual:

1) El rango [ first , iter ) es un heap con respecto a comp y proj .
2) El rango [ ranges:: begin ( r ) , iter ) es un heap con respecto a comp y proj .

Complejidad

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

1) ranges:: distance ( first, last )

Implementación posible

struct is_heap_until_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 I operator()(I first, S last, Comp comp = {}, Proj proj = {}) const
    {
        std::iter_difference_t<I> n{ranges::distance(first, last)}, dad{0}, son{1};
        for (; son != n; ++son)
        {
            if (std::invoke(comp, std::invoke(proj, *(first + dad)),
                                  std::invoke(proj, *(first + son))))
                return first + son;
            else if ((son % 2) == 0)
                ++dad;
        }
        return first + n;
    }
    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 ranges::borrowed_iterator_t<R>
        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_until_fn is_heap_until{};

Ejemplo

El ejemplo renderiza un vector dado como un árbol binario (balanceado).

#include <algorithm>
#include <cmath>
#include <iostream>
#include <iterator>
#include <vector>
void out(const auto& what, int n = 1)
{
    while (n-- > 0)
        std::cout << what;
}
void draw_bin_tree(auto first, auto last)
{
    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 auto size{std::ranges::distance(first, last)};
    const int m{static_cast<int>(std::ceil(std::log2(1 + size)))};
    for (int i{}; i != m; ++i)
        tier(i, m, first, last);
}
int main()
{
    std::vector<int> v{3, 1, 4, 1, 5, 9};
    std::ranges::make_heap(v);
    // probably mess up the heap
    v.push_back(2);
    v.push_back(6);
    out("v after make_heap and push_back:\n");
    draw_bin_tree(v.begin(), v.end());
    out("the max-heap prefix of v:\n");
    const auto heap_end = std::ranges::is_heap_until(v);
    draw_bin_tree(v.begin(), heap_end);
}

Salida:

v after make_heap and push_back: 
       9               
   ┌───┴───┐       
   5       4       
 ┌─┴─┐   ┌─┴─┐   
 1   1   3   2   
┌┴┐ ┌┴┐ ┌┴┐ ┌┴┐ 
6 
the max-heap prefix of v: 
   9       
 ┌─┴─┐   
 5   4   
┌┴┐ ┌┴┐ 
1 1 3 2

Véase también

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