队列（顺序存储）基础操作

自律的光电人

已于 2022-07-24 16:40:45 修改

阅读量930

点赞数 4

分类专栏：数据结构文章标签： c语言 c++ 蓝桥杯数据结构

于 2022-07-24 16:26:20 首次发布

本文链接：https://blog.csdn.net/gaokuiyuan/article/details/125960349

版权

数据结构专栏收录该内容

8 篇文章 1 订阅

订阅专栏

循环队列（静态分配），结构体定义了一个头指针，一个尾指针，为了判断队空队满，并将其区分，我们需要浪费一个存储空间。使

判断队空的条件为：Q.rear=Q.front

判断队满的条件为:(Q.rear+1)%MaxSize ==Q.front

队长为：(Q.rear+MaxSize-Q.front)%MaxSize

这里的代码初始化后我直接用了一个循环，用入队操作来创建队列，输入9999结束输入。

//循环队列
//为了判断队空和队满，需要浪费一个存储空间
/**/
#include<stdio.h>
#include<stdlib.h>
#define MaxSize 10
typedef int ElemType;
typedef struct {
	ElemType data[MaxSize];
	int front, rear;//队头指针，队尾指针
}SqQueue;
//1.初始化
bool InitQueue(SqQueue& Q) {
	Q.rear = Q.front = 0;
	return true;
}
//2.判断队空
bool QueueEmpty(SqQueue Q) {
	if (Q.front == Q.rear)
		return true;
	else
		return false;
}
//3.判断队满
bool QueueFull(SqQueue Q) {
	if ((Q.rear + 1) % MaxSize == Q.front)
		return true;
	else
		return false;
}
//4.获取队列的长度
int QueueLength(SqQueue& Q) {
	if (Q.front == Q.rear)
		printf("队列为空!\n");
	else
		return ((Q.rear + MaxSize - Q.front) % MaxSize);
}
//5.入队
bool EnQueue(SqQueue& Q, ElemType x) {
	if ((Q.rear + 1) % MaxSize == Q.front)
		return false;
	Q.data[Q.rear] = x;
	Q.rear = (Q.rear + 1)%MaxSize;
	return true;
}
//6.出队
bool DeQueue(SqQueue& Q, ElemType& x) {
	if (Q.rear == Q.front)//判断队空
		return false;
	x = Q.data[Q.front];
	Q.front = (Q.front + 1) % MaxSize;//队头指针后移
	return true;
}
//7.获取队头元素的值
bool GetTop(SqQueue& Q, ElemType &x) {
	if (Q.rear == Q.front)
		return false;
	x = Q.data[Q.front];
	return true;
}
//8.打印队列
void PrintQueue(SqQueue Q) {
	int i;
	printf("要打印的队列为:\n");
	//for (i = 0; i < (Q.rear - Q.front)%MaxSize; i++)
	for (i = Q.front; i < Q.rear;i++)
		printf("%d ",Q.data[i]);
	printf("\n");
}
int main() {

	SqQueue Q;
	int x, e, headelem,i;
	//InitQueue(Q);
	int command;
	while (1) {
		printf("*******************************\n");
		printf("下面是操作界面\n");
		printf("1.队列的初始化                        2.判断队空\n");
		printf("3.判断队满                            4.队列的长度\n");
		printf("5.入队                                6.出队\n");
		printf("7.取队头元素                           8.退出\n");
		printf("*******************************\n");
		printf("请输入您要进行的操作:\n");
		scanf_s("%d", &command);
		switch (command)
		{
		case 1:
			//1.队列的初始化
			InitQueue(Q);
			if (InitQueue(Q) == 1) printf("初始化成功！\n"); else printf("初始化失败！\n");
			printf("请依次输入队列中元素:\n");
			scanf_s("%d", &x);
			while (x != 9999) {
				EnQueue(Q, x);
				scanf_s("%d", &x);
			}
			break;
		case 2:
			//2.判断队空
			if (QueueEmpty(Q) == 1) printf("队列为空!\n"); else printf("队列不空!\n");
			break;
		case 3:
			//3.判断队满  
			if (QueueFull(Q) == 1) printf("队列满!\n"); else printf("队列不满!\n");
			break;
		case 4:
			//4.队列的长度
			printf("队列的长度为：%d\n", QueueLength(Q));
			break;
		case 5:
			//5.入队
			printf("请输入要入队的元素值:\n");
			scanf_s("%d", &i);
			EnQueue(Q, i);
			break;
		case 6:
			//6.出队
			DeQueue(Q, e);
			printf("出队的元素为:%d\n", e);
			break;
		case 7:
			//7.取队头元素
			GetTop(Q, headelem);
			printf("队头元素为:%d\n", headelem);
			break;
		case 8:
			//退出
			break;
		default:
			printf("输入错误\n");
			break;
		}
		PrintQueue(Q);
		printf("\n");

	}
	return 0;
}

为了不浪费存储空间，我们有两种解决办法，第一种是可以用在结构体定义中设置一个int size变量，初始化置为0,。每进行一次入队操作size++，每进行一次出队操作size--。

此时size==0为队空，size==MaxSize为队满，size的值即为队列的长度

//循环队列（不浪费存储空间）
//设置一个size变量，初始化为0，每进行一次入队操作size++。每进行一次出队操作size--。
/**/
#include<stdio.h>
#include<stdlib.h>
#define MaxSize 10
typedef int ElemType;
typedef struct {
	ElemType data[MaxSize];
	int front, rear;//队头指针，队尾指针
	int size;//队列当前长度
}SqQueue;
//初始化
bool InitQueue(SqQueue& Q) {
	Q.rear = Q.front = 0;
	Q.size = 0;
	return true;
}
//判断队空
bool QueueEmpty(SqQueue Q) {
	if (Q.size==0)
		return true;
	else
		return false;
}
//判断队满
bool QueueFull(SqQueue Q) {
	if (Q.size==MaxSize)
		return true;
	else
		return false;
}

/*获取队列的长度（忽略）
int QueueLength(SqQueue& Q) {
	if (Q.front == Q.rear)
		printf("队列为空!\n");
	else
		return ((Q.rear + MaxSize - Q.front) % MaxSize);
}*/
int QueueLength(SqQueue& Q) {
	return Q.size;
}
//入队
bool EnQueue(SqQueue& Q, ElemType x) {
	if ((Q.rear + 1) % MaxSize == Q.front)
		return false;
	Q.data[Q.rear] = x;
	Q.rear = (Q.rear + 1) % MaxSize;
	Q.size++;
	return true;
}
//出队
bool DeQueue(SqQueue& Q, ElemType& x) {
	if (Q.rear == Q.front)
		return false;
	x = Q.data[Q.front];
	Q.front = (Q.front + 1) % MaxSize;
	Q.size--;
	return true;
}
//获取队头元素的值
bool GetTop(SqQueue& Q, ElemType& x) {
	if (Q.rear == Q.front)
		return false;
	x = Q.data[Q.front];
	return true;
}
//打印队列
void PrintQueue(SqQueue& Q) {
	int i;
	printf("要打印的队列为:\n");
	for (i = Q.front; i < Q.size; i++) {
		printf("%d ", Q.data[i]);
	}
	printf("\n");
}

int main() {

	SqQueue Q;
	int x, e, headelem, i;
	//InitQueue(Q);
	int command;
	while (1) {
		printf("*******************************\n");
		printf("下面是操作界面\n");
		printf("1.队列的初始化                        2.判断队空\n");
		printf("3.判断队满                            4.队列的长度\n");
		printf("5.入队                                6.出队\n");
		printf("7.取队头元素                           8.退出\n");
		printf("*******************************\n");
		printf("请输入您要进行的操作:\n");
		scanf_s("%d", &command);
		switch (command)
		{
		case 1:
			//1.队列的初始化
			InitQueue(Q);
			if (InitQueue(Q) == 1) printf("初始化成功！\n"); else printf("初始化失败！\n");
			printf("请依次输入队列中元素:\n");
			scanf_s("%d", &x);
			while (x != 9999) {
				EnQueue(Q, x);
				scanf_s("%d", &x);
			}
			break;
		case 2:
			//2.判断队空
			if (QueueEmpty(Q) == 1) printf("队列为空!\n"); else printf("队列不空!\n");
			break;
		case 3:
			//3.判断队满  
			if (QueueFull(Q) == 1) printf("队列满!\n"); else printf("队列不满!\n");
			break;
		case 4:
			//4.队列的长度
			printf("队列的长度为：%d\n", QueueLength(Q));
			break;
		case 5:
			//5.入队
			printf("请输入要入队的元素值:\n");
			scanf_s("%d", &i);
			EnQueue(Q, i);
			break;
		case 6:
			//6.出队
			DeQueue(Q, e);
			printf("出队的元素为:%d\n", e);
			break;
		case 7:
			//7.取队头元素
			GetTop(Q, headelem);
			printf("队头元素为:%d\n", headelem);
			break;
		case 8:
			//退出
			break;
		default:
			printf("输入错误\n");
			break;
		}
		PrintQueue(Q);
		printf("\n");

	}
	return 0;
}

第二种方法：在结构体中设置一个tag变量，初始化为0，每进行一次入队操作tag置为1，每进行一次出队操作tag置为0.

此时队空的条件是：Q.rear==Q.front&&Q.tag==0

此时队满的条件是：Q.rear==Q.front&&Q.tag==1

队长：(Q.rear + MaxSize - Q.front) % MaxSize

//循环队列（不浪费存储空间）
/*在定义结构体的时候加一个tag变量
每次进行入队操作将tag置为1，每次进行出队操作将tag置为0。
1.当Q.front==Q.rear&&tag=1时,说明最后一次进行的操作是入队操作，则这时队列满
2.当Q.front==Q.rear&&tag=0时,说明最后一次进行的操作时出队操作，则这时队列空
*/
/**/
#include<stdio.h>
#include<stdlib.h>
#define MaxSize 10
typedef int ElemType;
typedef struct {
	ElemType data[MaxSize];
	int front, rear;//队头指针，队尾指针
	int tag;
}SqQueue;
//初始化
bool InitQueue(SqQueue& Q) {
	Q.rear = Q.front = 0;
	Q.tag = 0;
	return true;
}
//判断队空
bool QueueEmpty(SqQueue Q) {
	if ((Q.front == Q.rear)&&Q.tag==0)
		return true;
	else
		return false;
}
//判断队满
bool QueueFull(SqQueue Q) {
	if ((Q.front == Q.rear) && Q.tag == 1)
		return true;
	else
		return false;
}
//获取队列的长度
int QueueLength(SqQueue& Q) {
	if (Q.front == Q.rear)
		printf("队列为空!\n");
	else
		return ((Q.rear + MaxSize - Q.front) % MaxSize);
}
//入队
bool EnQueue(SqQueue& Q, ElemType x) {
	if ((Q.rear + 1) % MaxSize == Q.front)
		return false;
	Q.data[Q.rear] = x;
	Q.rear = (Q.rear + 1) % MaxSize;
	Q.tag = 1;
	return true;
}
//出队
bool DeQueue(SqQueue& Q, ElemType& x) {
	if (Q.rear == Q.front)
		return false;
	x = Q.data[Q.front];
	Q.front = (Q.front + 1) % MaxSize;
	Q.tag = 0;
	return true;
}
//获取队头元素的值
bool GetTop(SqQueue& Q, ElemType& x) {
	if (Q.rear == Q.front)
		return false;
	x = Q.data[Q.front];
	return true;
}
//打印队列
void PrintQueue(SqQueue& Q) {
	int i;
	printf("要打印的队列为:\n");
	for (i = Q.front; i < Q.rear; i++) {
		printf("%d ", Q.data[i]);
	}
	printf("\n");
}
int main() {

	SqQueue Q;
	int x, e, headelem, i;
	//InitQueue(Q);
	int command;
	while (1) {
		printf("*******************************\n");
		printf("下面是操作界面\n");
		printf("1.队列的初始化                        2.判断队空\n");
		printf("3.判断队满                            4.队列的长度\n");
		printf("5.入队                                6.出队\n");
		printf("7.取队头元素                           8.退出\n");
		printf("*******************************\n");
		printf("请输入您要进行的操作:\n");
		scanf_s("%d", &command);
		switch (command)
		{
		case 1:
			//1.队列的初始化
			InitQueue(Q);
			if (InitQueue(Q) == 1) printf("初始化成功！\n"); else printf("初始化失败！\n");
			printf("请依次输入队列中元素:\n");
			scanf_s("%d", &x);
			while (x != 9999) {
				EnQueue(Q, x);
				scanf_s("%d", &x);
			}
			break;
		case 2:
			//2.判断队空
			if (QueueEmpty(Q) == 1) printf("队列为空!\n"); else printf("队列不空!\n");
			break;
		case 3:
			//3.判断队满  
			if (QueueFull(Q) == 1) printf("队列满!\n"); else printf("队列不满!\n");
			break;
		case 4:
			//4.队列的长度
			printf("队列的长度为：%d\n", QueueLength(Q));
			break;
		case 5:
			//5.入队
			printf("请输入要入队的元素值:\n");
			scanf_s("%d", &i);
			EnQueue(Q, i);
			break;
		case 6:
			//6.出队
			DeQueue(Q, e);
			printf("出队的元素为:%d\n", e);
			break;
		case 7:
			//7.取队头元素
			GetTop(Q, headelem);
			printf("队头元素为:%d\n", headelem);
			break;
		case 8:
			//退出
			break;
		default:
			printf("输入错误\n");
			break;
		}
		PrintQueue(Q);
		printf("\n");

	}
	return 0;
}

文章结束了，点个赞再走，后续队列的其他操作会在这个文章补充的。