C++ Algorithm pop_heap()

C++ Algorithm pop_heap() function is used to swap the value in the position ?first? and the value in the position ?last-1? and makes the sub range [first, last-1) into a max heap. It has the effect of removing the first (largest) element from the heap defined by the range [first, last).

Elements are compared using operator < for the first version or using the given binary comparison function comp for the second version.

Note: A max heap is a range of elements [first, last) that has the following properties:

N = last - first, for all 0 < i < N, f [floor (i-1, 2)] does not compare less than f[i].
a new element can be added using std::push_heap()
the first element can be removed using std::pop_heap()

Syntax

default (1)     template <class RandomAccessIterator>
                         void pop_heap (RandomAccessIterator first, RandomAccessIterator last);

custom (2)    template <class RandomAccessIterator, class Compare>
                       void pop_heap (RandomAccessIterator first, RandomAccessIterator last,
                                                Compare comp);

Parameter

first: A random access iterator pointing to the first element in the heap.

last: A random access iterator pointing to the past last element in the heap.

comp: A user-defined binary predicate function that accepts two arguments and returns true if the two arguments are in order otherwise, it returns false. It follows the strict weak ordering to order the elements.

Return value

None

Complexity

Complexity is up to twice logarithmic in the distance between first and last: compares elements and potentially swaps (or moves) them until rearranges as a longer heap.

Data races

Some of the objects in the range [first, last) are modified.

Exceptions

This function throws an exception if any of element comparison, the element swapping, or an operation on iterator throws an exception.

Note: The invalid parameters cause an undefined behavior.

Example 1

Let's see the simple example to demonstrate the use of pop_heap():

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

using namespace std;

int main(){
   const int SIZE = 10;
   int a[ SIZE ] = { 13, 10, 152, 77, 22, 31, 1, 98, 13, 40 };
   int j;
   vector< int > v
   ( a, a + SIZE ), v2;

   make_heap( v.begin(), v.end() );
   sort_heap( v.begin(), v.end() );

   for ( j=0; j < SIZE; j++ ) 
{
      v2.push_back( a[ j ] );
      push_heap( v2.begin(), v2.end() );      
   }
   
   for ( j = 0; j < v2.size(); j++ ) 
{
      cout << "\nv2 after " << v2[ 0 ] << " popped from heap\n";
      pop_heap( v2.begin(), v2.end() - j );
   }

   cout << endl;
   return 0;
}

Output:

v2 after 152 popped from heap

v2 after 98 popped from heap

v2 after 77 popped from heap

v2 after 40 popped from heap

v2 after 31 popped from heap

v2 after 22 popped from heap

v2 after 13 popped from heap

v2 after 13 popped from heap

v2 after 10 popped from heap

v2 after 1 popped from heap

Example 2

Let's see another simple example:

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

using namespace std;
 
int main()
{
    vector<int> v { 3, 1, 4, 1, 5, 9 };
 
    make_heap(v.begin(), v.end());
 
    cout << "v: ";
    for (auto i : v) cout << i << ' ';
    cout << '\n';
 
    pop_heap(v.begin(), v.end()); // moves the largest to the end
 
    cout << "after pop_heap: ";
    for (auto i : v) cout << i << ' ';
    cout << '\n';
 
    int largest = v.back();
    v.pop_back();  // actually removes the largest element
    cout << "largest element: " << largest << '\n';
 
    cout << "heap without largest: ";
    for (auto i : v) cout << i << ' ';
    cout << '\n';
    
    return 0;
}

Output:

v: 9 5 4 1 1 3 
after pop_heap: 5 3 4 1 1 9 
largest element: 9
heap without largest: 5 3 4 1 1

Example 3

Let's see another simple example:

#include <iostream>
#include <vector>
#include <deque>
#include <list>
#include <set>
#include <map>
#include <string>
#include <algorithm>
#include <iterator>
#include <functional>
#include <numeric>

/* PRINT_ELEMENTS()
 * - prints optional C-string optcstr followed by
 * - all elements of the collection coll
 * - separated by spaces
 */
template <class T>
inline void PRINT_ELEMENTS (const T& coll, const char* optcstr="")
{
    typename T::const_iterator pos;

    std::cout << optcstr;
    for (pos=coll.begin(); pos!=coll.end(); ++pos) {
        std::cout << *pos << ' ';
    }
    std::cout << std::endl;
}

/* INSERT_ELEMENTS (collection, first, last)
 * - fill values from first to last into the collection
 * - NOTE: NO half-open range
 */
template <class T>
inline void INSERT_ELEMENTS (T& coll, int first, int last)
{
    for (int i=first; i<=last; ++i) {
        coll.insert(coll.end(),i);
    }
}


using namespace std;

int main()
{
    vector<int> coll;

    INSERT_ELEMENTS(coll,3,7);
    INSERT_ELEMENTS(coll,5,9);
    INSERT_ELEMENTS(coll,1,4);

    PRINT_ELEMENTS (coll, "on entry:           ");

    // convert collection into a heap
    make_heap (coll.begin(), coll.end());

    PRINT_ELEMENTS (coll, "after make_heap():  ");

    // pop next element out of the heap
    pop_heap (coll.begin(), coll.end());
    coll.pop_back();

    PRINT_ELEMENTS (coll, "after pop_heap():   ");

    return 0;    
}

Output:

on entry:           3 4 5 6 7 5 6 7 8 9 1 2 3 4 
after make_heap():  9 8 6 7 7 5 5 3 6 4 1 2 3 4 
after pop_heap():   8 7 6 7 4 5 5 3 6 4 1 2 3

Example 4

Let's see a simple example:

#include <vector>  
#include <algorithm>  
#include <functional>  
#include <iostream>  
  
int main( )  {  
   using namespace std;  
   vector <int> v1;  
   vector <int>::iterator Iter1, Iter2;  
  
   int i;  
   for ( i = 1 ; i <= 9 ; i++ )  
      v1.push_back( i );  
  
   // Make v1 a heap with default less than ordering  
   random_shuffle( v1.begin( ), v1.end( ) );  
   make_heap ( v1.begin( ), v1.end( ) );  
   cout << "The heaped version of vector v1 is ( " ;  
   for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )  
      cout << *Iter1 << " ";  
   cout << ")." << endl;  
  
   // Add an element to the back of the heap  
   v1.push_back( 10 );  
   push_heap( v1.begin( ), v1.end( ) );  
   cout << "The reheaped v1 with 10 added is ( " ;  
   for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )  
      cout << *Iter1 << " ";  
   cout << ")." << endl;  
  
   // Remove the largest element from the heap  
   pop_heap( v1.begin( ), v1.end( ) );  
   cout << "The heap v1 with 10 removed is ( " ;  
   for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )  
      cout << *Iter1 << " ";  
   cout << ")." << endl << endl;  
  
   // Make v1 a heap with greater-than ordering with a 0 element  
   make_heap ( v1.begin( ), v1.end( ), greater<int>( ) );  
   v1.push_back( 0 );  
   push_heap( v1.begin( ), v1.end( ), greater<int>( ) );  
   cout << "The 'greater than' reheaped v1 puts the smallest "  
        << "element first:\n ( " ;  
   for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )  
      cout << *Iter1 << " ";  
   cout << ")." << endl;  
  
   // Application of pop_heap to remove the smallest element  
   pop_heap( v1.begin( ), v1.end( ), greater<int>( ) );  
   cout << "The 'greater than' heaped v1 with the smallest element\n "  
        << "removed from the heap is: ( " ;  
   for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )  
      cout << *Iter1 << " ";  
   cout << ")." << endl;  
   
   return 0;
}

Output:

The heaped version of vector v1 is ( 9 7 8 5 1 6 3 2 4 ).
The reheaped v1 with 10 added is ( 10 9 8 5 7 6 3 2 4 1 ).
The heap v1 with 10 removed is ( 9 7 8 5 1 6 3 2 4 10 ).

The 'greater than' reheaped v1 puts the smallest element first:
 ( 0 1 3 4 2 6 8 5 9 10 7 ).
The 'greater than' heaped v1 with the smallest element
 removed from the heap is: ( 1 2 3 4 7 6 8 5 9 10 0 ).

Next TopicC++ Algorithm

← prev next →