数据结构复习5 队列

/* Queue.h */
#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
/* OrderQueue.cpp */
#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;
}

/* LinkQueue.cpp */
#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);
};
//the final position didnt store value
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;
}

• 双端队列

/* OrderDeque.cpp */
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;
	
}

/* LinkDeque.cpp */
template<class T>
class LinkDeque:public Queue<T>,public LinkQueue<T>{
	LinkDeque(){
		LinkQueue<T>::LinkQueue(NULL,NULL);
	}
	~LinkDeque(){
		LinkQueue<T>::~LinkQueue();
	}
};

/* 	virtual bool GetHead(T &x)const=0;
	virtual bool GetTail(T &x)const=0;
	virtual bool EnQueue(const T &x);
	virtual bool EnQueueHead(const T &x)=0;
	virtual bool EnQueueTail(const T &x)=0;
	virtual bool DeQueue(const T &x);
	virtual bool DeQueueHead(const T &x)=0;
	virtual bool DeQueueTail(const T &x)=0; */
	
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;
}