优先队列（堆）

优先队列

和队列一样优先队列也支持入队和出队操作，不过区别在于优先队列的出队操作出队的是优先级最高的元素，这里以元素的大小来判定任务的优先级，越小，优先级越高。优先队列的模型如下图：

                 

基于这种优先队列的模型,我们可以多种方法对其进行实现,一种常用的方法就是使用链表以O(1)执行 插入操作,,遍历最小元素并删除花费O(N)时间。基于优先队列的插入操作一般情况下多于删除操作这一情况， 前者是一种较好的实现。

 二叉堆

二叉堆就结构性质上来说就是一个完全填满的二叉树，满足结构性和堆序性。结构性不必多说，就是完全二叉树应该满足的树结构。堆序性指的是：父节点的键值总是大于或等于（小于或等于）任何一个子节点的键值，且每个节点的左子树和右子树都是一个二叉堆（都是最大堆或最小堆）。

最大堆：当父节点的键值总是大于或等于任何一个子节点的键值。

最小堆：当父节点的键值总是小于或等于任何一个子节点的键值。

                     

结构性质

上面对二叉堆的结构性质略有提及，这里我们进行下详细说明。看看二叉堆是如何实现的。

                  

仔细观察上述完全二叉树的结构，我们可以发现的是对于任意一个位置i，其结点的左孩子在2i的位置，右孩子在2i+1的位置上，基于上述的性质我们可以使用数组来实现二叉堆。 如下图，堆大小的界限是13个元素。该数组有一个位置0。

           

由此，二叉堆可以使用一个数组和一个代表当前堆的大小的整数组成。如下所示为一个优先队列接口：

template <typename Comparable>
class BinaryHeap
{
    public:
		explicit BinaryHeap ( int capacity = 100 );
		explicit BinaryHeap ( const vector<Comparable> & items );
		
		bool isEmpty () const;
		const Comparable & findMin() const;

		void insert ( const Comparable & x);
		void deleteMin ();
		void deleteMin( Comparable & minItem);
		void makeEmpty ();

	private:
		int currentSize; // Number of elements in heap
		vector<Comparable> array; //The heap array;

		void buildHeap();
		void percolateDown( int hole );
} 

以上代码显示的是一个优先队列的架构。至于其提供的具体操作，我们先看看 二叉堆的堆序性。

堆序性

    简单的说保证优先队列的删除操作快速执行是堆序性质，基于这个特点我们需要找出最小元素，那么最小元素应该在根结点上，也就是最小堆。这样我们就能以常数时间执行 findMin()操作了。

二叉堆基本操作

基于二叉堆的堆序性，我们来看看二叉堆基本操作是如何实现的吧！

 insert(插入)

根据优先队列的模型，二叉堆实现的优先队列应该具备插入操作，不过根据其对序性具体的插入操作是如何进行的呢？看下面的演示：二叉堆插入元素14的情况。

              

                  

            

为将一个元素 X 插入到堆中，我们在下一个可用位置创建一个空穴，否则该堆将不是完全数。如果 X 可以放在该空穴中而不破坏堆的序，那么插入完成。否则，我们把空穴的父节点上的元素移入该空穴中，这样，空穴就朝着根的方向上冒一步。继续改过程直到 X 能被放入空穴中为止。这种实现过程称之为上滤（percolate up）：新元素在堆中上滤直到找出正确的插入位置。

实现代码： 

/*
 * Insert item x, allowing duplicates.
*/

void insert (const Comparable & x)
{
	if (currentSize == array.size() - 1)
	{
		array.resize( array.size() * 2 );
	}

	// Percolate up
	int hole = ++currentSize;
	for (; hole >1 && x < array[hole / 2]; hole /= 2)
	{
		array [hole] = array [hole / 2];
	}
	array [hole] = x;
}

可以知道的是当插入的元素小于堆中所有的元素的时候，必须上滤到根，插入时间为O(logN）

deleteMin(删除最小元)

当删除一个最小元时，要在根节点建立一个空穴。由于现在堆少了一个元素，因此堆中最后一个元素 X 必须移动到该堆的某个地方。如果 X 可以直接被放到空穴中，那么 deleteMin 完成。不过这一般不太可能，因此我们将空穴的两个儿子中比较小者移入空穴，这样就把空穴向下推了一层。重复该步骤直到 X 可以被放入空穴中。因此，我们的做法是将 X 置入沿着从根开始包含最小儿子的一条路径上的一个正确的位置。

演示过程如下:

                 

首先我们删除根元素13,建立一个空穴,之后判断元素31是否可以放入这个空穴中, 明显不能, 会破坏堆序性.

                  

之后我们选择较小的左儿子放入空穴,同时空穴下滑一层,之后判断31是否置于空穴中

               

同上,26置于空穴中,空穴下滑一层,31可以置于空穴中,过程结束。 这一种操作过程称之为下滤（percolate down）:空穴一步步下滑.

源码实现:

/*
* Remove the minimum item.
*/
void deleteMin( )
{
	if( isEmpty( ) )
		throw UnderflowException( );

    array[ 1 ] = array[ currentSize-- ];
    percolateDown( 1 );
}


/*
* Remove the minimum item and place it in minItem.
*/
void deleteMin( Comparable & minItem )
{
	if( isEmpty( ) )
		throw UnderflowException( );
	
	minItem = array[ 1 ];
    array[ 1 ] = array[ currentSize-- ];
    percolateDown( 1 );
}

/*
* Internal method to percolate down in the heap.
* hole is the index at which the percolate begins.
*/
void percolateDown( int hole )
{
	int child;
	Comparable tmp = array[ hole ];

	for( ; hole * 2 <= currentSize; hole = child )
	{
		child = hole * 2;
		if( child != currentSize && array[ child + 1 ] < array[ child ] )
		{
			child++;
		}
		if( array[ child ] < tmp < 0 )
		{
			array[ hole ] = array[ child ];
		}
		else
		{
			break;
		}
	}
	array[ hole ] = tmp;
}

优先队列其他操作

上面对二叉堆实现的优先队列的两个基本操作做了一些讲解。我们知道的是在将任务提交给优先队列的时候有时候我们需要根据实际情况修改任务的优先级。

  decreaseKey(降低关键字的值)

desreaseKey(p,m)操作降低在位置p处的值，降值幅度为正m，不过这种方式很可能破坏堆序性，因此需要通过上滤操作进行调整。这种方式能够动态的提高某个任务的优先级，使其在能够优先开始。 

increaseKey(降低关键字的值)

与上个操作相反，降低任务的优先级。

remove(删除)

remove(p)操作删除堆中位置p上的结点。这通过先先执行decreasekey(P，+ ∞)，然后执行deleteMin() 操作。这种操作的任务并不是正常终止的，而是被用户终止的。

构造二叉堆

上述讲了二叉堆的方式实现优先队列。那么一个二叉堆又是如何构造的呢？简单的我们可以认为它可以使用N个相继的insert操作来完成。每个insert操作都花费O(1)的平均时间以及最坏时间为O(logN)，所以则其构建为O（N）平均时间，其最坏情形时间为O(N*logN)。

更为常用的算法是先将N项以任意顺序放入树中，保持其结构性，之后再通过检查每个位置，通过下滤操作percolateDown(i) 使其满足堆序性。

        具体实现如下：

explicit BinaryHeap( const vector<Comparable> & items )
	: array ( items.size() + 10 ), currentSize (items.size() )  
	// set the size of array is items.size()+10, 
	// and set the number of elements (currentSize) is items.size()
{
	for( int i = 0; i < items.size(); i++ )
	{
		array[ i + 1 ] = item [ i ];  // copy from item[] to array[];
	}
	buildHeap();
}

void buildHeap()
{
	for( int i = currentSize / 2; i > 0; i-- )
		percolateDown( i );
}