数据结构学习笔记3-队列

队列是一种先进先出的线性数据结构。分别有对头指针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.顺序队列的实现

#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.链接队列的实现

#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;
}

【欢迎读者交流批评指正~】