堆&优先级队列

本文要点：

1.堆的实现

3.利用堆实现优先级队列

一、堆

1.堆是一种数组对象，可以被看作一颗完全二叉树结构，堆结构的二叉树存储是一种静态存储。

堆又被分为大堆和小堆：

大堆：每个父节点大于子节点

小堆：每个父节点小于子节点

2.堆的实现（以大堆为例）

实现一个堆主要在于要建堆和调整。

假设现有数组int a[] = { 10, 16, 18, 12, 11, 13, 15, 17, 14, 19 }，a的大堆表示

建堆：也就是将数字插入数组对象中（这里我们用迭代器实现）

调整：首先要从堆数组的尾部开始找到第一个非叶子结点，从该位置开始调整，将左右孩子以及父节点中大的放在父节点的位置，然后继续调整数组的前一个位置的数字。这种挑这个方式也叫做向下调整。

由于堆存在大顶堆和小顶堆两种结构，因此为了提高代码的复用性，这里我们用仿函数来实现

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

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

//堆
template<class T,class Compare = Greater<T>>	//默认为大堆
class Heap
{
public:
	Heap()
	{}
	Heap(T* a,int size)
	{
		assert(a);
		_heap.reserve(size);
		for(int i=0; i<size; ++i)
		{
			_heap.push_back(a[i]);
		}
		//建堆
		for (int j=(size-2)/2; j>=0; --j)	//从下向上，找到第一个非叶子结点
		{
			AdjustDown(j);
		}
	}
	void Push(const T& x)
	{
		_heap.push_back(x);			//在最后插入一个数字
		AdjustUp(_heap.size()-1);	//从最后插入数字的位置向上调整
	}
	void Pop()
	{
		assert(!_heap.empty());
		swap(_heap[0],_heap[_heap.size()-1]);	//交换堆顶与最后一个元素
		_heap.pop_back();	//删除最后一个元素(删除了堆顶的元素)
		AdjustDown(0);		//从第一个数向下调整
	}
	bool Empty()
	{
		return _heap.empty();
	}
	size_t Size()
	{
		size_t sz = _heap.size();
		return _heap.size();
	}
	const T& Top()
	{
		return _heap[0];
	}
	void Display()
	{
		for (size_t i=0; i<Size(); ++i)
		{
			cout<<_heap[i]<<" ";
		}
		cout<<endl;
	}
protected:
	void AdjustDown(int root)	//向下调整
	{
		int parent = root;
		size_t child = parent * 2 + 1;
		while (child < _heap.size())
		{
			Compare com;
			//选左右孩子中较大的一个
			/*if ((child+1) < _heap.size()
				&& _heap[child+1] > _heap[child])*/
			if ((child+1) < _heap.size()
				&& com(_heap[child+1],_heap[child]))
			{
				++child;
			}
			//选父节点与孩子节点中较大的一个
			/*if (_heap[child] > _heap[parent])*/
			if (com(_heap[child],_heap[parent]))
			{
				swap(_heap[parent],_heap[child]);
				parent = child;
				child = parent * 2 + 1;
			}
			else
				break;
		}
	}
	void AdjustUp(int child)		//向上调整
	{
		int parent = (child-1)/2;
		while(child > 0)
		{
			Compare com;
			//if (_heap[child] > _heap[parent])	//孩子结点大于父节点就交换
			if(com(_heap[child],_heap[parent]))
			{
				swap(_heap[child],_heap[parent]);
				child = parent;
				parent = (child-1)/2;
			}
			else
				break;
		}
	}
protected:
	vector<T> _heap;
};

二、优先级队列

优先级队列实现的操作有删除、插入，每次从队列中取出的都是具有最高优先级的元素。还是以上述数组为例，那么每次取最大的值就是取优先级最高的元素。

· 假如是一组无序数组，每次进行插入时，我们可以在数组的尾部直接插入，但是删除时就必须进行查找，找出最大的数以后才能删除这个数。那么，插入的时间复杂度为O(1)，删除的时间复杂度为O(N)

· 假如是一组有序数组，插入时需将插入的数x放到正确位置，时间复杂度为O(N)，删除时，可以直接删除数组的第一个元素（或最后一个元素），时间复杂度O(1)

但是这两种方法都不是最好的，当N值特别大时，这两种方法的效率都很低。因此我们借用堆特有的性质就可以实现优先级队列了！

删除：直接删除堆顶元素，然后进行向上调整使其重新称为一个大堆------O(N*lgN)

插入：插到堆数组最后，进行向下调整------O(N*lgN)

//优先级队列
template<class T,class Compare = Greater<T>>
class PriorityQueue
{
public:
	PriorityQueue(T* a,int size)
		:_pq(a,size)
	{}
	void Push(const T& x)
	{
		_pq.Push(x);
	}
	void Pop()
	{
		_pq.Pop();
	}
	const T& Top()
	{
		return _pq.Top();
	}
	void Display()
	{
		_pq.Display();
	}
protected:
	Heap<T,Compare> _pq;
};
void TestPriorityQueue()
{
	int a[] = { 10, 16, 18, 12, 11, 13, 15, 17, 14, 19 }; 
	int sz = sizeof(a)/sizeof(a[0]);
	PriorityQueue<int,Greater<int>> pq1(a,sz);
	cout<<"大堆： ";
	pq1.Display();
	cout<<"Top: "<<pq1.Top()<<endl;

	pq1.Push(30);
	cout<<"Push(30)： ";
	pq1.Display();

	pq1.Pop();
	cout<<"Pop()： ";
	pq1.Display();
}