堆 heap

堆也叫优先队列，堆是一种特殊的完全二叉树数据结
堆分为两种，最大堆，最小堆。
最大堆：根节点大于左右两个子节点的完全二叉树
最小堆：根节点小于左右两个子节点的完全二叉树
堆可以用数组来存储，
a[i]处存根节点，a[2 * i]存左子树的根节点 ; a[2 * i + 1]存右子树的根节点。i从1开始!!

实现

 #pragma once
#include<vector>
//using namespace std;

enum heaptype
{
	MAXHEAP, MINHEAP,
};
template<class T>
class Myheap
{

private:
	std::vector<T>_vecdata;
	int _size;//元素数量
	int _capacity;//整个堆的大小
	heaptype _type;
public:
	Myheap(T data[],int len,heaptype);
	Myheap(int capacity, heaptype);//一个空堆
	virtual ~Myheap();
	bool push(T data);
	bool pop(int index);
	void print();
	bool full()
	{
		if (_size >= _capacity)
		{
			return true;
		}
		return false;
	}
	bool empty()
	{
		//检查的是堆是否为空而不是_capacity的大小
		return _size == 0;
	}

private:
	void _swap(int i, int j);
	
	//元素下沉
	void _sink(int index);
	//元素上浮
	void _floating(int index);
};
template <class T>
Myheap<T>::Myheap(T data[], int len, heaptype type):_size(0),_capacity(len),_type(type)
{
	_vecdata.resize(_capacity);
	//将data数组中元素加入堆中
	for (int i = 0; i < len; i++)
		push(data[i]);	
}
template <class T>
Myheap<T>::Myheap(int capacity, heaptype type):_size(0),_capacity(capacity), _type(type)   //创建一个capacity空间大小的空堆
{
	_vecdata.resize(_capacity);
}
template <class T>
Myheap<T>::~Myheap()
{
	//vector自动析构
}
template<class T>
bool Myheap<T>::push(T data)
{
	if (full()){
		throw("The heap is full !!\n");
		return false;
	}
	else 
	{
		_vecdata[_size] = data;
		++_size;
		_floating(_size);
		//将当期位置的数据进行判断上浮(这里的位置从1开始算，而非0)
		//这是为了更方便计算左结点和右结点的位置
		//当前节点: i   左结点: 2i  右结点: 2i+1
		return true;
	}
}
template<class T>
void Myheap<T>::_floating(int index)
{
	//只有一个元素&空堆不需要进行操作
	if (_size == 1)
		return;
	if (_type == MINHEAP)
	{
		for (int i = index; i > 0; i *= 0.5)
		{
			//小根堆的上浮
			//大根堆判断条件相反
			if (_vecdata[i - 1] < _vecdata[i*0.5 - 1])
				_swap(i - 1, i*0.5 - 1);
			else
				break;
		}
	}
	else if(_type==MAXHEAP)
	{
		for (int i = index; i > 0; i *= 0.5)
		{
			//大根堆的上浮
			if (_vecdata[i - 1] > _vecdata[i*0.5 - 1])
				_swap(i - 1, i*0.5 - 1);
			else
				break;
		}
	}
	return;
}
template<class T>
void Myheap<T>::_swap(int i, int j)
{
	T temp = _vecdata[i];
	_vecdata[i] = _vecdata[j];
	_vecdata[j] = temp;
	return ;
}
template<class T>
void Myheap<T>::_sink(int index)
{
	int i = index;
	if (_type == MINHEAP)
	{
		while (i * 2 <= _size)
		{
			//与左结点比
			if (_vecdata[i - 1] > _vecdata[i * 2 - 1])
			{
				_swap(i - 1, i * 2 - 1);
				//交换后，index位置的结点与其右结点比
				if (i * 2 + 1 <= _size && _vecdata[i - 1] > _vecdata[i * 2])
					_swap(i - 1, i * 2);
				i = i * 2;
			}
			//与右结点比
			else if (i * 2 + 1 <= _size && _vecdata[i - 1] > _vecdata[i * 2])
			{
				_swap(i - 1, i * 2);
				i = i * 2 + 1;
			}
			else
				break;
		}
	}
	else if (_type == MAXHEAP)
	{
		while (i * 2 <= _size)
		{
			//与左结点比
			if (_vecdata[i - 1] < _vecdata[i * 2 - 1])
			{
				_swap(i - 1, i * 2 - 1);
				//交换后，index位置的结点与其右结点比
				if (i * 2 + 1 <= _size && _vecdata[i - 1]< _vecdata[i * 2])
					_swap(i - 1, i * 2);
				i = i * 2;
			}
			//与右结点比
			else if (i * 2 + 1 <= _size && _vecdata[i - 1] < _vecdata[i * 2])
			{
				_swap(i - 1, i * 2);
				i = i * 2 + 1;
			}
			else
				break;
		}
	}
}
template<class T>
void Myheap<T>::print() {
	for (int i=0;i<_size;i++)
		std::cout << _vecdata[i]<< " ";
	std::cout << endl;
	return;
}
template<class T>
bool  Myheap<T>::pop(int index)
{
	if (empty())
	{
		throw("This is an empty heap !!\n");
		return false;
	}
	_vecdata[index] = _vecdata[_size - 1];
	--_size  ;
	_sink(index+1);
	return true;
}

测试

 //堆也叫优先队列，堆是一种特殊的完全二叉树数据结
//堆分为两种，最大堆，最小堆。
//最大堆：根节点大于左右两个子节点的完全二叉树
//最小堆：根节点小于左右两个子节点的完全二叉树
//堆可以用数组来存储，
//a[i]处存根节点，a[2 * i]存左子树的根节点 ; a[2 * i + 1]存右子树的根节点。i从1开始!!

#include<iostream>
#include"Myheap.h"

using namespace std;
int main() 
{
	int minheapbuffer[10] = { 9,8,7,6,5,4,3,2,1,0 };
	int maxheapbuffer[10] = { 0,1,2,3,4,5,6,7,8,9 };
	Myheap<int>minheap(minheapbuffer,10,MINHEAP);
	Myheap<int>maxheap(maxheapbuffer, 10,MAXHEAP);
	//小顶堆
	minheap.print();
	minheap.pop(1);
	minheap.print();
	minheap.push(1);
	minheap.print();
	cout << endl;
	//大顶堆
	maxheap.print();
	maxheap.pop(0);
	maxheap.print();
	maxheap.push(10);
	maxheap.print();
	system("pause");
	return 0;
}

代码：
https://github.com/ChristmasError/Data_Structure/tree/master/堆 Heap