14.队列的顺序存储

1.队列的概念

1.1队列的定义

队列（queue）是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。
队列是一种先进先出（First In First Out）的线性表，简称FIFO。允许插入的一端称为队尾，允许删除的一端称为队头。

队头（Front）：允许删除的一端，又称队首。
队尾（Rear）：允许插入的一端。
空队列：不包含任何元素的空表。

1.2队列的常见基本操作

InitQueue(&Q)：初始化队列，构造一个空队列Q。
QueueIsEmpty(Q)：判队列空，若队列Q为空返回true，否则返回false。
QueueIsFull(Q)：判队列满，若队列Q为满返回true，否则返回false。
PrintQueue(Queue* Q)：打印队列中的各元素
EnQueue(&Q, x)：入队，若队列Q未满，将x加入，使之成为新的队尾。
DeQueue(&Q, &x)：出队，若队列Q非空，删除队头元素，并用x返回。
ClearQueue(Queue* Q)：清空队列
GetHead(Q, &x)：读队头元素，若队列Q非空，则将队头元素赋值给x。

————————————————
版权声明：本文为CSDN博主「UniqueUnit」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/Real_Fool_/article/details/113852222

2.队列的顺序存储

采用数组来保存队列的元素，设立一个队首指针front，一个队尾指针rear，分别指向队首和队尾元素。则
rear-front 即为存储的元素个数！

2.1队列定义

#define MaxSize 5 //队列的最大容量
typedef int DataType; //队列中元素类型
typedef struct Queue
{
    DataType queue[MaxSize];
    int front; //队头指针
    int rear; //队尾指针
}SeqQueue;

2.2队列初始化

//队列初始化，将队列初始化为空队列
void InitQueue(SeqQueue *SQ)
{
    if(!SQ) return;
    SQ->front = SQ->rear = 0;//把对头和队尾指针同时置0
}

2.3队列为空

//判断队列为空
int IsEmpty(SeqQueue *SQ)
{
    if(!SQ) return 0;
    if (SQ->front == SQ->rear)
    {
        return 1;
    }
    return 0;
}

2.4队列为满

//判断队列是否为满
int IsFull(SeqQueue *SQ)
{
    if(!SQ) return 0;
    if (SQ->rear == MaxSize)
    {
        return 1;
    }
    return 0;
}

2.5入队

//入队,将元素data 插入到队列SQ 中
int EnterQueue( SeqQueue *SQ, DataType data)
{
    if(!SQ) return 0;
    if(IsFull(SQ))
    {
        cout<<"无法插入元素"<<data<<", 队列已满!"<<endl;
        return 0;
    }
    SQ->queue[SQ->rear] = data; //在队尾插入元素data
    SQ->rear++; //队尾指针后移一位
    return 1;
}

2.6打印队列中的元素

//打印队列中的各元素
void PrintQueue(SeqQueue* SQ)
{
    if(!SQ) return ;
    int i = SQ->front;
    while(i<SQ->rear)
    {
        cout<<setw(4)<<SQ->queue[i];
        i++;
    }
    cout<<endl;
}

2.7出队

方式 1 - 删除 front 所指的元素, 后面所有元素前移 1 并返回被删除元素

//出队，将队列中队头的元素data 出队，后面的元素向前移动
int DeleteQueue(SeqQueue* SQ, DataType *data)
{
    if(!SQ || IsEmpty(SQ))
    {
        cout<<"队列为空！"<<endl;
        return 0;
    }
    if(!data) return 0;
    *data = SQ->queue[SQ->front];
    for(int i=SQ->front+1; i<SQ->rear; i++)//移动后面的元素
    {
        SQ->queue[i-1]=SQ->queue[i];
    }
    SQ->rear--;//队尾指针前移一位
    return 1;
}

方式 2 - 删除 front 所指的元素，然后加 1 并返回被删元素。8979438401111

//出队，将队列中队头的元素data 出队，出队后队头指针front 后移一位
int DeleteQueue2(SeqQueue* SQ,DataType* data)
{
    if (!SQ || IsEmpty(SQ))
    {
        cout<<"队列为空！"<<endl;
        return 0;
    }
    if(SQ->front>=MaxSize)
    {
        cout<<"队列已到尽头!"<<endl;
        return 0;
    }
    *data = SQ->queue[SQ->front]; //出队元素值
    SQ->front = (SQ->front)+1; //队首指针后移一位
    return 1;
}

2.8取队首元素：返回front 指向的元素值

//获取队首元素
int GetHead(SeqQueue* SQ,DataType* data)
{
    if (!SQ || IsEmpty(SQ))
    {
        cout<<"队列为空!"<<endl;
    }
    return *data = SQ->queue[SQ->front];
}

2.9清空队列

//清空队列
void ClearQueue(SeqQueue* SQ)
{
    SQ->front = SQ->rear = 0;
}

2.10获取队列长度

//获取队列中元素的个数
int getLength(SeqQueue* SQ)
{
    if(!SQ) return 0;
    return SQ->rear-SQ->front;
}

完整代码

#include <stdio.h>
#include <assert.h>
#include <Windows.h>
#include <iostream>
#include <iomanip>

using namespace std;

#define MaxSize 5 //队列的最大容量

typedef int DataType; //队列中元素类型

typedef struct Queue
{
    DataType queue[MaxSize];
    int front; //队头指针
    int rear; //队尾指针
}SeqQueue;

//队列初始化，将队列初始化为空队列
void InitQueue(SeqQueue* SQ)
{
    if (!SQ) return;
    SQ->front = SQ->rear = 0; //把对头和队尾指针同时置0
}

//判断队列为空
int IsEmpty(SeqQueue* SQ)
{
    if (!SQ) return 0;
    if (SQ->front == SQ->rear)
    {
        return 1;
    }
    return 0;
}

//判断队列是否为满
int IsFull(SeqQueue* SQ)
{
    if (!SQ) return 0;
    if (SQ->rear == MaxSize)
    {
        return 1;
    }
    return 0;
}

//入队,将元素data 插入到队列SQ 中
int EnterQueue(SeqQueue* SQ, DataType data) 
{
    if (!SQ) return 0;

    if (IsFull(SQ))
    {
        cout << "无法插入元素" << data << ", 队列已满!" << endl;
        return 0;
    }

    SQ->queue[SQ->rear] = data; //在队尾插入元素data
    SQ->rear++; //队尾指针后移一位

    return 1;
}

//出队，将队列中队头的元素data 出队，后面的元素向前移动
int DeleteQueue(SeqQueue * SQ, DataType * data) 
{
    if (!SQ || IsEmpty(SQ)) 
    {
        cout << "队列为空！" << endl;
        return 0;
    }

    if (!data) return 0;

    *data = SQ->queue[SQ->front];
    for (int i = SQ->front + 1; i < SQ->rear; i++)//移动后面的元素 
    {
        SQ->queue[i - 1] = SQ->queue[i];
    }
    SQ->rear--;//队尾指针前移一位

    return 1;
}

//出队，将队列中队头的元素data 出队，出队后队头指针front 后移一位
int DeleteQueue2(SeqQueue* SQ, DataType* data)
{
    if (!SQ || IsEmpty(SQ))
    {
        cout << "队列为空！" << endl;
        return 0;
    }

    if (SQ->front >= MaxSize) 
    {
        cout << "队列已到尽头!" << endl;
        return 0;
    }

    *data = SQ->queue[SQ->front]; //出队元素值
    SQ->front = (SQ->front) + 1; //队首指针后移一位
    return 1;
}
//打印队列中的各元素
void PrintQueue(SeqQueue* SQ)
{
    if (!SQ) return;

    int i = SQ->front; 
    while (i < SQ->rear)
    {
        cout << setw(4) << SQ->queue[i];
        i++;
    }
    cout << endl;
}

//获取队首元素，不出队
int GetHead(SeqQueue* SQ, DataType* data)
{
    if (!SQ || IsEmpty(SQ))
    {
        cout << "队列为空!" << endl;
    }
    return *data = SQ->queue[SQ->front];
}

//清空队列
void ClearQueue(SeqQueue* SQ)
{
    if (!SQ) return;
    SQ->front = SQ->rear = 0;
}

//获取队列中元素的个数
int getLength(SeqQueue* SQ)
{
    if (!SQ) return 0;
    return SQ->rear - SQ->front;
}

int main()
{
    SeqQueue* SQ = new SeqQueue;
    DataType data = -1;

    //初始化队列
    InitQueue(SQ);

    //入队
    for (int i = 0; i < 7; i++) 
    {
        EnterQueue(SQ, i);
    }
    //打印队列中的元素
    printf("队列中的元素(总共%d 个)：", getLength(SQ));
    PrintQueue(SQ);
    cout << endl;
    //出队
    for(int i=0; i<10; i++)
    {
        if (DeleteQueue2(SQ, &data))
        {
            cout << "出队的元素是：" << data << endl;
        }
        else
        {
        cout << "出队失败！" << endl;
        }
    }

    //打印队列中的元素
    printf("出队一个元素后，队列中剩下的元素：");
    PrintQueue(SQ);
    cout << endl;

    system("pause");
    return 0;
}

3.队列的链式存储

队列的链式存储结构，其实就是线性表的单链表，只不过它只是尾进头出而已，我们把它简称为链队列。为了
操作上的方便，我们将队头指针指向链队列的头结点，而队尾指针指向终端节点

3.1队列的定义

#define MaxSize 5 //队列的最大容量
typedef int DataType;//队列中元素的类型

typedef struct _QNode//结点结构
{
	DataType data;
	struct _QNode* next;
}QNode;

typedef QNode* QueuePtr;

typedef struct Queue
{
	int length;//队列的长度
	QueuePtr front;//队头指针
	QueuePtr rear;//队尾指针
}LinkQueue;

3.2队列初始化

//队列初始化，将队列初始化为空队列
void InitQueue(LinkQueue* LQ)
{
	if (!LQ) return;

	LQ->length = 0;
	LQ->front = LQ->rear = NULL;//把队头指针和队尾指针同时置0
}

3.3判断队列是否为空

//判断队列为空
int IsEmpty(LinkQueue *LQ)
{
	if (!LQ) return 0;

	if (LQ->front == NULL)
	{
		return 1;
	}
	return 0;
}

3.4判断队列是否为满

//判断队列是否为满
int IsFull(LinkQueue* LQ)
{
	if (!LQ) return 0;

	if (LQ->length == MaxSize)
	{
		return 1;
	}
	return 0;
}

3.5入队

空队列时，front 和rear 都指向空。

//入队,将元素data 插入到队列LQ 中
int EnterQueue(LinkQueue* LQ, DataType data)
{
	if (!LQ) return 0;

	if (IsFull(LQ))
	{
		cout << "队列无法插入元素" << data << "，队列已满" << endl;
		return 0;
	}

	//创建结点
	QNode* qNode = new QNode;
	qNode->data = data;
	qNode->next = NULL;

	if (IsEmpty(LQ))//空队列
	{
		LQ->front = LQ->rear = qNode;
	}
	else
	{
		LQ->rear->next = qNode;//在队尾插入结点qNode
		LQ->rear = qNode;//队尾指向新插入的结点
	}
	LQ->length++;

	return 1;
}

3.6删除结点

//出队，将队列中队头的元素data出队，后面的元素向前移动
int DeleteQueue(LinkQueue* LQ, DataType* data)
{
	QNode* tmp = NULL;

	if (!LQ || IsEmpty(LQ))
	{
		cout << "队列为空" << endl;
		return 0;
	}

	if (!data) 
		return 0;

	tmp = LQ->front;

	LQ->front = tmp->next;
	if (!LQ->front) 
		LQ->rear = NULL;//如果队头出列后不存在其他元素，则rear结点也要置空

	*data = tmp->data;
	LQ->length--;

	delete tmp;//配合入队时用了new

	return 1;
}

3.7获取队首元素

//获取队首元素，不出队
int GetHead(LinkQueue* LQ, DataType* data)
{
	if (!LQ || IsEmpty(LQ))
	{
		cout << "队列为空！" << endl;
		return 0;
	}

	if (!data) return 0;

	*data = LQ->front->data;
	return 1;
}

3.8清空队列

//清空队列
void ClearQueue(LinkQueue* LQ)
{
	if (!LQ) return;

	while (LQ->front)
	{
		QueuePtr tmp = LQ->front->next;
		delete LQ->front;
		LQ->front = tmp;
	}
	LQ->front = LQ->rear = NULL;
	LQ->length = 0;
}

3.9获取队列中元素个数

//获取队列中元素的个数
int getLength(LinkQueue* LQ)
{
	if (!LQ) return 0;
	
	return LQ->length;
}

3.10打印队列中的元素

//打印队列中的各元素
void PrintQueue(LinkQueue *LQ)
{ 
    QueuePtr tmp;
    if(!LQ) return ;
    if(LQ->front==NULL)
    {
        cout<<"队列为空！";
        return ;
    }
    tmp = LQ->front;
    while(tmp)
    {
        cout<<setw(4)<<tmp->data;
        tmp = tmp->next;
    }
    cout<<endl;
}

完整代码

#include <stdio.h>
#include <assert.h>
#include <Windows.h>
#include <iostream>
#include <iomanip>

using namespace std;

#define MaxSize 5 //队列的最大容量
typedef int DataType; //队列中元素类型

typedef struct _QNode//结点结构
{ 
	DataType data;
	struct _QNode* next;
}QNode;

typedef QNode* QueuePtr;

typedef struct Queue
{
	int length; //队列的长度
	QueuePtr front; //队头指针
	QueuePtr rear; //队尾指针
}LinkQueue;

//队列初始化，将队列初始化为空队列
void InitQueue(LinkQueue* LQ)
{
	if (!LQ) return;
	LQ->length = 0;
	LQ->front = LQ->rear = NULL; //把对头和队尾指针同时置0
}

//判断队列为空
int IsEmpty(LinkQueue* LQ)
{
	if (!LQ) return 0;
	if (LQ->front == NULL)
	{
		return 1;
	}
	return 0;
}

//判断队列是否为满
int IsFull(LinkQueue* LQ)
{
	if (!LQ) return 0;
	if (LQ->length == MaxSize)
	{
		return 1;
	}
	return 0;
}

//入队,将元素data 插入到队列LQ 中
int EnterQueue(LinkQueue* LQ, DataType data) 
{
	if (!LQ) return 0;
	if (IsFull(LQ)) 
	{
		cout << "无法插入元素" << data << ", 队列已满!" << endl;
		return 0;
	}
	QNode* qNode = new QNode;
	qNode->data = data;
	qNode->next = NULL;
	if (IsEmpty(LQ))//空队列
	{
		LQ->front = LQ->rear = qNode;
	}
	else
	{
		LQ->rear->next = qNode;//在队尾插入节点qNode
		LQ->rear = qNode; //队尾指向新插入的节点
	}
	LQ->length++;
	return 1;
}

//出队，将队列中队头的元素出队，其后的第一个元素成为新的队首
int DeleteQueue(LinkQueue* LQ, DataType* data) {
	QNode* tmp = NULL;
	if (!LQ || IsEmpty(LQ)) 
	{
		cout << "队列为空！" << endl;
		return 0;
	}

	if (!data) return 0;

	tmp = LQ->front;
	LQ->front = tmp->next;
	if (!LQ->front) LQ->rear = NULL;//如果对头出列后不存在其他元素，则rear节点也要置空
		* data = tmp->data;
	LQ->length--;
	delete tmp;

	return 1;
}

//打印队列中的各元素
void PrintQueue(LinkQueue* LQ)
{
	QueuePtr tmp;

	if (!LQ) return;

	if (LQ->front == NULL) 
	{
		cout << "队列为空！";
		return;
	}

	tmp = LQ->front;

	while (tmp)
	{
		cout << setw(4) << tmp->data;
		tmp = tmp->next;
	}
	cout << endl;
}

//获取队首元素，不出队
int GetHead(LinkQueue* LQ, DataType* data)
{
	if (!LQ || IsEmpty(LQ))
	{ 
		cout << "队列为空!" << endl;
		return 0;
	}

	if (!data) return 0;

	*data = LQ->front->data;

	return 1;
}

//清空队列
void ClearQueue(LinkQueue* LQ)
{
	if (!LQ) return;
	while (LQ->front) 
	{
		QueuePtr tmp = LQ->front->next;
		delete LQ->front;
		LQ->front = tmp;
	}

	LQ->front = LQ->rear = NULL;
	LQ->length = 0;
}

//获取队列中元素的个数
int getLength(LinkQueue* LQ) 
{
	if (!LQ) return 0;
	return LQ->length;
}

int main()
{
	LinkQueue* LQ = new LinkQueue;
	DataType data = -1;
	//初始化队列
	InitQueue(LQ);
	//入队
	for (int i = 0; i < 7; i++) {
		EnterQueue(LQ, i);
	}
	//打印队列中的元素
	printf("队列中的元素(总共%d 个)：", getLength(LQ)); 
	PrintQueue(LQ);
	cout << endl;

	//出队
	for(int i=0; i<10; i++)
	{
		if (DeleteQueue(LQ, &data)) 
		{
			cout << "出队的元素是：" << data << endl;
		}
		else 
		{	
			cout << "出队失败！" << endl;
		}
	}

	//打印队列中的元素
	printf("出队一个元素后，队列中剩下的元素[%d]：", getLength(LQ));
	PrintQueue(LQ);
	cout << endl;

	ClearQueue(LQ);
	cout << "清空队列!\n";
	PrintQueue(LQ);

	//清理资源
	delete LQ;
	system("pause");
	return 0;
}

参考资料来源：

奇牛学院