优先队列

自己实现优先队列：

#include <iostream>
#include <vector>
using namespace std;
/*the definition and implemention of Queue*/
const int queueSize = 10000;
template <class Queue_entry>
class Queue{     // Contiguous Queue
	public:
		Queue();
		void pop();               /*pre: make sure the Queue is not empty */
		Queue_entry front() const;/*pre: make sure the Queue is not empty */
		Queue_entry back() const; /*pre: make sure the Queue is not empty */
		
		bool push(const Queue_entry&);
		bool empty() const;
		int size() const;
	protected:
		int count;
		Queue_entry entry[queueSize];
		int head;
		int tail;
		//private:
};
template <class Queue_entry>
Queue<Queue_entry> :: Queue(){
	count = 0;
	head = 0;
	tail = 0;
}
template <class Queue_entry>
void Queue<Queue_entry> :: pop(){
	if(count > 0){
		count--;
		if(count) // if queue has only one entry, then head = tail when pop a entry
			head = (head-1+queueSize)%queueSize; 
	}
	/*else underflow*/
	return;
}
template <class Queue_entry>
Queue_entry Queue<Queue_entry> :: front() const{
	 if(count > 0){
		return entry[head];
	 }
	 /* return underflow */
}
template <class Queue_entry>
Queue_entry Queue<Queue_entry> :: back() const{
	 if(count > 0){
		return entry[tail];
	 }
	 /* return underflow */
}
template <class Queue_entry>
bool Queue<Queue_entry> :: push(const Queue_entry& newEntry){
	if(count < queueSize){
		if(count)// if queue is empty, then head = tail when push a entry
			 tail = (tail-1+queueSize)%queueSize;
		++count;                                       
		entry[tail] = newEntry;
		return true;
	}
	return false/*overflow*/;
}
template <class Queue_entry>
bool Queue<Queue_entry> :: empty() const{
	return count == 0;
}
template <class Queue_entry>
int Queue<Queue_entry> :: size() const{
	return count;
}


/*the definition and implemention of Priority Queue*/
template <class Queue_entry>
class Priority_Queue : public Queue<Queue_entry>{
	public:
		Priority_Queue();
		Priority_Queue(Queue<Queue_entry>);
		Priority_Queue(const Priority_Queue<Queue_entry>&);
		//~Priority_Queue();
		//friend bool operator<(const Priority_Queue&, const Priority_Queue&);
		void push(const Queue_entry&); /*pre: make sure the Queue is not full  */
		void pop();                    /*pre: make sure the Queue is not empty */
		Queue_entry top() const;       /*pre: make sure the Queue is not empty */
	private:
		void insert(Queue_entry *v, Queue_entry current, int high, int low);
		void build(Queue_entry *v, int n);
		//void HeapSort(Queue_entry *v, int n);
};

template <class Queue_entry>
Priority_Queue<Queue_entry> :: Priority_Queue(){
}
template <class Queue_entry>    
Priority_Queue<Queue_entry> :: Priority_Queue(Queue<Queue_entry> Q){
	this->count = Q.size();
	int i = 0;
	while(!Q.empty()){
		this->entry[i++] = Q.front();
		Q.pop();
	}
	build(this->entry, this->count);
}
template <class Queue_entry>
Priority_Queue<Queue_entry> :: Priority_Queue(const Priority_Queue<Queue_entry>& Q){
	this->count = Q.size();
	for(int i = 0; i < this->count; i++){
		this->entry[i] = Q.entry[i];
	}
}
template <class Queue_entry> // adjust from low to high 
void Priority_Queue<Queue_entry> :: push(const Queue_entry& new_entry)
{
	this->count++;
	int low = this->count-1, high = this->count/2 - 1;
	while(low > 0){
		if(new_entry > this->entry[high]){
			this->entry[low] = this->entry[high];
			low = high;
			high = (high-1)/2;
		} else{
			break;
		}
	} this->entry[low] = new_entry;
	return;
}
template <class Queue_entry>
void Priority_Queue<Queue_entry> :: pop()
{
	this->count--;
	insert(this->entry, this->entry[this->count], 0, this->count-1);
	return;
}
template <class Queue_entry>
Queue_entry Priority_Queue<Queue_entry> :: top() const
{
	return this->entry[0];
}
template <class Queue_entry>
void Priority_Queue<Queue_entry> :: insert(Queue_entry *v, Queue_entry current, int high, int low){
    int small = 2 * high + 1;
    while(small <= low)
    {
        if(small + 1 <= low && v[small] < v[small + 1])
            small++;
        if(v[small] < current)
            break;
        v[high] = v[small];
        high = small;
        small = 2 * high + 1;
    }
    v[high] = current;
    return;
}
template <class Queue_entry>
void Priority_Queue<Queue_entry> :: build(Queue_entry *v, int n){
    for(int i = n/2-1; i >= 0; i--){
        Queue_entry current = v[i];
        insert(v, current, i, n - 1);
    }
    return;
}

int main(){
	Queue<int> q;
	int cnt = 10; // test for cnt is 9 or 10 
	for(int i = 0; i < cnt; i++){
		q.push(cnt-i);
	}
	Priority_Queue<int> pq(q);
	cout << "pq\n";
	cout << "size: " << pq.size() << endl;
	while(!pq.empty()){
		cout << pq.top() << ' ';
		pq.pop();
	} cout << endl;
		
	Priority_Queue<int> pq2;
	for(int i = 1; i <= cnt; i++){
		pq2.push(i);
	}
	
	Priority_Queue<int> pq3(pq2);
	cout << "pq2\n";
	cout << "size: " << pq3.size() << endl;
	while(!pq2.empty()){
		cout << pq2.top() << ' ';
		pq2.pop();
	} cout << endl;
	cout << "pq3\n";
	while(!pq3.empty()){
		cout << pq3.top() << ' ';
		pq3.pop();
	} cout << endl;
    return 0;
}