Namespaces
Variants

std::ranges:: is_heap

From cppreference.net
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)
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
Minimum/maximum operations
Lexicographical comparison operations
Permutation operations
C library
Numeric operations
Operations on uninitialized memory
Constrained algorithms
All names in this menu belong to namespace std::ranges
Non-modifying sequence operations
Modifying sequence operations
Partitioning operations
Sorting operations
Binary search operations (on sorted ranges)
Set operations (on sorted ranges)
Heap operations
Minimum/maximum operations
Permutation operations
Fold operations
Operations on uninitialized storage
Return types
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 heap par rapport à comp et proj .

1) La plage spécifiée est [ first , last ) .
2) La plage spécifiée est r .

Les entités de type fonction décrites sur cette page sont des algorithm function objects (informellement appelées niebloids ), c'est-à-dire :

Table des matières

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 algorithme)
crée un tas max à partir d'une plage d'éléments
(objet fonction algorithme)
ajoute un élément à un tas max
(objet fonction algorithme)
supprime le plus grand élément d'un tas max
(objet fonction algorithme)
transforme un tas max en une plage d'éléments triés par ordre croissant
(objet fonction algorithme)
(C++11)
vérifie si la plage donnée est un tas max
(modèle de fonction)