Namespaces
Variants

std::is_heap_until

От ru.cppreference.net
 
 
Библиотека алгоритмов
Ограниченные алгоритмы и алгоритмы над диапазонами (C++20)
Ограниченные алгоритмы, например ranges::copy, ranges::sort, ...
Операции последовательности, не изменяющие её    
Пакетные операции
(C++17)
Операции поиска
Операции последовательности, изменяющие её
Операции копирования
(C++11)
(C++11)
Операции обмена
Операции преобразования
Операции генерации
Операции удаления
Операции изменения порядка
(до C++17)(C++11)
(C++20)(C++20)
Операции выборки
(C++17)

Сортировка и связанные операции
Операции разбиения
(C++11)    

Операции сортировки
Операции бинарного поиска
(по разделённым диапазонам)
Операции над множествами (на отсортированных диапазонах)
Операции слияния (на отсортированных диапазонах)
Операции с кучей
Операции минимума/максимума
(C++11)
(C++17)
Операции лексикографического сравнения
Операции перестановок


Политики выполнения(C++17)
(только для пояснения*)(C++26)

Числовые операции
(C++11)
(C++17)
(C++17)    

Специализированные <memory> алгоритмы

Специализированные <random> алгоритмы
Библиотека C









 
Определено в заголовочном файле<algorithm>
template< class RandomIt >
RandomIt is_heap_until( RandomIt first, RandomIt last );
(1) (начиная с C++11)
(constexpr начиная с C++20)
template< class ExecutionPolicy, class RandomIt >
RandomIt is_heap_until( ExecutionPolicy&& policy,
                        RandomIt first, RandomIt last );
(2) (начиная с C++17)
template< class RandomIt, class Compare >
RandomIt is_heap_until( RandomIt first, RandomIt last, Compare comp );
(3) (начиная с C++11)
(constexpr начиная с C++20)
template< class ExecutionPolicy, class RandomIt, class Compare >
RandomIt is_heap_until( ExecutionPolicy&& policy,
                        RandomIt first, RandomIt last, Compare comp );
(4) (начиная с C++17)

Исследует диапазон [first, last) и находит наибольший диапазон, начиная с first который является кучей.

1) Проверяемое свойство кучи задаётся с помощью operator<(до C++20)std::less{}(начиная с C++20).
3) Проверяемое свойство кучи задаётся с помощью comp.
2,4) То же, что и (1,3), но выполняется согласно policy.
Эти перегрузки участвуют в разрешении перегрузки только если значение следующего выражения равно true:

std::is_execution_policy_v<std::decay_t<ExecutionPolicy>>

(до C++20)

std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>>

(начиная с C++20)

Параметры

first, last - пара итераторов, определяющих диапазон элементов для исследования
policy - политика выполнения для использования
comp - объект функции сравнения (т.е. объект, удовлетворяющий требованиям Compare), который возвращает true, если первый аргумент меньше второго.

Сигнатура функции сравнения должна быть эквивалентна следующей:

bool cmp(const Type1& a, const Type2& b);

Хотя сигнатура не обязательно должна содержать const&, функция не должна изменять переданные ей объекты и должна принимать все значения типа (возможно, const) Type1 и Type2 независимо от категории значения (таким образом, Type1& не разрешено, также не разрешено Type1 за исключением случаев, когда Type1 перемещение эквивалентно копированию(начиная с C++11)).
Типы Type1 и Type2 должны быть такими, что объект типа RandomIt можно разыменовать и затем неявно преобразовать к обоим из них.

Требования к типам
-
RandomIt должен удовлетворять требованиям LegacyRandomAccessIterator.
-
Compare должен удовлетворять требованиям Compare.

Возвращаемое значение

Последний итератор it, для которого диапазон [first, it) является кучей.

Сложность

Пусть N равно std::distance(first, last):

1,2) O(N) сравнений с использованием operator<(до C++20)std::less{}(начиная с C++20).
3,4) O(N) применений функции сравнения comp.

Исключения

Перегрузки с параметром шаблона с именем ExecutionPolicy сообщают об ошибках следующим образом:

  • Если выполнение функции, вызванной как часть алгоритма, вызывает исключение, и ExecutionPolicy является одной из стандартных политик, вызывается std::terminate. Для любой другой ExecutionPolicy поведение определяется реализацией.
  • Если алгоритму не удаётся выделить память, генерируется std::bad_alloc.

Пример

#include <algorithm>
#include <iostream>
#include <vector>

int main()
{
    std::vector<int> v{3, 1, 4, 1, 5, 9};
    
    std::make_heap(v.begin(), v.end());
    
    // probably mess up the heap
    v.push_back(2);
    v.push_back(6);
    
    auto heap_end = std::is_heap_until(v.begin(), v.end());
    
    std::cout << "all of v:  ";
    for (const auto& i : v)
        std::cout << i << ' ';
    std::cout << '\n';
    
    std::cout << "only heap: ";
    for (auto i = v.begin(); i != heap_end; ++i)
        std::cout << *i << ' ';
    std::cout << '\n';
}

Вывод:

all of v:  9 5 4 1 1 3 2 6
only heap: 9 5 4 1 1 3 2

См. также

(C++11)
проверяет, является ли данный диапазон максимальной кучей
(шаблон функции & объект функции алгоритма)
создаёт максимальную кучу из диапазона элементов
(шаблон функции & объект функции алгоритма)
добавляет элемент в максимальную кучу
(шаблон функции & объект функции алгоритма)
удаляет наибольший элемент из максимальной кучи
(шаблон функции & объект функции алгоритма)
превращает максимальную кучу в диапазон элементов, отсортированных по возрастанию
(шаблон функции & объект функции алгоритма)
находит наибольший поддиапазон, являющийся максимальной кучей
(объект функции алгоритма)