C++大顶堆和小顶堆

原理

  堆数据结构是一种数组对象，它可以被视为一颗完全二叉树结构（或者也有可能是满二叉树）

大顶堆

  根结点（亦称为堆顶）的关键字是堆里所有结点关键字中最大者，称为大顶堆。大根堆要求根节点的关键字既大于或等于左子树的关键字值，又大于或等于右子树的关键字值。

小顶堆

  根结点（亦称为堆顶）的关键字是堆里所有结点关键字中最小者，称为小顶堆。小根堆要求根节点的关键字既小于或等于左子树的关键字值，又小于或等于右子树的关键字值。

大顶堆和小顶堆对比图

大顶堆和小顶堆的实现代码

heap.h

#pragma once
#include<iostream>
#include<assert.h>
#include<vector>
using namespace std;

template<class T>
struct Less
{
	bool operator()(const T& left, const T& right) const
	{
		return left < right;
	}
};

template<class T>
struct Greater
{
	bool operator()(const T& left, const T& right) const
	{
		return left > right;
	}
};


template<class T, class Compare = Less<T>>
class Heap
{
public:
	Heap()//无参的构造函数（系统不会给无参构造函数），开始堆是空的不需要做什么事
	{}
	Heap(T* a, size_t n)
	{
		_a.reserve(n);//开空间
		for (size_t i = 0; i < n; ++i)
		{
			_a.push_back(a[i]);

		}
		//建堆,找最后一个非叶子节点
		for (int i = (_a.size() - 2) / 2; i >= 0; --i)//不用size_t，因为i在这可能等于0，用size_t会死循环
		{
			AdjustDown(i);
		}
	}
	//向下调整
	void AdjustDown(int root)
	{
		Compare com;
		int parent = root;
		size_t child = parent * 2 + 1;//默认为左孩子
		while (child < _a.size())
		{
			//选出小孩子
			//if (child+1 > _a.size() && _a[child + 1]< _a[child])
			if (child + 1 < _a.size() && com(_a[child + 1], _a[child]))
			{
				++child;
			}

			//if (_a[child] < _a[parent])
			if (com(_a[child], _a[parent]))
			{
				swap(_a[child], _a[parent]);//交换值
				parent = child;
				child = parent * 2 + 1;
			}
			else
			{
				break;
			}
		}
	}
	//向上调整
	void AdjustUp(int child)
	{
		Compare com;
		int parent = (child - 1) / 2;
		while (parent >= 0)
		{
			//if (_a[child] < _a[parent])
			if (com(_a[child], _a[parent]))
			{
				swap(_a[parent], _a[child]);
				child = parent;
				parent = (child - 1) / 2;
			}
			else
			{
				break;
			}
		}

	}
	//最后插入
	void Push(const T&x)
	{
		_a.push_back(x);
		AdjustUp(_a.size() - 1);
	}
	//删除最大数
	void Pop()
	{
		assert(!_a.empty());
		swap(_a[0], _a[_a.size() - 1]);
		_a.pop_back();
		AdjustDown(0);

	}
	//取顶元素
	T& Top()
	{
		assert(!_a.empty());
		return _a[0];
	}
	size_t Size()
	{
		return _a.size();
	}

	bool Empty()
	{
		return _a.empty();
	}


private:
	vector<T> _a;

};

main.cpp

#include <iostream>
#include "heap.h"
using namespace std;

int main()
{
	int a[] = { 10,11,13,12,16,18,15,17,14,19 };
	// Heap<int,Greater<int>> hp1(a,sizeof(a)/sizeof(a[0])); 最大堆
	// Heap<int,Less<int>> hp1(a,sizeof(a)/sizeof(a[0])); 最小堆
	Heap<int> hp1(a, sizeof(a) / sizeof(a[0])); // 缺省，最小堆
	hp1.Push(15);
	system("pause");
	return 0;
}

vector和push_heap、pop_heap实现堆

建堆

vector<int> nums = {9, 6, 2, 4, 7, 0, 1, 8, 3, 5};

如何使用nums构建最大堆

make_heap(nums.begin(), nums.end());
//或
make_heap(nums.begin(), nums.end(), less<int>());

如何使用nums构建最小堆

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

调整堆

当使用上述的make_heap()建完堆后，如果vector使用push_back()插入数据或pop_back()删除数据后，会破坏最大堆/最小堆的性质，所以需要调整堆，常用push_heap()和pop_heap()两个方法。
1、push_heap()用法是，vector先push_back()，后push_heap()

nums.push_back(10);
push_heap(nums.begin(), nums.end(), less<int>());

2、pop_heap()用法是，先pop_heap()，vector后pop_back()

pop_heap(nums.begin(), nums.end(), less<int>());
nums.pop_back();

为什么pop_heap()的用法要反过来呢？
要从我们的目的来考虑，使用pop_heap()的绝大部分目的是要把堆顶元素pop出堆中，因为它最大或最小。如果先用vector的pop_back()，它删除的不是堆顶元素（nums[0]），而是vector的最后一个元素。可见这不是我们想要的结果：对于最大堆，最后一个元素既不是最大，也不一定是最小；对于最小堆，最后一个元素既不是最小，也不一定是最大。pop出来没有意义。
观察pop_heap()对堆做了什么？
pop_heap()把堆顶元素放到了最后一位，然后对它前面的数字重建了堆。这样一来只要再使用pop_back()把最后一位元素删除，就得到了新的堆。

priority_queue实现堆

priority_queue
对于这个模板类priority_queue，它是STL所提供的一个非常有效的容器。
作为队列的一个延伸，优先队列包含在头文件 中。

简述

优先队列时一种比较重要的数据结构，它是有二项队列编写而成的，可以以O(log n) 的效率查找一个队列中的最大值或者最小值，其中是最大值还是最小值是根据创建的优先队列的性质来决定的。

模板参数

优先队列有三个参数，其声明形式为：

priority_queue< type, container, function >

这三个参数，后面两个可以省略，第一个不可以。其中：
**type：**数据类型；
**container：**实现优先队列的底层容器；
**function：**元素之间的比较方式；
对于container，要求必须是数组形式实现的容器，例如vector、deque，而不能使list。
在STL中，默认情况下（不加后面两个参数）是以vector为容器，以 operator< 为比较方式，所以在只使用第一个参数时，优先队列默认是一个最大堆，每次输出的堆顶元素是此时堆中的最大元素。

成员函数

假设type类型为int，则：

1. bool empty() const 返回值为true，说明队列为空；
2. int size() const 返回优先队列中元素的数量；
3. void pop() 删除队列顶部的元素，也即根节点；
4. int top() 返回队列中的顶部元素，但不删除该元素；
5. void push(int arg) 将元素arg插入到队列之中。

大顶堆和小顶堆

#include <functional>

//构造一个空的优先队列（此优先队列默认为大顶堆）
priority_queue<int> big_heap;   
//另一种构建大顶堆的方法
priority_queue<int,vector<int>,less<int> > big_heap2; 

//构造一个空的优先队列,此优先队列是一个小顶堆
priority_queue<int,vector<int>,greater<int> > small_heap;