模板库-最大堆的实现

MinHeap.h

/*
 * MinHeap.h
 *
 *  Created on: 2011-9-21
 *      Author: brunie
 */

#ifndef MINHEAP_H_
#define MINHEAP_H_

#include <iostream>
#include <cstdlib>
using namespace std;

#define  STEP 500

template<class T>
struct Less
{
		bool operator()(T &a, T &b)
		{
			return a < b;
		}
};

template<class T, class Compare = Less<T> >
class MinHeap
{
	public:
		MinHeap();

		MinHeap(int n);

		MinHeap(T *array, int n);

		virtual~MinHeap();

		void Initialize();

		bool Insert(const T &x);

		bool DeleteMin(T &x);

		int Size();

		int Sort();

	private:

		bool allocator(T* &heap, int n);

		int copy(T *src, T* des, int n);

		int size;
		int MaxSize;
		T 	*heap;

};



template<class T, class Compare>
MinHeap<T, Compare>::MinHeap()
{
	MaxSize = STEP;
	size = 0;
	heap = new T[size + 1];
}

template<class T, class Compare>
MinHeap<T, Compare>::MinHeap(int n)
{
	MaxSize = n;
	size = 0;
	heap = new T[size + 1];
}

template<class T, class Compare>
MinHeap<T, Compare>::MinHeap(T *array, int n)
{
	MaxSize = STEP;
	if(n > MaxSize)
	{
		do{
			MaxSize += STEP;
		}while(MaxSize < n);
	}
	allocator(heap, MaxSize);
	copy(array, heap, n);
	size = n;
}

template<class T, class Compare>
MinHeap<T, Compare>::~MinHeap()
{
	if (NULL != heap)
		delete heap;
	heap = NULL;
}

template<class T, class Compare>
bool MinHeap<T, Compare>::allocator(T* &heap, int n)
{
	heap = new T[n];
	if(NULL != heap)
		return true;
	return false;
}

template<class T, class Compare>
int MinHeap<T, Compare>::copy(T *src, T* des, int n)
{
	int i;
	for (i = 1; i <= n; i++)
		des[i] = src[i];
	return n;
}

template<class T, class Compare>
void MinHeap<T, Compare>::Initialize()
{
	int i;
	for (i = size / 2; i >= 1; i--)
	{
		T y = heap[i]; // root of subtree

		int c = 2 * i; // parent of c is target
		// location for y
		while (c <= size)
		{
			if (c < size && Compare(heap[c + 1], heap[c]))
				c++;

			if(!Compare(heap[c], y))
				break;

			heap[c / 2] = heap[c];
			c *= 2;
		}
		heap[c / 2] = y;
	}
}

template<class T, class Compare>
bool MinHeap<T, Compare>::Insert(const T &x)
{
	if (size == MaxSize)
	{
		T *tmp = heap;
		if(!allocator(heap, MaxSize + STEP))
			return false;
		MaxSize += STEP;
		copy(tmp, heap, size);
	}

	int i = ++size;
	while (i != 1 && Compare(x , heap[i/2]))
	{
		heap[i] = heap[i/2];
		i /= 2;
	}
	heap[i] = x;

	return true;
}

template<class T, class Compare>
bool MinHeap<T, Compare>::DeleteMin(T &x)
{
	if (size == 0)
	return false;

	x = heap[1];

	T y = heap[size--];

	int i = 1,ci = 2;
	while (ci <= size)
	{
		if (ci < size && Compare(i, ci))  //Compare(heap[ci + 1], heap[ci])
			ci++;

		if(!Compare(heap[ci], y))
			break;

		heap[i] = heap[ci];
		i = ci;
		ci *= 2;
	}
	heap[i] = y;

	return true;
}

template<class T, class Compare >
int MinHeap<T, Compare>::Size()
{
	return size;
}

template<class T, class Compare >
int MinHeap<T, Compare>::Sort()
{
	int i;
	T x;
	for(i = 1; i < size; i++)
	{
		DeleteMin(x);
		heap[size - i + 1] = x;
	}
	return size;
}

#endif /* MINHEAP_H_ */

Main.cpp

/*
 * Main.cpp
 *
 *  Created on: 2011-9-21
 *      Author: brunie
 */

#include "MinHeap.h"

int main()
{
	MinHeap<int> *heap = new MinHeap<int>();
	int i;
	for (i = 10; i > 0; i--)
		heap->Insert(i);
	int n;
	for (i = 1; i < 11; i++)
	{
		heap->DeleteMin(n);
		cout<<" "<<n;
	}

	return 0;
}