Namespaces
Variants

std::ranges::is_heap_until

Depuis fr.cppreference.net
 
 
Bibliothèque d'algorithmes
Algorithmes contraints et algorithmes sur plages (C++20)
Algorithmes contraints, p. ex. ranges::copy, ranges::sort, ...
Opérations de séquence non modifiantes    
Opérations par lots
(C++17)
Opérations de recherche
Opérations de séquence modifiantes
Opérations de copie
(C++11)
(C++11)
Opérations d'échange
Opérations de transformation
Opérations de génération
Opérations de suppression
Opérations de changement d'ordre
(jusqu'à C++17)(C++11)
(C++20)(C++20)
Opérations d'échantillonnage
(C++17)

Opérations de tri et connexes
Opérations de partitionnement
(C++11)    

Opérations de tri
Opérations de recherche binaire
(sur plages partitionnées)
Opérations d'ensemble (sur plages triées)
Opérations de fusion (sur plages triées)
Opérations de tas
Opérations minimum/maximum
(C++11)
(C++17)
Opérations de comparaison lexicographique
Opérations de permutation


 
Algorithmes contraints
Tous les noms de ce menu appartiennent à l'espace de noms std::ranges
Opérations de séquence non modifiantes
Opérations de séquence modifiantes
Opérations de partitionnement
Opérations de tri
Opérations de recherche binaire (sur plages triées)
       
       
Opérations d'ensemble (sur plages triées)
Opérations de tas
Opérations minimum/maximum
       
       
Opérations de permutation
Opérations de pliage
Opérations sur le stockage non initialisé
Types de retour
 
Défini dans l'en-tête <algorithm>
Signature d'appel
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) (depuis 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) (depuis C++20)

Dans la plage spécifiée, trouve la plus longue plage commençant au début de la plage spécifiée et représentant un tas par rapport à comp et proj.

1) La plage spécifiée est [firstlast).
2) La plage spécifiée est r.

Les entités de type fonction décrites sur cette page sont des objets fonctions d'algorithme (informellement appelés niebloids), c'est-à-dire :

Paramètres

first, last - la plage d'éléments à examiner
r - la plage d'éléments à examiner
pred - prédicat à appliquer aux éléments projetés
proj - projection à appliquer aux éléments

Valeur de retour

Le dernier itérateur iter dans la plage spécifiée pour lequel :

1) La plage [ first , iter ) est un tas par rapport à comp et proj .
2) La plage [ ranges:: begin ( r ) , iter ) est un tas par rapport à comp et proj .

Complexité

O(N) applications de comp et de proj , où N est :

1) ranges:: distance ( premier, dernier )

Implémentation possible

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{};

Exemple

L'exemple affiche un vecteur donné sous forme d' arbre binaire (équilibré).

#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);
}

Sortie :

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

Voir aussi

vérifie si la plage donnée est un tas maximum
(objet fonction d'algorithme)
crée un tas maximum à partir d'une plage d'éléments
(objet fonction d'algorithme)
ajoute un élément à un tas maximum
(objet fonction d'algorithme)
supprime le plus grand élément d'un tas maximum
(objet fonction d'algorithme)
transforme un tas maximum en une plage d'éléments triés
(objet fonction d'algorithme)
trouve la plus grande sous-plage qui est un tas maximum
(modèle de fonction)