隊列

佇列，又稱為-{zh-hans:佇列;zh-hant:隊列}-（queue），計算機科學中的一種抽象資料型別，是先進先出（FIFO, First-In-First-Out）的線性表。在具體應用中通常用鏈表或者數組來實現。隊列只允許在後端（稱為rear）進行插入操作，在前端（稱為front）進行刪除操作。
隊列的操作方式和堆棧類似，唯一的區別在於隊列只允許新數據在後端進行添加。

**單鏈隊列**
單鏈隊列使用鏈表作為基本數據結構，所以不存在偽溢出的問題，隊列長度也沒有限制。但插入和讀取的時間代價較高

**存儲結構**
/* c3-2.h 單鏈隊列－－隊列的鏈式存儲結構 */
typedef struct QNode
{
	QElemType data;
	struct QNode *next;
}QNode,*QueuePtr;
typedef struct
{
	QueuePtr front,rear; /* 隊頭、隊尾指針 */
}LinkQueue;

**基本操作**
/* bo3-2.c 鏈隊列(存儲結構由c3-2.h定義)的基本操作(9個) */
void InitQueue(LinkQueue *Q)
{	/* 構造一個空隊列Q */
	(*Q).front=(*Q).rear=(QueuePtr)malloc(sizeof(QNode));
	if(!(*Q).front)
		exit(OVERFLOW);
	(*Q).front->next=NULL;
}
void DestroyQueue(LinkQueue *Q)
{	/* 銷燬隊列Q(無論空否均可) */
	while((*Q).front)
	{
		(*Q).rear=(*Q).front->next;
		free((*Q).front);
		(*Q).front=(*Q).rear;
	}
}
void ClearQueue(LinkQueue *Q)
{	/* 將Q清為空隊列 */
	QueuePtr p,q;
	(*Q).rear=(*Q).front;
	p=(*Q).front->next;
	(*Q).front->next=NULL;
	while(p)
	{
		q=p;
		p=p->next;
		free(q);
	}
}
Status QueueEmpty(LinkQueue Q)
{	/* 若Q為空隊列，則返回TRUE，否則返回FALSE */
	if(Q.front->next==NULL)
		return TRUE;
	else
		return FALSE;
}
int QueueLength(LinkQueue Q)
{	/* 求隊列的長度 */
	int i=0;
	QueuePtr p;
	p=Q.front;
	while(Q.rear!=p)
	{
		i++;
		p=p->next;
	}
	return i;
}
Status GetHead_Q(LinkQueue Q,QElemType *e) /* 避免與bo2-6.c重名 */
{	/* 若隊列不空，則用e返回Q的隊頭元素，並返回OK，否則返回ERROR */
	QueuePtr p;
	if(Q.front==Q.rear)
		return ERROR;
	p=Q.front->next;
	*e=p->data;
	return OK;
}
void EnQueue(LinkQueue *Q,QElemType e)
{	/* 插入元素e為Q的新的隊尾元素 */
	QueuePtr p=(QueuePtr)malloc(sizeof(QNode));
	if(!p) /* 存儲分配失敗 */
		exit(OVERFLOW);
	p->data=e;
	p->next=NULL;
	(*Q).rear->next=p;
	(*Q).rear=p;
}
Status DeQueue(LinkQueue *Q,QElemType *e)
{	/* 若隊列不空，刪除Q的隊頭元素，用e返回其值，並返回OK，否則返回ERROR */
	QueuePtr p;
	if((*Q).front==(*Q).rear)
		return ERROR;
	p=(*Q).front->next;
	*e=p->data;
	(*Q).front->next=p->next;
	if((*Q).rear==p)
		(*Q).rear=(*Q).front;
	free(p);
	return OK;
}
void QueueTraverse(LinkQueue Q,void(*vi)(QElemType))
{	/* 從隊頭到隊尾依次對隊列Q中每個元素調用函數vi() */
	QueuePtr p;
	p=Q.front->next;
	while(p)
	{
		vi(p->data);
		p=p->next;
	}
	printf("\n");
}

**循環隊列**
循環隊列可以更簡單防止偽溢出的發生，但隊列大小是固定的。
// 隊列的順序存儲結構(循環隊列)
#define MAX_QSIZE 5 // 最大隊列長度+1
typedef struct {
int *base; // 初始化的動態分配存儲空間
int front; // 頭指針，若隊列不空，指向隊列頭元素
int rear; // 尾指針，若隊列不空，指向隊列尾元素的下一個位置
} SqQueue;
// 構造一個空隊列Q
SqQueue* Q_Init() {
SqQueue *Q = (SqQueue*)malloc(sizeof(SqQueue));
// 存儲分配失敗
if (!Q){
exit(OVERFLOW);
}
Q->base = (int *)malloc(MAX_QSIZE * sizeof(int));
// 存儲分配失敗
if (!Q->base){
exit(OVERFLOW);
}
Q->front = Q->rear = 0;
return Q;
}
// 銷燬隊列Q，Q不再存在
void Q_Destroy(SqQueue *Q) {
if (Q->base)
free(Q->base);
Q->base = NULL;
Q->front = Q->rear = 0;
free(Q);
}
// 將Q清為空隊列
void Q_Clear(SqQueue *Q) {
Q->front = Q->rear = 0;
}
// 若隊列Q為空隊列，則返回1；否則返回-1
int Q_Empty(SqQueue Q) {
if (Q.front == Q.rear) // 隊列空的標誌
return 1;
else
return -1;
}
// 返回Q的元素個數，即隊列的長度
int Q_Length(SqQueue Q) {
return (Q.rear - Q.front + MAX_QSIZE) % MAX_QSIZE;
}
// 若隊列不空，則用e返回Q的隊頭元素，並返回OK；否則返回ERROR
int Q_GetHead(SqQueue Q, int &e) {
if (Q.front == Q.rear) // 隊列空
return -1;
e = Q.baseQ.front;
return 1;
}
// 打印隊列中的內容
void Q_Print(SqQueue Q) {
int p = Q.front;
while (Q.rear != p) {
cout rear + 1) % MAX_QSIZE == Q->front) // 隊列滿
return -1;
Q->baseQ->rear = e;
Q->rear = (Q->rear + 1) % MAX_QSIZE;
return 1;
}
// 若隊列不空，則刪除Q的隊頭元素，用e返回其值，並返回1；否則返回-1
int Q_Poll(SqQueue *Q, int &e) {
if (Q->front == Q->rear) // 隊列空
return -1;
e = Q->baseQ->front;
Q->front = (Q->front + 1) % MAX_QSIZE;
return 1;
}

**陣列佇列**
#define MAX_QSIZE 10 // 最大隊列長度+1
// 陣列隊列的存儲結構
struct Queue {
int ArrayMAX_QSIZE; // 陣列空間大小
int front; // 隊頭
int rear; // 隊尾
int length; // 隊列長度
};
// 構造一個空隊列Q
Queue* Q_Init() {
Queue *Q = (Queue*)malloc(sizeof(Queue));
if (!Q){
// 存儲分配失敗
exit(OVERFLOW);
}
//初始化
Q->front = Q->rear = Q->length = 0;
return Q;
}
// 將Q清為空隊列
void Q_Clear(Queue *Q) {
//清除頭尾下標和長度
Q->front = Q->rear = Q->length = 0;
}
// 入列
int Q_Put(Queue *Q, int x) {
//如果當前元素數量等於最大數量 返回 -1
if (Q->rear + 1 == MAX_QSIZE) {
return -1;
}
Q->ArrayQ->rear = x;
Q->rear = Q->rear + 1;
//length + 1
Q->length = Q->length + 1;
return 1;
}
// 出列
int Q_Poll(Queue *Q) {
//如果當前元素數量等於最大數量 返回 -1
if (Q->front + 1 == MAX_QSIZE)
return -1;
int x = Q->ArrayQ->front;
Q->front = Q->front + 1;
// 移出後減少1
Q->length = Q->length - 1;
return x;
}

**參考文獻**

**參見**
 堆棧- 鏈表- 數組- 數據結構