水完棧和佇列之後，感覺常用的優先佇列也不錯，內部的排序是堆排序，感覺也不是很難，就直接寫上了，但是實現的時候出現了一些問題，幸好有學長在旁邊，幫助我解決了問題，在此感謝LYG學長；

對於排序，仍然自定義型別，然後對於優先順序，進行過載，寫完這個之後感覺對泛型的運用瞭解了一些，對堆的感覺也更強了點；

我是大頂堆排序，裡面的元素過載了什麼的一改就是自定義排序了

期間用到了解構函式，但是後來發現編譯器會自動生成（如果沒有的話），所以就刪掉了

話不多說，直接上原始碼吧：

//#pragma comment(linker, "/STACK:1024000000,1024000000") 

#include<stdio.h>
#include<string.h>  
#include<math.h>  
  
//#include<map>   
//#include<set>
#include<deque>  
#include<queue>  
#include<stack>  
#include<bitset> 
#include<string>  
#include<fstream>
#include<iostream>  
#include<algorithm>  
using namespace std;  

#define ll long long  
//#define max(a,b) (a)>(b)?(a):(b)
//#define min(a,b) (a)<(b)?(a):(b) 
#define clean(a,b) memset(a,b,sizeof(a))// 水印 
//std::ios::sync_with_stdio(false);
const int MAXN=1e5+10;
const int INF=0x3f3f3f3f;
const ll mod=1e9+7;

struct Edge{
	int data;
	bool operator > (const Edge &a)const {
		return a.data<data;
	}
	Edge(int _data=0):
	data(_data){}
};

template<typename T>
class pQueue{
	private://私有 
		//初始佇列長度，初始佇列最長度 
		int heapsize,max;
		struct node{
			T data;
		}*pQ;
		void SWAP(int a,int b);//交換佇列中的兩個節點 
		void heap_adjust(int rt);//維護大頂堆
	public:
		pQueue()
		{
			pQ=NULL;
			heapsize=0;
			max=0;
		}
		void push(T data);
		T top();
		void pop();
		int size();
		bool Empty();
		
};
template<typename T>
void pQueue<T>::SWAP(int a,int b)
{
	node temp=pQ[a];
	pQ[a]=pQ[b];
	pQ[b]=temp;
}
template<typename T>
void pQueue<T>::heap_adjust(int rt)//維護大頂堆 
{
	int temp=rt;
	int l=temp<<1,r=temp<<1|1;
	if(l<=heapsize&&pQ[l].data>pQ[temp].data)
		temp=l;
	if(r<=heapsize&&pQ[r].data>pQ[temp].data)
		temp=r;
	//temp最大 
	if(temp!=rt)
	{
		SWAP(temp,rt);
		heap_adjust(temp);
	}
}
template<typename T>
void pQueue<T>::push(T data)
{
	
	if(heapsize<max)//在範圍內 
	{
		pQ[++heapsize].data=data;
//		pQ[heapsize].priority=0;
	}
	else
	{
		//與malloc的區別 
		
		pQ=(node*)realloc(pQ,(++heapsize+1)*sizeof(node));
		//cout<<heapsize<<" "<<data.data<<" "<<max<<endl;
		pQ[heapsize].data=data;
//		pQ[heapsize].priority=0;
		max++;
	}
	int index=heapsize;
	int p=index>>1;
	if(p==0)
		return ;
	while(p>=1&&pQ[index].data>pQ[p].data)
	{
		SWAP(index,p);
		index=p;
		p=index>>1;
	}
	heap_adjust(heapsize);
	//提升優先順序 
}
template<typename T>
T pQueue<T>::top()
{
	return pQ[1].data;
}
template<typename T>
void pQueue<T>::pop()
{
	if(heapsize>1)
	{
		SWAP(1,heapsize);
		heapsize--;
		heap_adjust(1);
	}
	else
		heapsize--;
}
template<typename T>
int pQueue<T>::size()
{
	return heapsize;
}
template<typename T>
bool pQueue<T>::Empty()
{
	return heapsize>1?1:0;
}
/*
1 6 3 4 9 12 50 32 16 53 465 321 20 3

*/
int main()
{
	pQueue<Edge> que;
	for(int i=1;i<15;++i)
	{
		int data;
		cin>>data;
		que.push(Edge(data));
		cout<<"data:"<<que.top().data<<" size:"<<que.size()<<" isEmpty:"<<que.Empty()<<endl;
	}
	while(que.size())
	{
		cout<<que.top().data<<endl;
		que.pop();
	}
	
}
 

樣例輸出：