queue实现

队列是一种先进先出的线性数据结构。分别有对头指针front和队尾指针rear,数据从对头出，从队尾进。队列可以分为顺序队列和链接队列。

• 顺序队列中，

各逻辑位置相邻的数据其物理位置也相邻，为了节省空间，一般采用循环队列结构

队头指针进1(数据出队列)：front=(front+1)%maxSize; //maxSize为顺序队列创造时设置的最大存储空间

队尾指针进1(数据入队列)：rear=(rear+1)%maxSize;

注意：

队列为空时，rear=front;

队列为满时，(rear+1)%maxSize=front;

• 链接队列中，

front指向的第一个队列节点是一个空节点，即是一个带表头的单链表，rear始终指向最后一个节点，即rear->link=NULL

1.队列抽象类

template 
class Queue
{
public:
    virtual bool IsEmpty() const=0;
    //virtual bool IsFull() const=0;
    virtual bool Front(T &x) const=0;   //返回队首元素给x
    virtual bool EnQueue(T x)=0;        //队尾x入队列
    virtual bool DeQueue()=0;           //队首出队列
    virtual bool Clear()=0;
};

2.顺序队列的实现

#include "queue.h"
 
template 
class SeqQueue:public Queue
{
private:
    T *q;           //建立T类型数组，指针q指向数组首地址，作为队列
    int front,rear; //front是队首下标号，rear是队尾下标号
    int maxSize;    //队列长度
public:
    SeqQueue(int mSize);
    ~SeqQueue();
    bool IsEmpty() const;
    bool IsFull() const;
    bool Front(T &x) const; //返回队首元素给x
    bool EnQueue(T x);      //队尾x入队列
    bool DeQueue();         //队首出队列
    bool Clear();
    void Print() const;
};

#include "seqqueue.h"
 
template 
SeqQueue::SeqQueue(int mSize)
{
    maxSize=mSize;
    q=new T[maxSize];
    front=rear=0;
}
 
template 
SeqQueue::~SeqQueue()
{
    delete [] q;
}
 
template 
bool SeqQueue::IsEmpty() const
{
    return front==rear;
}
 
template 
bool SeqQueue::IsFull() const
{
    return (rear+1)%maxSize==front;
}
 
template 
bool SeqQueue::Front(T &x) const
{
    if(IsEmpty())
    {
        cout<<"Front:the seqqueue is empty"<
bool SeqQueue::EnQueue(T x)
{
    if(IsFull())
    {
        cout<<"EnQueue:the seqqueue is full"<
bool SeqQueue::DeQueue()
{
    if(IsEmpty())
    {
        cout<<"DeQueue:the seqqueue is empty"<
bool SeqQueue::Clear()
{
    rear=front=0;
    return true;
}
 
template 
void SeqQueue::Print() const
{
    int j=front;
    while(j%maxSize!=rear)
    {
        cout<

3.链接队列的实现

#include "queue.h"
 
template  class LinkQueue;
template 
class QueueNode
{
private:
    T element;
    QueueNode *link;
    friend class LinkQueue;
};
 
template 
class LinkQueue:public Queue
{
private:
    QueueNode *front,*rear;
public:
    LinkQueue();
    ~LinkQueue();
    bool IsEmpty() const;
    //bool IsFull() const;
    bool Front(T &x) const; //返回队首元素给x
    bool EnQueue(T x);      //队尾x入队列
    bool DeQueue();         //队首出队列
    bool Clear();
    void Print() const;
};

#include "linkqueue.h"
 
template 
LinkQueue::LinkQueue()   //带有表头，front始终指向一个空节点
{
    front=new QueueNode;
    front->link=NULL;
    rear=front;
}
 
template 
LinkQueue::~LinkQueue()
{
    QueueNode *p;
    while(front)
    {
        p=front;
        front=front->link;
        delete p;
    }
}
 
template 
bool LinkQueue::IsEmpty() const
{
    return front==rear;
}
 
 
 
template 
bool LinkQueue::Front(T &x) const
{
    if(IsEmpty())
    {
        cout<<"Front:the linkqueue is empty"<link->element;
    return true;
}
 
template 
bool LinkQueue::EnQueue(T x)
{
    QueueNode *p=new QueueNode;
    p->element=x;
    rear->link=p;
    p->link=NULL;
    rear=p;
    return true;
}
 
template 
bool LinkQueue::DeQueue()
{
    if(IsEmpty())
    {
        cout<<"DeQueue:the linkqueue is empty"< *p;
    p=front;
    front=front->link;
    delete p;
    return true;
}
 
template 
bool LinkQueue::Clear()
{
    QueueNode *p;
    while(front->link)
    {
        p=front->link;
        front->link=p->link;
        delete p;
    }
    rear=front;
    return true;
}
 
template 
void LinkQueue::Print() const
{
    QueueNode *p=front->link;
    while(p)
    {
        cout<element<<' ';
        p=p->link;
    }
    cout<