heapSort之应用

写了一个类库，有两个版本：

版本一:

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

template <typename type> class Schedule
{
public:
	Schedule():cnt(0){}
	~Schedule(){}
	type GetMax();
	type ExtractMax();
	void Insert(type);
	bool empty();
	int size();
private:
	type scheme[1000000];
	int cnt;
	void BuildHeap();
	void Heapify(int);
	int GetLeftChild(int);
	int GetRightChild(int);
	int GetParent(int);
};

template<typename type> type Schedule<type>::GetMax()
{
	return scheme[1];
}

template<typename type> type Schedule<type>::ExtractMax()
{
	type val=scheme[1];
	scheme[1]=scheme[cnt--];
	Heapify(1);
	return val;
}

template<typename type> void Schedule<type>::Insert(type value)
{
	scheme[++cnt]=value;
	int curpos=cnt;
	int ppos=GetParent(curpos);
	while(ppos>0&&scheme[ppos]<scheme[curpos])
	{
		swap(scheme[ppos],scheme[curpos]);
		curpos=ppos;
		ppos=GetParent(curpos);
	}
}

template<typename type> int Schedule<type>::size()
{
	return cnt;
}

template<typename type> bool Schedule<type>::empty()
{
	return cnt==0;
}

template<typename type> void Schedule<type>::Heapify(int pos)
{
	int lt,rt,max;
	lt=GetLeftChild(pos);
	rt=GetRightChild(pos);
	max=pos;
	if(lt<=cnt&&scheme[lt]>scheme[max])
		max=lt;
	if(rt<=cnt&&scheme[rt]>scheme[max])
		max=rt;
	if(max!=pos)
	{
		swap(scheme[max],scheme[pos]);
		Heapify(max);
	}
}

template<typename type> void Schedule<type>::BuildHeap()
{
	for(int i=floor(cnt/2);i>0;--i)
	{
		Heapify(i);
	}
}

template<typename type> int Schedule<type>::GetLeftChild(int pos)
{
	return 2*pos; 
}

template<typename type> int Schedule<type>::GetRightChild(int pos)
{
	return 2*pos+1;
}

template<typename type> int Schedule<type>::GetParent(int pos)
{
	return floor(pos/2);
}

版本二（这个版本比较挫，不过没有空间限制了．．．而且是标准C++）

#include<iostream>
#include<vector>
#include<iterator>
#include<cmath>
#include<cstdlib>
using namespace std;

template <typename type> class Schedule
{
public:
	Schedule(){}
	~Schedule(){}
	type GetMax();
	type ExtractMax();
	void Insert(type);
	bool empty();
	int size();
private:
	vector<type> vec;
	void BuildHeap();
	void Heapify(typename vector<type>::iterator);
	typename vector<type>::iterator GetLeftChild(typename vector<type>::iterator);
	typename vector<type>::iterator GetRightChild(typename vector<type>::iterator);
	typename vector<type>::iterator GetParent(typename vector<type>::iterator);
};

template<typename type> type Schedule<type>::GetMax()
{
	return *vec.begin();
}

template<typename type> type Schedule<type>::ExtractMax()
{
	type val=*vec.begin();
	*vec.begin()=*(vec.end()-1);
	vec.pop_back();
	Heapify(vec.begin());
	return val;
}

template<typename type> void Schedule<type>::ViewAll()
{
	if(vec.size()==0)
	{
		cout<<"The schedule is empty."<<endl;
		exit(0);
	}
	for(typename vector<type>::iterator iter=vec.begin();iter!=vec.end();++iter)
	{
		cout<<*iter<<endl;
	}
}

template<typename type> void Schedule<type>::Insert(type value)
{
	vec.push_back(value);
	typename vector<type>::iterator iter=vec.end()-1;
	typename vector<type>::iterator pit=GetParent(iter);
	while(pit>=vec.begin()&&*pit<*iter)
	{
		swap(*pit,*iter);
		iter=pit;
		pit=GetParent(iter);
	}
}

template<typename type> int Schedule<type>::size()
{
	return vec.size();
}

template<typename type> bool Schedule<type>::empty()
{
	return vec.empty();
}

template<typename type> void Schedule<type>::Heapify(typename vector<type>::iterator iter)
{
	 typename vector<type>::iterator lt=GetLeftChild(iter);
	 typename vector<type>::iterator rt=GetRightChild(iter);
	 typename vector<type>::iterator max=iter;
         if(lt<vec.end()&&*lt>*max)
		max=lt;
	 if(rt<vec.end()&&*rt>*max)
		 max=rt;
	 if(max!=iter)
	 {
		 swap(*max,*iter);
		 Heapify(max);
	 }
}

template<typename type> void Schedule<type>::BuildHeap()
{
	 for(typename vector<type>::iterator it=vec.begin()+floor(vec.size()/2);it>=vec.begin();--it)
	 {
		 Heapify(it);
	 }
}

template<typename type> typename vector<type>::const_iterator Schedule<type>::GetLeftChild(typename vector<type>::iterator iter)
{
	return iter+(iter-vec.begin()+1);
}

template<typename type> typename vector<type>::iterator Schedule<type>::GetRightChild(typename vector<type>::iterator iter)
{
	return iter+(iter-vec.begin()+2);
}

template<typename type> typename vector<type>::iterator Schedule<type>::GetParent(typename vector<type>::iterator iter)
{
	return vec.begin()+floor((iter-vec.begin()+1)/2)-1;
}

剩下的还有其他的算法导论上都说的很清楚了．