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>constexprIpop_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>pop_heap(R&&r,Compcomp={},Projproj={}); (2) (since C++20)Swaps the first element and the last element of the specified
with respect to comp and proj and makes the subrange excluding the first position into a heap with respect to comp and proj. This has the effect of removing the first element from the specified heap.
1) The specified heap is [first, last).
2) The specified heap is r.
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 2log(N) applications of comp and 4log(N) applications of proj, where N is:
1)ranges::distance(first,last)
2)ranges::distance(r)
Example
Run this code
#include<algorithm>#include<array>#include<iostream>#include<iterator>#include<string_view>template<classI=int*>voidprint(std::string_viewrem,Ifirst={},Ilast={},std::string_viewterm="\n"){for(std::cout<<rem;first!=last;++first)std::cout<<*first<<' ';std::cout<<term;}intmain(){std::arrayv{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(auton{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");}}Output:
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 ] See also
(C++20)
adds an element to a max heap
(algorithm function object)
(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)
turns a max heap into a sorted range of elements
(algorithm function object)
removes the largest element from a max heap
(function template)