std::ranges::pop_heap

template< std::random_access_iterator I, std::sentinel_for<I> S,
          class Comp = ranges::less, class Proj = std::identity >
    requires std::sortable<I, Comp, Proj>
constexpr I pop_heap( I first, S last, Comp comp = {}, Proj proj = {} );

template< ranges::random_access_range R,
          class Comp = ranges::less, class Proj = std::identity >
    requires std::sortable<ranges::iterator_t<R>, Comp, Proj>
constexpr ranges::borrowed_iterator_t<R>
    pop_heap( R&& r, Comp comp = {}, Proj proj = {} );

Échange le premier élément et le dernier élément du tas spécifié par rapport à comp et proj et transforme la sous-plage excluant la première position en un tas par rapport à comp et proj. Cela a pour effet de supprimer le premier élément du tas spécifié.

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

• Les listes d'arguments de modèle explicites ne peuvent pas être spécifiées lors de l'appel de l'un d'entre eux.
• Aucun d'entre eux n'est visible par recherche dépendante des arguments.
• Lorsque l'un d'entre eux est trouvé par recherche normale non qualifiée comme le nom à gauche de l'opérateur d'appel de fonction, la recherche dépendante des arguments est inhibée.

Paramètres

Valeur de retour

Complexité

Au plus \(\scriptsize 2\log{(N)}\) 2log(N) applications de comp et \(\scriptsize 4\log{(N)}\) 4log(N) applications de proj , où \(\scriptsize N \) N est :

Exemple

#include <algorithm>
#include <array>
#include <iostream>
#include <iterator>
#include <string_view>
template<class I = int*>
void print(std::string_view rem, I first = {}, I last = {},
           std::string_view term = "\n")
{
    for (std::cout << rem; first != last; ++first)
        std::cout << *first << ' ';
    std::cout << term;
}
int main()
{
    std::array v{3, 1, 4, 1, 5, 9, 2, 6, 5, 3};
    print("initially, v: ", v.cbegin(), v.cend());
    std::ranges::make_heap(v);
    print("make_heap, v: ", v.cbegin(), v.cend());
    print("convert heap into sorted array:");
    for (auto n {std::ssize(v)}; n >= 0; --n)
    {
        std::ranges::pop_heap(v.begin(), v.begin() + n);
        print("[ ", v.cbegin(), v.cbegin() + n, "]  ");
        print("[ ", v.cbegin() + n, v.cend(), "]\n");
    }
}

initially, v: 3 1 4 1 5 9 2 6 5 3
make_heap, v: 9 6 4 5 5 3 2 1 1 3
convert heap into sorted array:
[ 6 5 4 3 5 3 2 1 1 9 ]  [ ]
[ 5 5 4 3 1 3 2 1 6 ]  [ 9 ]
[ 5 3 4 1 1 3 2 5 ]  [ 6 9 ]
[ 4 3 3 1 1 2 5 ]  [ 5 6 9 ]
[ 3 2 3 1 1 4 ]  [ 5 5 6 9 ]
[ 3 2 1 1 3 ]  [ 4 5 5 6 9 ]
[ 2 1 1 3 ]  [ 3 4 5 5 6 9 ]
[ 1 1 2 ]  [ 3 3 4 5 5 6 9 ]
[ 1 1 ]  [ 2 3 3 4 5 5 6 9 ]
[ 1 ]  [ 1 2 3 3 4 5 5 6 9 ]
[ ]  [ 1 1 2 3 3 4 5 5 6 9 ]

Voir aussi