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 T>
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. queue順序實現（數組）

#include "queue.h"
 
template <class T>
class SeqQueue:public Queue<T>
{
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 <class T>
SeqQueue<T>::SeqQueue(int mSize)
{
    maxSize=mSize;
    q=new T[maxSize];
    front=rear=0;
}
 
template <class T>
SeqQueue<T>::~SeqQueue()
{
    delete [] q;
}
 
template <class T>
bool SeqQueue<T>::IsEmpty() const
{
    return front==rear;
}
 
template <class T>
bool SeqQueue<T>::IsFull() const
{
    return (rear+1)%maxSize==front;
}
 
template <class T>
bool SeqQueue<T>::Front(T &x) const
{
    if(IsEmpty())
    {
        cout<<"Front:the seqqueue is empty"<<endl;
        return false;
    }
    x=q[(front+1)%maxSize];
    return true;
}
 
template <class T>
bool SeqQueue<T>::EnQueue(T x)
{
    if(IsFull())
    {
        cout<<"EnQueue:the seqqueue is full"<<endl;
        return false;
    }
    rear=(rear+1)%maxSize;
    q[rear]=x;
    return true;
}
 
template <class T>
bool SeqQueue<T>::DeQueue()
{
    if(IsEmpty())
    {
        cout<<"DeQueue:the seqqueue is empty"<<endl;
        return false;
    }
    front=(front+1)%maxSize;
    return true;
}
 
template <class T>
bool SeqQueue<T>::Clear()
{
    rear=front=0;
    return true;
}
 
template <class T>
void SeqQueue<T>::Print() const
{
    int j=front;
    while(j%maxSize!=rear)
    {
        cout<<q[(j+1)%maxSize]<<' ';
        j=(j+1)%maxSize;
    }
    cout<<endl;
}

 

3. queue鏈接實現（鏈表）

#include "queue.h"
 
template <class T> class LinkQueue;
template <class T>
class QueueNode
{
private:
    T element;
    QueueNode<T> *link;
    friend class LinkQueue<T>;
};
 
template <class T>
class LinkQueue:public Queue<T>
{
private:
    QueueNode<T> *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 <class T>
LinkQueue<T>::LinkQueue()   //帶有表頭，front始終指向一個空節點
{
    front=new QueueNode<T>;
    front->link=NULL;
    rear=front;
}
 
template <class T>
LinkQueue<T>::~LinkQueue()
{
    QueueNode<T> *p;
    while(front)
    {
        p=front;
        front=front->link;
        delete p;
    }
}
 
template <class T>
bool LinkQueue<T>::IsEmpty() const
{
    return front==rear;
}
 
 
 
template <class T>
bool LinkQueue<T>::Front(T &x) const
{
    if(IsEmpty())
    {
        cout<<"Front:the linkqueue is empty"<<endl;
        return false;
    }
    x=front->link->element;
    return true;
}
 
template <class T>
bool LinkQueue<T>::EnQueue(T x)
{
    QueueNode<T> *p=new QueueNode<T>;
    p->element=x;
    rear->link=p;
    p->link=NULL;
    rear=p;
    return true;
}
 
template <class T>
bool LinkQueue<T>::DeQueue()
{
    if(IsEmpty())
    {
        cout<<"DeQueue:the linkqueue is empty"<<endl;
        return false;
    }
    QueueNode<T> *p;
    p=front;
    front=front->link;
    delete p;
    return true;
}
 
template <class T>
bool LinkQueue<T>::Clear()
{
    QueueNode<T> *p;
    while(front->link)
    {
        p=front->link;
        front->link=p->link;
        delete p;
    }
    rear=front;
    return true;
}
 
template <class T>
void LinkQueue<T>::Print() const
{
    QueueNode<T> *p=front->link;
    while(p)
    {
        cout<<p->element<<' ';
        p=p->link;
    }
    cout<<endl;
}