Namespaces
Variants

std::ranges::is_heap

De fr.cppreference.net
 
 
Bibliothèque d'algorithmes
Algorithmes contraints et algorithmes sur plages (C++20)
Algorithmes contraints, par 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 la mémoire non initialisée
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 bool is_heap( 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 bool is_heap( R&& r, Comp comp = {}, Proj proj = {} );
(2) (depuis C++20)

Vérifie si la plage spécifiée représente 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 paire itérateur-sentinelle définissant l'intervalle des éléments à examiner
r - l' range des éléments à examiner
comp - comparateur à appliquer aux éléments projetés
proj - projection à appliquer aux éléments

Valeur de retour

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

Complexité

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

1) ranges:: distance ( first, last )

Implémentation possible

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

Exemple

#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("initialement, v:\n");
    for (auto i : v)
        std::cout << i << ' ';
    out('\n');
    if (!std::ranges::is_heap(v))
    {
        out("création du tas...\n");
        std::ranges::make_heap(v);
    }
    out("après make_heap, v:\n");
    for (auto t{1U}; auto i : v)
        std::cout << i << (std::has_single_bit(++t) ? " │ " : " ");
    out("\n" "l'arbre binaire correspondant est :\n");
    draw_heap(v);
}

Sortie :

initialement, v :
3 1 4 1 5 9 2 6 5 3 5 8 9 7 9 3 2 3 8
construction du tas...
après make_heap, v :
9 │ 8 9 │ 6 5 8 9 │ 3 5 3 5 3 4 7 2 │ 1 2 3 1
l'arbre binaire correspondant est :
               9
       ┌───────┴───────┐
       8               9
   ┌───┴───┐       ┌───┴───┐
   6       5       8       9
 ┌─┴─┐   ┌─┴─┐   ┌─┴─┐   ┌─┴─┐
 3   5   3   5   3   4   7   2
┌┴┐ ┌┴┐ ┌┴┐ ┌┴┐ ┌┴┐ ┌┴┐ ┌┴┐ ┌┴┐
1 2 3 1

Voir aussi

trouve le plus grand sous-intervalle qui est un tas max
(objet fonction d'algorithme)
crée un tas max à partir d'un intervalle d'éléments
(objet fonction d'algorithme)
ajoute un élément à un tas max
(objet fonction d'algorithme)
supprime le plus grand élément d'un tas max
(objet fonction d'algorithme)
transforme un tas max en un intervalle trié d'éléments
(objet fonction d'algorithme)
(C++11)
vérifie si l'intervalle donné est un tas max
(modèle de fonction)