From cppreference.com
Defined in header
Call signature
template<std::random_access_iteratorI,std::sentinel_for<I>S,classComp=ranges::less,classProj=std::identity>requiresstd::sortable<I,Comp,Proj>constexprIsort_heap(Ifirst,Slast,Compcomp={},Projproj={}); (1) (since C++20)template<ranges::random_access_rangeR,classComp=ranges::less,classProj=std::identity>requiresstd::sortable<ranges::iterator_t<R>,Comp,Proj>constexprranges::borrowed_iterator_t<R>sort_heap(R&&r,Compcomp={},Projproj={}); (2) (since C++20)
the elements in the specified range with respect to comp and proj, where the range originally represents a
with respect to comp and proj. The sorted range no longer maintains the heap property.
1) The specified range is [first, last).
2) The specified range is r.
If the specified range is not a heap with respect to comp and proj, the behavior is undefined.
The function-like entities described on this page are
(informally known as niebloids), that is:
Explicit template argument lists cannot be specified when calling any of them.
None of them are visible to
.
When any of them are found by
as the name to the left of the function-call operator,
is inhibited.
Parameters
first, last - the iterator-sentinel pair defining the
of elements to modify r - the
of elements to modify comp - comparator to apply to the projected elements proj - projection to apply to the elements Return value
1)last
2)ranges::end(r)
Complexity
At most 2N⋅log(N) applications of comp and 4N⋅log(N) applications of proj, where N is:
1)ranges::distance(first,last)
2)ranges::distance(r)
Possible implementation
structsort_heap_fn{template<std::random_access_iteratorI,std::sentinel_for<I>S,classComp=ranges::less,classProj=std::identity>requiresstd::sortable<I,Comp,Proj>constexprIoperator()(Ifirst,Slast,Compcomp={},Projproj={})const{autoret{ranges::next(first,last)};for(autolast{ret};first!=last;--last)ranges::pop_heap(first,last,comp,proj);returnret;}template<ranges::random_access_rangeR,classComp=ranges::less,classProj=std::identity>requiresstd::sortable<ranges::iterator_t<R>,Comp,Proj>constexprranges::borrowed_iterator_t<R>operator()(R&&r,Compcomp={},Projproj={})const{return(*this)(ranges::begin(r),ranges::end(r),std::move(comp),std::move(proj));}};inlineconstexprsort_heap_fnsort_heap{};Example
Run this code
#include<algorithm>#include<array>#include<iostream>voidprint(autoconst&rem,constauto&v){std::cout<<rem;for(constautoi:v)std::cout<<i<<' ';std::cout<<'\n';}intmain(){std::arrayv{3,1,4,1,5,9};print("original array: ",v);std::ranges::make_heap(v);print("after make_heap: ",v);std::ranges::sort_heap(v);print("after sort_heap: ",v);}Output:
original array: 3 1 4 1 5 9 after make_heap: 9 5 4 1 1 3 after sort_heap: 1 1 3 4 5 9 See also
(C++20)
checks if the given range is a max heap
(algorithm function object)
(C++20)
finds the largest subrange that is a max heap
(algorithm function object)
(C++20)
creates a max heap out of a range of elements
(algorithm function object)
(C++20)
removes the largest element from a max heap
(algorithm function object)
(C++20)
adds an element to a max heap
(algorithm function object)
turns a max heap into a range of elements sorted in ascending order
(function template)