#ifndef QUEUE_H
#define QUEUE_H
const int maxSize=50;
template <class T>
class Queue{
public:
Queue(){};
~Queue(){};
virtual void EnQueue(const T &x)-0;
virtual bool DeQueue(T &x)=0;
virtual bool getFront(T &x)=0;
virtual bool IsEmpty()const=0;
virtual bool IsFull()const=0;
virtual int getSize()const=0;
};
#endif
#include<iostream.h>
#include<assert.h>
#include"Queue.h"
using namespace std;
template<class T>
class OrderQueue:public Queue<T>{
public:
OrderQueue(int size=10);
~OrderQueue(){delete []elem;}
bool EnQueue(const T &x);
bool DeQueue(T &x);
bool getFront(T &x);
void makeEmpty(){front=rear=0;}
bool IsEmpty()const{return (front==rear)?true:false;}
bool IsFull()const{return ((rear+1)%maxSize==front)?true:false;}
int getSize()const{return ((rear-front+maxSize)%maxSize==0)?true:false;}
friend ostream& operator<<(ostream &out,OrderQueue<T> &q);
private:
T *elem;
int front;
int rear;
int maxSize;
};
template<class T>
OrderQueue<T>::OrderQueue(int size):front(0),rear(0),maxSize(size){
elem=new T[maxSize];
assert(elem!=NULL);
}
template<class T>
bool OrderQueue<T>::getFront(T &x){
if(IsEmpty())
return false;
x=elem[front];
return true;
}
template<class T>
bool OrderQueue<T>::EnQueue(const T &x){
if(IsFull())
return false;
elem[rear]=x;
rear=(rear+1)%maxSize;
return true;
}
template<class T>
bool OrderQueue<T>::DeQueue(T &x){
if(IsEmpty()){
return false;
}
x=elem[front];
front=(front+1)%maxSize;
return true;
}
template<class T>
ostream& OrderQueue<T>::operator<<(ostream &out,OrderQueue<T> &q){
int begin=q.front;
while(begin!=q.front){
out << q.elem[begin] <<endl;
begin=(begin+1)%maxSize;
}
return out;
}
#include"LinkList.h"
template<class T>
class LinkQueue:public Queue<T>{
private:
LinkNode<T> *front,*rear;
public:
LinkQueue():front(NULL),rear(NULL){}
~LinkQueue(){makeEmpty();}
bool EnQueue(const T &x);
bool DeQueue(T &x);
bool getFront(T &x);
void makeEmpty();
bool IsEmpty()const{return front==NULL?true:false;}
int getSize()const;
friend ostream& operator<<(ostream o&ut,LinkQueue<T> &lq);
};
template<class T>
void LinkQueue<T>::makeEmpty(){
LinkNode<T> p
while(front!=rear){
p=front;
front=front->link;
delete p;
}
}
template<class T>
bool LinkQueue<T>::getFront(T &x){
if(IsEmpty())
return false;
x=front->elem;
return true;
}
template<class T>
int LinkQueue<T>::getSize()const{
LinkNode<T> p=front;int ctr=0;
while(p!=rear){
p=p->link;
ctr++;
}
return ctr;
}
template<class T>
bool LinkQueue<T>::EnQueue(const T &x){
LinkNode<T> p=new LinkNode<T>(x,NULL);
if(p==NULL){
cerr<<"allocate memory error"<<endl;
return false;
}
if(IsEmpty()){
front=rear=p;
rear=rear->link;
}
rear=p;
rear=rear->link;
return true;
}
template<class T>
bool LinkQueue<T>::DeQueue(T &x){
if(IsEmpty())
return false;
LinkNode<T> p=front;
front=front->link;
x=p->elem;
delete p;
}
template<class T>
ostream& LinkQueue<T>::operator<<(ostream &out,LinkQueue<T> &lq){
LinkNode<T> p=lq.front;
while(p!=lq.rear){
out <<p->elem;
p=p->link;
}
return out;
}
template<class T>
class OrderDeque:public Deque<T>,public OrderQueue<T>{
public:
OrderDeque<T>::OrderQueue(int sz);
};
OrderDeque<T>::OrderQueue(int sz){
OrderQueue(sz);
}
bool GetHead(T &x)const{
T temp;
bool tag=OrderQueue<T>::getFront(temp);
x=temp;
return tag;
}
bool GetTail(T &x)const{
if(front==rear){
return false;
}
x=elem[(rear-1+maxSize)%maxSize];
return true;
}
bool EnQueueHead(const T &x){
if(IsFull()==true){
return false;
}
front=(front-1+maxSize)%maxSize;
elem[front]=x;
return true;
}
bool EnQueueTail(const T &x){
return OrderQueue<T>::EnQueue(x);
}
bool DeQueueHead(T &x){
return OrderQueue<T>::DeQueue(x);
}
bool DeQueueTail(T &x){
if(IsEmpty()==true)
return false;
x=elem[rear];
rear=(rear-1+maxSize)%maxSize;
return true;
}
template<class T>
class LinkDeque:public Queue<T>,public LinkQueue<T>{
LinkDeque(){
LinkQueue<T>::LinkQueue(NULL,NULL);
}
~LinkDeque(){
LinkQueue<T>::~LinkQueue();
}
};
bool GetHead(T &x)const{
return getFront(x);
}
bool GetTail(T &x)const{
if(IsEmpty())
return false;
LinkNode<T> *p=rear;
x=p->elem;
return true;
}
bool EnQueueHead(const T &x){
LinkNode<T> *p=new LinkNode<T>(x,NULL);
if(p==NULL){
cerr<<"allocate memory error"<<endl;
return false;
}
p->link=front;
front=p;
return true;
}
bool EnQueueTail(const T &x){
return LinkQueue<T>::EnQueue(x);
}
bool DeQueueHead(const T &x){
return LinkQueue<T>::DeQueue(x);
}
bool DeQueueTail(const T &x){
if(IsEmpty()){
return false;
}
LinkNode<T> *p=front;
while(p->link->link!=rear){
p=p->link;
}
rear=p;
p=p->link;
delete p;
rear=rear->link;
return true;
}