优先级队列的一种实现

代码：

#include <iostream>

using namespace std;

typedef char Item;
typedef struct QNode *pQNode;
typedef struct QNode
{
	Item data;
	QNode *link;	
}QNode;

typedef struct Queue
{
	pQNode front;
	pQNode rear;
}Queue,*PriorityQueue;

void Copy(Item *dest,Item *src)
{
	*dest = *src;
}

void InitQueue(PriorityQueue* Q);
void Enqueue(PriorityQueue Q,Item item);
void Dequeue(PriorityQueue Q,Item *item);
Item Front(PriorityQueue Q);
bool Isempty(PriorityQueue Q);
void Clear(PriorityQueue *Q);
void PrintQueue(PriorityQueue Q);
void PriorityModify(PriorityQueue Q);



void InitQueue(PriorityQueue* Q)
{
	*Q = new Queue;
	(*Q)->front = NULL;
	(*Q)->rear = NULL;
}
bool Gt(Item a,Item b)
{
	if (a>b)
		return true;
	return false;
}
void PriorityModify(PriorityQueue Q,bool (*Gt)(Item,Item))
{
	if(Isempty(Q))
		return;
	
	pQNode pb = Q->front;
	pQNode pa = pb->link;
	pQNode u,x,t;
	pb->link = NULL;
	while(pa)
	{
		
		if(Gt(pa->data , pb->data))
		{
			/* ">" is applyed if max priority queue is needed here*/
			u = pa->link;
			pa->link = pb;
			pb = pa;
			pa = u; 
		}
		else
		{
			for(t = pb;t->link;t=t->link)
			{
				if(Gt(pa->data,t->link->data)) 
				{
					
					break;
				}	 
			}
			u = t->link;
			x = pa->link;
			t->link = pa;
			pa->link = u;
			pa = x; 				
		}
	}
	Q->front = pb;
	for(t=pb;t->link;t=t->link);
	Q->rear = t;
	
}
void Enqueue(PriorityQueue Q,Item item)
{
	pQNode p = new QNode;
	Copy(&(p->data),&item);
	p->link = NULL;
	if(Q->rear == NULL)
	{
		Q->front = Q->rear = p;
	}
	else
	{
		Q->rear->link = p;
		Q->rear = p;
	}
	
	PriorityModify(Q,&Gt);
}
void Dequeue(PriorityQueue Q,Item *item)
{
	if(!Isempty(Q))
	{
		pQNode p = Q->front;
		Copy(item,&(p->data));
		if (Q->front == Q->rear)
			Q->front = Q->rear = NULL;
		else
			Q->front = Q->front->link;
		delete p;
	}
	
	PriorityModify(Q,&Gt);
	
	
}
Item Front(PriorityQueue Q)
{
	return Q->front->data;
}
bool Isempty(PriorityQueue Q)
{
	return Q == NULL || Q->rear == NULL;
}
void Clear(PriorityQueue *Q)
{
	pQNode  p = (*Q)->front;
	pQNode tmp; 
	while(p)
	{
		tmp = p->link;
		delete p;
		p = tmp;
	}
	delete (*Q);
	(*Q) = NULL;
}
void PrintQueue(PriorityQueue Q)
{
	pQNode p = Q->front;
	cout<<"Queue currently Start:"<<endl;
	while(p)
	{
		cout<<"Qnode : "<<p->data<<endl;
		p = p->link;
	}
	cout<<"Queue End."<<endl;
}

 
int main()
{
	PriorityQueue Q;
	InitQueue(&Q);
	for(int i=0;i<5;i++)
	{
		Enqueue(Q,'A'+8-2*i);
		PrintQueue(Q);
	}
	
	cout<<"Front node of current Queue : "<<Front(Q)<<endl;
	
	cout<<"QNode B Enqueue."<<endl;
	Enqueue(Q,'B');
	PrintQueue(Q);
	
	Item v;
	Dequeue(Q,&v);
	
	cout<<"QNode  ："<<v<<" Dequeued."<<endl;
	PrintQueue(Q);

	for(int i=0;i<5;i++)
		Dequeue(Q,&v);
	cout<<boolalpha<<Isempty(Q)<<endl;
	Clear(&Q);
	cout<<boolalpha<<Isempty(Q)<<endl;

	getchar();
} 

测试输出：

Queue currently Start:
Qnode : I
Queue End.
Queue currently Start:
Qnode : I
Qnode : G
Queue End.
Queue currently Start:
Qnode : I
Qnode : G
Qnode : E
Queue End.
Queue currently Start:
Qnode : I
Qnode : G
Qnode : E
Qnode : C
Queue End.
Queue currently Start:
Qnode : I
Qnode : G
Qnode : E
Qnode : C
Qnode : A
Queue End.
Front node of current Queue : I
QNode B Enqueue.
Queue currently Start:
Qnode : I
Qnode : G
Qnode : E
Qnode : C
Qnode : B
Qnode : A
Queue End.
QNode  ：I Dequeued.
Queue currently Start:
Qnode : G
Qnode : E
Qnode : C
Qnode : B
Qnode : A
Queue End.
true
true