数据结构-队列的相关操作

队列(Queue)：是运算受限的线性表。是一种先进先出(First In First Out ，简称FIFO)的线性表。只允许在表的一端进行插入，而在另一端进行删除。

队首(front) ：允许进行删除的一端称为队首。

队尾(rear) ：允许进行插入的一端称为队尾。

这和我们日常生活中的排队是一致的，最早进入队列的最先离开，队首的人先离开，后来的人站在队尾。

链队列-队列的链式表示和实现

用链表表示的队列叫做链队列。一个链队列需要两个分别指向队首和队尾的指针（分别成为头指针和尾指针）才能唯一确定。为了操作方便起见，我们也给链队列添加一个头结点，并令头指针指向头结点。此时，空队列的判决条件为头指针和尾指针均指向头结点。

链队列的操作实际上是单链表的操作，只不过是删除在表头进行，插入在表尾进行。插入、删除时分别修改不同的指针。

链队列实现代码 （构造、销毁、入列、出列）：

#include<iostream>
using namespace std;

//链式队列
typedef int QElemType;
typedef struct QNode//数据元素结点
{
	QElemType    data;//数据域
	struct QNode* next;//指针域
}QNode,* QueuePtr;

typedef struct//指针结点
{
	QueuePtr front;//队首指针，出队
	QueuePtr rear;//队尾指针，入队
}LinkQueue;

//构造一个队列
bool Create(LinkQueue& Q)
{
	Q.front = Q.rear = new QNode;//首尾指针指向相同,指向头结点
	if (!Q.front)//空间分配失败
		return false;
	Q.front->next = NULL;//头结点的next为空
	return true;
}

//销毁队列
bool Destroy(LinkQueue& Q)
{
	while (Q.front)//释放每一个结点
	{
		Q.rear = Q.front->next;
		delete Q.front;
		Q.front = Q.rear;
	}
	return true;
}

//插入元素e为新的队尾元素
bool Insert(LinkQueue& Q, QElemType e)
{
	QueuePtr p = new QNode;//创建新的结点
	if (!p)//分配空间失败
		return false;
	p->data = e;
	p->next = NULL;
	Q.rear->next = p;//将新的结点接在队尾
	Q.rear = p;//尾指针指向新的结点
	return true;
}

//若队列不为空，则删除队首元素，并用e返回
bool Delete(LinkQueue& Q, QElemType& e)
{
	if (Q.front == Q.rear)//队列为空
		return false;
	QueuePtr p = Q.front->next;//创建指针指向首个结点
	e = p->data;//接收队首元素
	Q.front->next = p->next;//首指针后移一位
	if (Q.rear == p)//如果队列只有一个元素，删除后要对尾指针重新赋值，否则尾指针丢失
		Q.rear = Q.front;
	delete p;
	return true;
}

int main()
{
	LinkQueue Q;
	Create(Q);
	cout << "入列：" << endl;
	for (int i = 0; i < 10; i++)
	{
		int num = rand() % 100;
		Insert(Q, num);
		cout << num << endl;
	}
	cout << "出列：" << endl;
	int e;
	for (int i = 0; i < 10; i++)
	{
		Delete(Q, e);
		cout << e << endl;
	}
}

循环队列-队列的顺序表示和实现

在队列的顺序存储结构中，除了用一组地址连续的存储单元依次存放从队首到队尾的元素外，仍需要设置头尾指针指向队首元素和队尾元素。为了方便起见，初始化队列时，令front=rear=0，每当队列插入新的队尾元素时，rear+1，每当删除队首元素时，front+1。这也就表明，front始终指向队首位置，而rear始终指向队尾元素的下一个位置。

但是，利用一维数组存储队列，随着入队、出队的操作，会出现“假溢出”现象，不利于空间的充分利用。如下图：

因此，为了充分利用队列空间，将为队列分配的向量空间看成为一个首尾相接的圆环，并称这种队列为循环队列(Circular Queue)。

 

 入队时尾指针向前追赶头指针，出队时头指针向前追赶尾指针，故队空和队满时头尾指针均相等。因此，无法通过front==rear来判断队列“空”还是“满”。

解决此问题的方法是：约定入队前，测试尾指针加1后是否等于头指针，若相等则认为队满。但此方法会少用一个队列空间。

即：

◆ rear所指的单元始终为空。

◆ 循环队列为空：front == rear 。 

◆ 循环队列满：(rear+1)%MAXSIZE ==front。

循环列实现代码 （构造、入列、出列）：

#include<iostream>
using namespace std;
#define Maxsize 100//最大队列长度
//循环队列的相关操作
typedef int QElemType;
typedef struct
{
	QElemType* base;//初始化的内存空间
	int front;//记录队头元素的下标
	int rear;//记录队尾元素的下标
}SqQueue;

//构造空队列
bool Create(SqQueue& Q)
{
	Q.base = new QElemType[Maxsize];//堆区动态分配存储空间
	if (!Q.base)//空间分配失败
		return false;
	Q.front = Q.rear = 0;
	return true;
}

//插入元素e作为队列的队尾元素
bool Insert(SqQueue& Q, QElemType e)
{
	if ((Q.rear + 1) % Maxsize == Q.front)//队列满
		return false;
	Q.base[Q.rear] = e;//将元素插入
	Q.rear=(Q.rear+1)%Maxsize;//队尾指针加一（这里是取模运算，防止rear的值大于队列长度）
	return true;
}

//删除队首元素，并用e返回
bool Delete(SqQueue& Q, QElemType& e)
{
	if (Q.front == Q.rear)//队列为空
		return false;
	e = Q.base[Q.front];//将队首元素赋值给e
	Q.front = (Q.front + 1) % Maxsize;//头指针加一
	return true;
}

int main()
{
	SqQueue Q;
	Create(Q);
	//入队
	cout << "入队：" << endl;
	for (int i = 0; i < 10; i++)
	{
		int num = rand() % 100;
		Insert(Q, num);
		cout << num << endl;
	}
	cout << "出队：" << endl;
	int e;
	for (int i = 0; i < 10; i++)
	{
		Delete(Q, e);
		cout << e << endl;
	}
}

 这里有个需要理解的地方是，利用动态数组开辟的循环队列虽然在地址上是连续的，但是我们将其看作首尾相连的圆环。也就是说这个队列在理解中没有固定的头和尾，头和尾取决于我们赋予的队首元素和队尾元素的下标，也就是front和rear，利用取模运算front和rear的值一直在Maxsize内循环。这也解释了为什么front和rear是整型变量而非指针。由于动态数组的大小是固定的，因此我们删除元素的实际意义是将front后移，队首元素就成了下一个元素，实际上被删除的元素还在数组中，增加元素的实际意义是给数组重新赋值覆盖掉原有元素。

ps：如果用户不清楚元素的数量，则需要链式队列存储元素。