二叉队列的实现

头文件：

/*
*A class for Minimum BinaryHeap
*writter:	flyaway
*Time:	2012.5.22
*description:
*	use the array to store data
*	This class provide public functions:
*	insert()
*	findMin()
* 	deleteMin()
*   isEmpty()
*   makeEmpty()
*/
#ifndef BinaryHeap_H
#define BinaryHeap_H

#include<iostream>
#include<vector>
using namespace std;
template< typename T >
class BinaryHeap
{
	public:
			explicit BinaryHeap(const int capacity = 100);
			explicit BinaryHeap(const vector< T > & item);
			bool isEmpty();
			T findMin() ;
			void insert(const T &k);
			void deleteMin();
			void makeEmpty();
			
	private:
			int currentsize;	//number of elements in heap
			vector< T > array;	//The heap array
			
			void buildHeap();
			void ShiftDown(int hole);
};

#endif

下面是具体的实现：

#include "BinaryHeap.h"
template< typename T >
BinaryHeap< T > ::BinaryHeap(const int capacity)
{
	currentsize = capacity;
	array.resize(capacity+10);
}



template< typename T >
BinaryHeap< T >::BinaryHeap(const vector< T > &item)
{
	int i;
	int n =  item.size();
	array.resize(n+1);
	currentsize = n;
	for(i = 0;i < n;++i)
	{
		array[i+1] = item[i];
	}
	buildHeap();
}


template< typename T >
void BinaryHeap< T > ::buildHeap()
{
	int i;
	for(i = currentsize/2;i >= 1;--i)
	{
		ShiftDown(i);
	}
}

template< typename T >
void BinaryHeap< T >::ShiftDown(int hole)
{
	T tmp = array[hole];
	int father = hole;
	int child ;
	for(;father * 2 <= currentsize;father = child)
	{
		//find the smller child
		child = father * 2; 
		if(child != currentsize && array[child] >  array[child+1])
		{
			child ++;
		}
		if(array[child] < tmp)
		{
			array[father] = array[child];
		}
		//find the right place and break out the loop
		else
		{
			break;
		}	
	}
	array[father] = tmp;
}




template< typename T >
T BinaryHeap< T >::findMin() 
{
	if(isEmpty())
	{
		cerr<<"Error! The Heap is empty!";
		exit(1);
	}
	else
	{
		return array[1];
	}
}


template< typename T >
bool BinaryHeap< T > ::isEmpty()
{
	return currentsize <= 0;
}

template< typename T >
void BinaryHeap< T > ::insert(const T &k)
{
	++currentsize;
	int father = currentsize/2;
	int child = currentsize;
	for(;father > 0 && array[father] > k;)
	{
		array[child] = array[father];
		child = father;
		father = child / 2; 
	}
	if(father == 0)
	{
		array[1] = k;
	}
	else
	{
		array[father] = k;
	}
}




template< typename T >
void BinaryHeap< T > ::deleteMin()
{
	array[1] = array[currentsize--];
	ShiftDown(1);
}



template< typename T >
void BinaryHeap< T >::makeEmpty()
{
	array.clear();
	currentsize = 0;
}

作者博客： 点击打开链接