堆（插入,删除）

首先呢，先来了解一个何为堆？

堆数据结构是一种数组对象，它可被视为一棵完全二叉树结构。

堆结构的二叉树存储是：

最大堆：每个父节点的都大于孩子节点

最小堆：每个父节点的都小于孩子节点

最大堆：a[] = {19,17,18,14,16,13,15,12,10,11}

最小堆：a[] = {10,11,13,12,16,18,15,17,14,19}

代码实现最大堆：

#pragma once
#include <iostream>
#include <assert.h>
#include <vector>

using namespace std;

template <class T>
class Heap
{
public:
	Heap()   //无参构造函数
	{}

	Heap(T* a,size_t size)
	{
		for(size_t i=0;i<size;++i)
		{
			_a.push_back(a[i]);
		}
		//建堆
		for(int i=(_a.size()-2)/2;i>=0;--i)
		{
			_ApDown(i);
		}
	}

	void Push(const T& x)//插入元素
	{
		_a.push_back(x);//在堆尾插入元素
		_ApHeapUp(_a.size()-1);	//向上调整	
	}

	void Pop()//删除(删除优先级高)
	{
		swap(_a[0],_a[_a.size()-1]);//交换堆的第一个元素和最后一个元素
		_a.pop_back();//删除最后一个元素
		_ApDown(0);//向下调整
	}

	size_t Size()//堆的大小
	{
		return _a.size();
	}

	bool Empty()//堆是否为空
	{
		return _a.empty();
	}

public:
	void _ApDown(size_t parent) 
	{
		size_t child = parent*2+1;
		
		while(child < _a.size())
		{
			//找到左右孩子中较大的       
			if((child+1) < _a.size() && _a[child+1] > _a[child]) 
			{
				++child;
			}
			//比较较大孩子与父亲
			if(_a[child] > _a[parent]) //（2）
			{
				swap(_a[child],_a[parent]);
				parent = child;
				child = parent*2+1;
			}
			else
			{
				break;
			}
		}
	}

	void _ApHeapUp(size_t child)
	{
		size_t parent = (child-1)/2;
		while(child > 0)
		{
			if(_a[child] > _a[parent])//比较孩子与父亲 （3）
			{
				swap(_a[child],_a[parent]);
				child = parent;
				parent = (child-1)/2;
			}
			else
			{
				break;
			}
		}
	}
	
protected:
	vector<T> _a;
};

若要实现最小堆，可将上述代码中(1)(2)(3)处的大于改为小于即可。

但是这样使得代码冗余，不容易维护。

那么如何用一个来实现即可建最大堆也可建最小堆呢？我们之前见的仿函数就用上场喽！

回顾一下什么是仿函数？

仿函数的机制就是通过对（）进行重载。

template <class T>
struct Less  //小于
{
	bool operator()(const T& l,const T& r)
	{
		return l < r;
	}
};

template <class T>
struct Greater  //大于
{
	bool operator()(const T& l,const T& r)
	{
		return l > r;
	}
};

template <class T,class Comper = Greater<T> >//默认建大堆
class Heap
{
public:
	Heap()   //无参构造函数
	{}

	Heap(T* a,size_t size)
	{
		for(size_t i=0;i<size;++i)
		{
			_a.push_back(a[i]);
		}
		//建堆
		for(int i=(_a.size()-2)/2;i>=0;--i)
		{
			_ApDown(i);
		}
	}

	void Push(const T& x)//插入元素
	{
		_a.push_back(x);//在堆尾插入元素
		_ApHeapUp(_a.size()-1);	//向上调整	
	}

	void Pop()//删除(删除优先级高)
	{
		swap(_a[0],_a[_a.size()-1]);//交换堆的第一个元素和最后一个元素
		_a.pop_back();//删除最后一个元素
		_ApDown(0);//向下调整
	}

	size_t Size()//堆的大小
	{
		return _a.size();
	}

	bool Empty()//堆是否为空
	{
		return _a.empty();
	}

public:
	void _ApDown(size_t parent) 
	{
		size_t child = parent*2+1;
		
		while(child < _a.size())
		{
			Comper com;
			//找到左右孩子中较大的
			if((child+1) < _a.size() && com(_a[child+1],_a[child]))
			{
				++child;
			}
			//比较较大孩子与父亲
			if(com(_a[child],_a[parent]))
			{
				swap(_a[child],_a[parent]);
				parent = child;
				child = parent*2+1;
			}
			else
			{
				break;
			}
		}
	}

	void _ApHeapUp(size_t child)
	{
		size_t parent = (child-1)/2;
		Comper com;
		while(child > 0)
		{
			if(com(_a[child],_a[parent]))//比较孩子与父亲
			{
				swap(_a[child],_a[parent]);
				child = parent;
				parent = (child-1)/2;
			}
			else
			{
				break;
			}
		}
	}
	
protected:
	vector<T> _a;
};

测试函数：

void Test1()
{
	int a[] = {10,16,18,12,11,13,15,17,14,19};
	//Heap<int> hp(a,sizeof(a)/sizeof(a[0]));  //默认建大堆
	Heap<int,Less<int> > hp1(a,sizeof(a)/sizeof(a[0])); //建小堆
}