队列的顺序存储和链式存储

队列的基本概念

1.定义：队列是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。

2.队列是一种先进先出的线性表，简称FIFO。允许插入的一端称为队尾，允许删除的一端称为队头。front指针指向对头元素，rear指针指向队尾的下一个位置。当front==rear时，为空队列。

队列的顺序存储（循环队列）

如图所示为队列的顺序存储：



假设这个队列的总个数不超过5个，但目前如接着入队的话，因数组末尾元素已经占用，再向后加，就会出现数组越界的错误，可实际上，队列在下标0和1的地方还是空闲的。把这种现象称为“假溢出”。

这也是队列的顺序存储不足的地方。所以解决假溢出的办法就是后面满了，就再从头开始，也就是头尾相接的循环。

我们把队列的这种头尾相接的顺序存储结构称为循环队列。

判断队列满的条件：

*办法一是设置一个标志变量flag，当front==rear，且flag=0是为队列空，当front=rear，且flag=1时为队列满。

*办法二是当队列空时，条件就是front=rear，当队列满时，保留一个元素空间，数组中还有一个空闲单元。如图所示：



这里主要讨论第二种方法：由于rear可能比front大，也可能比front小，所以尽管它们只相差一个位置时就是满的情况，但也可能是相差整整一圈。所以若队列的最大尺寸为QueueSize，那么队列满的条件是：

(rear+1)%QueueSize == front

而队列的长度计算公式为：

(rear-front+QueueSize)%QueueSize

循环队列的代码实现：

"sqqueue.h"

#pragma once

typedef int ELEM_TYPE;
#define MAXSIZE 10
typedef struct
{
ELEM_TYPE data[MAXSIZE];
int front;      //头指针
int rear;       //尾指针，若队列不为空，指向队列尾元素的下一个位置
}SqQueue;

void InitQueue(SqQueue *q);
void EnQueue(SqQueue *q,ELEM_TYPE e);
void DeQueue(SqQueue *q,ELEM_TYPE *e);
bool QueueEmpty(SqQueue q);
int QueueLength(SqQueue q);
void ClearQueue(SqQueue *q);
void DestroyQueue(SqQueue *q);
void QueueHead(SqQueue q,ELEM_TYPE *e);
void ShowQueue(SqQueue q);

"sqqueue.cpp"

#include "sqqueue.h"
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

void InitQueue(SqQueue *q)
{
q->front = NULL;
q->rear = NULL;
int i;
for (i=0;i<MAXSIZE;++i)
{
q->data[i] = 0;
}
}

void EnQueue(SqQueue *q,ELEM_TYPE e)
{
if ((q->rear+1)%MAXSIZE == q->front)
{
printf("队列满\n");
return;
}
q->data[q->rear] = e;
q->rear = (q->rear+1)%MAXSIZE;//rear指针向后移动一个位置，若到最后则返回数组头部
}

void DeQueue(SqQueue *q,ELEM_TYPE *e)
{
if(q->front == q->rear)
{
printf("队列为空\n");
return;
}
*e = q->data[q->front];
q->front = (q->front+1)%MAXSIZE;//头指针向后移一个位置，若到最后则返回到数组头部
}

bool QueueEmpty(SqQueue q)
{
return q.front == q.rear;
}

int QueueLength(SqQueue q)
{
return (q.rear-q.front+MAXSIZE)%MAXSIZE;
}

void ClearQueue(SqQueue *q)
{
assert(q != NULL);
while (q->front != q->rear)
{
q->front = (q->front+1)%MAXSIZE;
}
}

void DestroyQueue(SqQueue *q)
{
q->front = NULL;
q->rear = NULL;
}

void QueueHead(SqQueue q,ELEM_TYPE *e)
{
if (q.front == q.rear)
{
printf("队列为空z\n");
return;
}
*e = q.data[q.front];
}

void ShowQueue(SqQueue q)
{

while (q.front != q.rear)
{
printf("data:%d\n",q.data[q.front]);
q.front = (q.front+1)%MAXSIZE;
}
}

队列的链式存储

代码实现：

"linkqueue.h"

#pragma once

typedef int ELEM_TYPE;
typedef struct QNode
{
ELEM_TYPE data;
struct QNode *next;
}QNode,*QueuePtr;

typedef struct
{
QueuePtr front;//队头指针
QueuePtr rear;//队尾指针
}LinkQueue;

void InitQueue(LinkQueue *q);
void DestroyQueue(LinkQueue *q);
void ClearQueue(LinkQueue *q);
bool QueueEmpty(LinkQueue q);
int QueueLength(LinkQueue q);
void GetHead(LinkQueue q,ELEM_TYPE *e);
void EnQueue(LinkQueue *q,ELEM_TYPE e);
void DeQueue(LinkQueue *q,ELEM_TYPE *e);
void showQueue(LinkQueue q);

"linkqueue.cpp"

#include "linkqueue.h"
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

void InitQueue(LinkQueue *q)
{
q->front = q->rear = (QueuePtr)malloc(sizeof(QNode));
if (!q->front)
{
exit(EXIT_FAILURE);
}
q->front->next = NULL;
}

void DestroyQueue(LinkQueue *q)
{
while (q->front)
{
q->rear = q->front->next;
free(q->front);
q->front = q->rear;
}
}

void ClearQueue(LinkQueue *q)
{
QueuePtr p = q->front->next;
while (p)
{
q->front->next = p->next;
if (q->rear == p)
{
q->rear = q->front;
}
free(p);
p = q->front->next;
}
}

bool QueueEmpty(LinkQueue q)
{
if (q.front == q.rear)
{
return true;
}
else
{
return false;
}
}

int QueueLength(LinkQueue q)
{
int i = 0;
QueuePtr p = q.front->next;
while(p)
{
i++;
p = p->next;
}
return i;
}

void GetHead(LinkQueue q,ELEM_TYPE *e)
{
QueuePtr p = q.front->next;
if (p)
{
*e = p->data;
}
}

void EnQueue(LinkQueue *q,ELEM_TYPE e)
{
QueuePtr p = (QueuePtr)malloc(sizeof(QNode));
if (!p)
{
exit(EXIT_FAILURE);
}
p->data = e;
p->next = NULL;
q->rear->next = p;
q->rear = p;
}

void DeQueue(LinkQueue *q,ELEM_TYPE *e)
{
if (q->front == q->rear)
{
printf("队列为空\n");
return;
}
QueuePtr p = q->front->next;
*e = p->data;
q->front->next = p->next;
if (q->rear == p)
{
q->rear = q->front;
}
free(p);
}

void showQueue(LinkQueue q)
{
assert(q.front != NULL);
QueuePtr p = q.front->next;
while (p)
{
printf("data:%d\n",p->data);
p = p->next;
}
}