Przejdź do głównej zawartości

std::ranges::is_heap() algorithm

// (1)
constexpr bool is_heap( I first, S last, Comp comp = {}, Proj proj = {} );

// (2)
constexpr bool is_heap( R&& r, Comp comp = {}, Proj proj = {} );

The type of arguments are generic and have the following constraints:

  • I - std::random_access_iterator
  • S - std::sentinel_for<I>
  • R - std::ranges::random_access_range
  • Comp:
    • (1) - std::indirect_strict_weak_order<std::projected<I, Proj>>
    • (2) - std::indirect_strict_weak_order<std::projected<ranges::iterator_t<R>, Proj>>
  • Proj - (none)

The Proj and Comp template arguments have the following default types: std::identity, ranges::less for all overloads.

Checks if the elements in range [first; last) are a max heap.

  • (1) Elements are compared using the given binary comparison function comp and projection object proj.

  • (2) Same as (1), but uses r as the source range, as if using ranges::begin(r) as first and ranges::end(r) as last.

The function-like entities described on this page are niebloids.

Parameters

first
last

The range of elements to examine.

r

The range of elements to examine.

pred

Predicate to apply to the projected elements.

proj

The projection to apply to the elements.

Return value

true if the range is max heap, false otherwise.

Complexity

Linear in the distance between first and last.

Exceptions

(none)

Possible implementation

is_heap(1) and is_heap(2)
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 {};

Notes

A max heap is a range of elements [f; l), arranged with respect to comparator comp and projection proj, that has the following properties:

  • Given N as l - f, p = f[(i - 1) / 2], and q = f[i], for all 0 < i < N, the expression std::invoke(comp, std::invoke(proj, p), std::invoke(proj, q)) evaluates to false.
  • A new element can be added using ranges::push_heap, in O(log(N)) time.
  • The first element can be removed using ranges::pop_heap, in O(log(N)) time.

Examples

Main.cpp

#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(auto const& v);

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("initially, v:\n");
for (auto i : v) std::cout << i << ' ';
out('\n');

if (!std::ranges::is_heap(v))
{
out("making heap...\n");
std::ranges::make_heap(v);
}

out("after make_heap, v:\n");
for (auto t {1U}; auto i : v)
std::cout << i << (std::has_single_bit(++t) ? " │ " : " ");

out("\n" "corresponding binary tree is:\n");
draw_heap(v);
}

void draw_heap(auto const& 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());
}
Possible Output
initially, v:
3 1 4 1 5 9 2 6 5 3 5 8 9 7 9 3 2 3 8
making heap...
after make_heap, v:
9 │ 8 9 │ 6 5 8 9 │ 3 5 3 5 3 4 7 2 │ 1 2 3 1
corresponding binary tree is:
9
┌───────┴───────┐
8 9
┌───┴───┐ ┌───┴───┐
6 5 8 9
┌─┴─┐ ┌─┴─┐ ┌─┴─┐ ┌─┴─┐
3 5 3 5 3 4 7 2
┌┴┐ ┌┴┐ ┌┴┐ ┌┴┐ ┌┴┐ ┌┴┐ ┌┴┐ ┌┴┐
1 2 3 1
This article originates from this CppReference page. It was likely altered for improvements or editors' preference. Click "Edit this page" to see all changes made to this document.
Hover to see the original license.

std::ranges::is_heap() algorithm

// (1)
constexpr bool is_heap( I first, S last, Comp comp = {}, Proj proj = {} );

// (2)
constexpr bool is_heap( R&& r, Comp comp = {}, Proj proj = {} );

The type of arguments are generic and have the following constraints:

  • I - std::random_access_iterator
  • S - std::sentinel_for<I>
  • R - std::ranges::random_access_range
  • Comp:
    • (1) - std::indirect_strict_weak_order<std::projected<I, Proj>>
    • (2) - std::indirect_strict_weak_order<std::projected<ranges::iterator_t<R>, Proj>>
  • Proj - (none)

The Proj and Comp template arguments have the following default types: std::identity, ranges::less for all overloads.

Checks if the elements in range [first; last) are a max heap.

  • (1) Elements are compared using the given binary comparison function comp and projection object proj.

  • (2) Same as (1), but uses r as the source range, as if using ranges::begin(r) as first and ranges::end(r) as last.

The function-like entities described on this page are niebloids.

Parameters

first
last

The range of elements to examine.

r

The range of elements to examine.

pred

Predicate to apply to the projected elements.

proj

The projection to apply to the elements.

Return value

true if the range is max heap, false otherwise.

Complexity

Linear in the distance between first and last.

Exceptions

(none)

Possible implementation

is_heap(1) and is_heap(2)
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 {};

Notes

A max heap is a range of elements [f; l), arranged with respect to comparator comp and projection proj, that has the following properties:

  • Given N as l - f, p = f[(i - 1) / 2], and q = f[i], for all 0 < i < N, the expression std::invoke(comp, std::invoke(proj, p), std::invoke(proj, q)) evaluates to false.
  • A new element can be added using ranges::push_heap, in O(log(N)) time.
  • The first element can be removed using ranges::pop_heap, in O(log(N)) time.

Examples

Main.cpp

#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(auto const& v);

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("initially, v:\n");
for (auto i : v) std::cout << i << ' ';
out('\n');

if (!std::ranges::is_heap(v))
{
out("making heap...\n");
std::ranges::make_heap(v);
}

out("after make_heap, v:\n");
for (auto t {1U}; auto i : v)
std::cout << i << (std::has_single_bit(++t) ? " │ " : " ");

out("\n" "corresponding binary tree is:\n");
draw_heap(v);
}

void draw_heap(auto const& 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());
}
Possible Output
initially, v:
3 1 4 1 5 9 2 6 5 3 5 8 9 7 9 3 2 3 8
making heap...
after make_heap, v:
9 │ 8 9 │ 6 5 8 9 │ 3 5 3 5 3 4 7 2 │ 1 2 3 1
corresponding binary tree is:
9
┌───────┴───────┐
8 9
┌───┴───┐ ┌───┴───┐
6 5 8 9
┌─┴─┐ ┌─┴─┐ ┌─┴─┐ ┌─┴─┐
3 5 3 5 3 4 7 2
┌┴┐ ┌┴┐ ┌┴┐ ┌┴┐ ┌┴┐ ┌┴┐ ┌┴┐ ┌┴┐
1 2 3 1
This article originates from this CppReference page. It was likely altered for improvements or editors' preference. Click "Edit this page" to see all changes made to this document.
Hover to see the original license.