Simple use of C++ STL heap correlation function

A brief introduction to the use of heap related functions

Take the vector container as an example:
To simplify the code, the read and output of vector are packed into two functions

vector<int> get_input()
{
	int n;
	cin>>n;
	vector<int> nums; 
	for(int i=0; i<n; i++)
	{
		int x;
		cin>>x;
		nums.insert(nums.end(), x);
	}
	return nums;
}
void out(vector<int> nums)
{
	for(int i=0; i<nums.size(); i++)
	{
		cout<<nums[i]<<" ";
	}
	cout<<endl;
}

1. create heap

/*
function : Organize the data in the sequence container of the specified address segment into heaps according to the comparison rules
param 1  : Starting address of sequential container 
param 2  : End address of the sequential container 
param 3  : Compare function, use less < > by default, that is, to create a large top heap
return   : ---
*/
make_heap(param1, param2, param3);

Main function: use greater < int > to create a small top heap

make_heap(nums.begin(), nums.end(), greater<int>());

Result:

2. Add elements to the heap

Be careful:

1. The comparison rule at insert time (i.e. param3, comparison function) must be the same as at heap creation time, or a heap can only use the same comparison rule
2. The new element should be the last element, so you only need to call the push back of the corresponding container, and then call the push heap to insert the new element into the push

/*
function : Inserts [last] data from the sequence container of the specified address segment into the previous heap
param 1  : Starting address of sequential container 
param 2  : End address of the sequential container 
param 3  : Compare function, use less < > by default, i.e. insert large top heap
return   : ---
*/
push_heap(param1, param2, param3);

Main function: insert a new element into the organized heap

make_heap(nums.begin(), nums.end(), greater<int>());
nums.push_back(6);
push_heap(nums.begin(), nums.end(), greater<int>());

Result:

3. Delete the top element

Be careful

1. Because there is an adjustment action after removing the heap top element, it requires that the comparison rule (i.e. param3, comparison function) must be the same as when the heap is created, or that a heap can only use the same comparison rule
2. Pop heap only exchanges the elements to the end, but does not move out of the container. Finally, you need to call the pop back of the container to remove the last element

/*
function : Put the [first] data in the sequence container of the specified address segment last, and then reorganize the previous data into a heap
param 1  : Starting address of sequential container
param 2  : End address of the sequential container 
param 3  : Compare function, use less < > by default, delete and adjust large top heap
return   : ---
*/
pop_heap(param1, param2, param3);

Main function: remove top element

make_heap(nums.begin(), nums.end(), greater<int>());
nums.push_back(6);
push_heap(nums.begin(), nums.end(), greater<int>());
pop_heap(nums.begin(), nums.end(), greater<int>());
nums.pop_back();

Result:

4. Judge whether the sequence is a heap

Be careful:
When a function is called, the comparison rule (param3, comparison function) must be the same as when the heap is created, or a heap can only use the same comparison rule

/*
function : Determine whether the sequence container satisfies the properties of the heap
param 1  : Starting address of sequential container 
param 2  : End address of the sequential container
param 3  : Compare function, using less < > by default, to determine whether the large heap is satisfied
return   :  true or false
*/
is_heap(param1, param2, param3);

5. heap sort

By constantly exchanging the heap top elements to the end of the sequence, and then adjusting the front heap, because the heap top elements have polarity (maximum or minimum), the final sequence is a sorted sequence

• If it's a large top heap, it's sorted in ascending order
• If it's a small top heap, it's sorted in descending order

/*
function : Heap the sequence container of the specified address segment
param 1  : Starting address of sequential container
param 2  : End address of the sequential container 
param 3  : The comparison function uses less < > by default. After sorting the big top heap, it is in ascending order
return   : ---
*/
sort_heap(param1, param2, param3);

Main function: heap sort

make_heap(nums.begin(), nums.end(), greater<int>());
sort_heap(nums.begin(), nums.end(), greater<int>());

Result: the small top heap created is sorted in descending order

Complete code

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

using namespace std;

vector<int> get_input()
{
	int n;
	cin>>n;
	vector<int> nums; 
	for(int i=0; i<n; i++)
	{
		int x;
		cin>>x;
		nums.insert(nums.end(), x);
	}
	return nums;
}

void out(vector<int> nums)
{
	for(int i=0; i<nums.size(); i++)
	{
		cout<<nums[i]<<" ";
	}
	cout<<endl;
}

int main()
{
	vector<int> nums = get_input();		
	/*
	Fill in the code in the [main function] section above 
	*/
	out(nums);

	return 0;
}