队列的C++实现（两种方式）

这是用动态数组实现的队列：

#define SEQQUEUE_H

#include <iostream>
#include <assert.h>
using namespace std;

template <class T>
class SeqQueue
{
public:
	SeqQueue(int sz=50);
	~SeqQueue(){delete []elements;}
	bool EnQueue(const T& x);
	bool DeQueue(T& x);
	bool IsFull()const {return (front==(rear+1)%maxSize);}
	bool IsEmpty()const {return (front==rear);}
	bool getFront(T& x);
	int getSize()const{return (rear-front+maxSize)%maxSize;}
	friend ostream& operator<< <T>(ostream&,SeqQueue<T>&);
protected:
	int front,rear;
	T *elements;
	int maxSize;
};

template <class T>
SeqQueue<T>::SeqQueue(int sz):front(0),rear(0),maxSize(sz)
{
	elements=new T[maxSize];
	assert(elements);
};

template <class T>
bool SeqQueue<T>::EnQueue(const T& x)
{
	if(IsFull()) return false;
	elements[rear]=x;
	rear=(rear+1)%maxSize;
	return true;
};

template <class T>
bool SeqQueue<T>::DeQueue(T& x)
{
	if(IsEmpty()) return false;
	x=elements[front];
	front=(front+1)%maxSize;
	return true;
};

template <class T>
bool SeqQueue<T>::getFront(T& x)
{
	if(IsEmpty()) return false;
	x=elements[front];
	return true;
};

template <class T>
ostream& operator<<(ostream& out,SeqQueue<T>& q)
{
	if(q.IsEmpty()) {cout<<"The queue is empty!"<<endl;return out;}
	int p=q.front;
	while(p!=q.rear)
	{
		cout<<p<<":"<<q.elements[p]<<endl;
		p=(p+1)%(q.maxSize);
	}
	return out;
};

#endif

这是用链表节点实现的链式队列

#ifndef LINKQUEUE_H
#define LINKQUEUE_H

#include <iostream>
using namespace std;

/***链式队列，front指向队列附加头结点，rear指向最后一个元素，
和动态数组表示的队列不同，它的front指向第一个元素，rear指向下一个要插入的位置*/

template <class T>
struct Node
{
	T data;
	Node<T> *next;
	Node(Node<T> *p=NULL):next(p){}
	Node(const T& x,Node<T> *p=NULL):data(x),next(p){}	
};

template <class T>
class LinkQueue
{
public:
	LinkQueue():front(new Node<T>){rear=front;}
	~LinkQueue(){makeEmpty();}
	void makeEmpty();
	bool EnQueue(const T& x);
	bool DeQueue(T& x);
	bool IsEmpty(){return front==rear;}
	bool getFront(T& x)const;
	int getSize()const;
	friend ostream& operator<< <T>(ostream&,LinkQueue<T>&);
protected:
	Node<T> *front,*rear;
};

template <class T>
void LinkQueue<T>::makeEmpty()
{
	Node<T> *p;
	while (front->next)
	{
		p=front->next;
		front->next=p->next;
		delete p;
	}
	front=rear=NULL;
};

template <class T>
bool LinkQueue<T>::EnQueue(const T& x)
{
	rear->next=new Node<T>(x);
	if(rear==NULL) return false;
	rear=rear->next;
	return true;
};

template <class T>
bool LinkQueue<T>::DeQueue(T& x)
{
	if(IsEmpty()) return false;
	Node<T> *p=front->next;
	front->next=p->next;
	x=p->data;

<span style="white-space:pre">	</span>if(rear==p)

<span style="white-space:pre">	</span>   rear=front;
	delete p;
	return true;
};

template <class T>
bool LinkQueue<T>::getFront(T& x)const
{
	if(IsEmpty()) return false;
	x=front->next->data;
	return true;
};

template <class T>
int LinkQueue<T>::getSize()const
{
	Node<T> *p=front;
	int count=0;
	while (p!=rear)
	{
		count++;
		p=p->next;
	}
	return count;
};

template <class T>
ostream& operator<<(ostream& out,LinkQueue<T>& q)
{
	if(q.IsEmpty())
	{
		out<<"The queue is Empty!"<<endl;
		return out;
	}
	Node<T> *p=q.front->next;
	int i=0;
	while (p)
	{
		cout<<(++i)<<":"<<p->data<<endl;
		p=p->next;
	}
	return out;
};
#endif

这是主函数

#include <iostream>
#include "SeqQueue.h"
#include "LinkQueue.h"
using namespace std;
void main()
{
	//SeqQueue<int> q;
	LinkQueue<int> q;
	int a;
	cin>>a;
	while(a!=0)
	{
		q.EnQueue(a);
		cin>>a;
	}
	int x;
	for(int i=1;i<=5;i++)
	{
		q.DeQueue(x);
		cout<<"第"<<i<<"次出列："<<x<<endl;
	}
	cout<<"出列后的队列："<<endl;
	cout<<q;
}