数据结构之栈与队列（二）

已于 2023-04-13 16:49:08 修改
阅读量183 收藏 2
点赞数 4
CC 4.0 BY-SA版权
分类专栏： 数据结构 文章标签： 算法 c语言
于 2023-04-13 16:34:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/semu2000/article/details/130131379

目录


tips:本文只讲述队列！！！

队列

队列（Queue）简称队，同栈一样也是一种操作受限的线性表，只允许在表的一端进行插入，而在表的另一端进行删除。向队列中插入元素称为入队或进队；删除元素称为出队或离队。这和我们日常生活中的排队是一致的，最早排队的也是最早离队的，其操作的特性是先进先出（First In First Out）。
队列

1. 顺序循环队列

1.2 定义

1.2.1 队列的顺序存储

队列的顺序实现是指分配一块连续的存储单元存放队列中的元素，并附设两个指针：队头指针front指向队头元素，队尾指针rear指向队尾元素的下一个位置。
顺序队列存在“假溢出”的缺点。
顺序队列中的假溢出

1.2.2 循环队列

把队列的这种头尾相接的顺序存储结构称为循环队列。当队首指针Q.front = MAXSIZE-1后，再前进一个位置就自动到0.
其中的重点是区分队空和队满的情况，常用的处理方法是，牺牲一个单元来区分队空和队满，入队是少用一个队列单元。
队满条件：(Q.rear + 1) % MAXSIZE = Q.front
队空条件：Q.front == Q.rear
队列中元素个数：（Q.rear-Q.front+MAXSIZE）% MAXSIZE

1.3 基本操作

//初始化
//判空
//求队列长
//遍历输出
//入队
//获取队头元素
//出队
//清空

1.4 代码实现

#define _CRT_SECURE_NO_WARNINGS 1

#include <stdio.h>
#include <stdlib.h>

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

typedef int Status;
typedef int ElemType;

#define MAXSIZE 20

typedef struct 
{
	ElemType data[MAXSIZE];
	int front;   //首指针
	int rear;     //尾指针
}seQueue;
1.4.1 初始化
//初始化
Status QueueInit(seQueue* Q)
{
	Q->front = 0;
	Q->rear = 0;

	return OK;
}
1.4.2 判空
//判空
Status QueueEmpty(seQueue Q)
{
	if (Q.front == Q.rear)
	{
		return TRUE;
	}
	else
	{
		return FALSE;
	}
}
1.4.3 求队列长
//求队列长度
int QueueLength(seQueue Q)
{
	return (Q.rear - Q.front + MAXSIZE) % MAXSIZE;  //
}
1.4.4 遍历输出
//遍历输出
Status QueueTraverse(seQueue Q)
{
	int i = 0;
	while ((i + Q.front)%MAXSIZE != Q.rear)
	{
		printf("%d ", Q.data[i+Q.front]);
		i = i + 1;
	}
	printf("\n");
	return OK;
}

在这里插入图片描述

1.4.5 入队
//插入元素（入队）
Status EnterQueue(seQueue* Q, ElemType e)
{
	if ((Q->rear + 1) % MAXSIZE == Q->front)   //队满报错
	{
		return ERROR;
	}
	//将新元素 赋值给 队尾指针指向的位置
	Q->data[Q->rear] = e;
	Q->rear = (Q->rear + 1) % MAXSIZE;   //rear指针向后移动一个位置，若是在队列最后则移动到队头

	return OK;
}

在这里插入图片描述

1.4.6 获取队头元素
//读取队头元素
Status GetHead(seQueue Q, ElemType* e)
{
	if (Q.front == Q.rear)
	{
		return ERROR;
	}
	*e = Q.data[Q.front];

	return OK;
}

在这里插入图片描述

1.4.7 出队
//删除元素（出队）
Status DeleteQueue(seQueue* Q, ElemType* e)
{
	if (Q->front == Q->rear)   //队空报错
	{
		return ERROR;
	}
	*e = Q->data[Q->front];
	Q->front = (Q->front + 1) % MAXSIZE;

	return OK;
}

在这里插入图片描述

1.4.8 清空
//清空
Status QueueClear(seQueue* Q)
{
	Q->front = Q->rear = 0;

	return 0;
}

在这里插入图片描述

1.5 完整代码

#define _CRT_SECURE_NO_WARNINGS 1

#include <stdio.h>
#include <stdlib.h>

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

typedef int Status;
typedef int ElemType;

#define MAXSIZE 20

typedef struct 
{
	ElemType data[MAXSIZE];
	int front;   //首指针
	int rear;     //尾指针
}seQueue;

//初始化
Status QueueInit(seQueue* Q)
{
	Q->front = 0;
	Q->rear = 0;

	return OK;
}

//判空
Status QueueEmpty(seQueue Q)
{
	if (Q.front == Q.rear)
	{
		return TRUE;
	}
	else
	{
		return FALSE;
	}
}

//求队列长度
int QueueLength(seQueue Q)
{
	return (Q.rear - Q.front + MAXSIZE) % MAXSIZE;  //
}


//遍历输出
Status QueueTraverse(seQueue Q)
{
	int i = 0;
	while ((i + Q.front)%MAXSIZE != Q.rear)
	{
		printf("%d ", Q.data[i+Q.front]);
		i = i + 1;
	}
	printf("\n");
	return OK;
}




//插入元素（入队）
Status EnterQueue(seQueue* Q, ElemType e)
{
	if ((Q->rear + 1) % MAXSIZE == Q->front)   //队满报错
	{
		return ERROR;
	}
	//将新元素 赋值给 队尾指针指向的位置
	Q->data[Q->rear] = e;
	Q->rear = (Q->rear + 1) % MAXSIZE;   //rear指针向后移动一个位置，若是在队列最后则移动到队头

	return OK;
}

//读取队头元素
Status GetHead(seQueue Q, ElemType* e)
{
	if (Q.front == Q.rear)
	{
		return ERROR;
	}
	*e = Q.data[Q.front];

	return OK;
}

//删除元素（出队）
Status DeleteQueue(seQueue* Q, ElemType* e)
{
	if (Q->front == Q->rear)   //队空报错
	{
		return ERROR;
	}
	*e = Q->data[Q->front];
	Q->front = (Q->front + 1) % MAXSIZE;

	return OK;
}



//清空
Status QueueClear(seQueue* Q)
{
	Q->front = Q->rear = 0;

	return 0;
}


void test01()
{
	//初始化
	seQueue Q;
	QueueInit(&Q);
	//判空
	Status i_empty = QueueEmpty(Q);
	printf("队列是否为空(1为是/0为否)：%d\n", i_empty); //队列是否为空(1为是/0为否)：1
	//求队列长度
	Status i_length = QueueLength(Q);
	printf("队列的长度为：%d\n", i_length);  //队列的长度为：0

	printf("-------------------------------\n");

	//入队
	for (int i = 0; i < 10; i++)
	{
		EnterQueue(&Q, i);
	}
	//判空
	i_empty = QueueEmpty(Q);
	printf("队列是否为空(1为是/0为否)：%d\n", i_empty); //队列是否为空(1为是/0为否)：0
	//求队列长度
	i_length = QueueLength(Q);
	printf("队列的长度为：%d\n", i_length);  //队列的长度为：10
	//遍历输出
	QueueTraverse(Q);                //0 1 2 3 4 5 6 7 8 9

	printf("-------------------------------\n");

	//读取队头元素
	ElemType e1 = -1;
	GetHead(Q, &e1);
	printf("队列中队头的元素为：%d\n", e1);  //队列中队头的元素为：0

	printf("-------------------------------\n");

	//出队
	ElemType e2 = -1;
	DeleteQueue(&Q, &e2);
	printf("队列中被删除的元素为：%d\n", e2);  //队列中被删除的元素为：0
	//判空
	i_empty = QueueEmpty(Q);
	printf("队列是否为空(1为是/0为否)：%d\n", i_empty); //队列是否为空(1为是/0为否)：0
	//求队列长度
	i_length = QueueLength(Q);
	printf("队列的长度为：%d\n", i_length);  //队列的长度为：9
	QueueTraverse(Q);  //1 2 3 4 5 6 7 8 9

	printf("-------------------------------\n");

	//清空
	QueueClear(&Q);
	//判空
	i_empty = QueueEmpty(Q);
	printf("队列是否为空(1为是/0为否)：%d\n", i_empty); //队列是否为空(1为是/0为否)：1
	//求队列长度
	i_length = QueueLength(Q);
	printf("队列的长度为：%d\n", i_length);  //队列的长度为：0
	QueueTraverse(Q);  //(为空)
	
}

int main()
{
	test01();


	system("pause");
	return 0;
}

2. 链队列

2.2 定义

队列的链式存储结构，其实就是线性表的单链表，只不过它只能尾进头出而已，我们把它简称为链队列。
在这里插入图片描述

2.3 基本操作

//初始化
//判空
//求队长
//遍历输出
//入队
//获取队头元素
//出队
//清空
//销毁

2.4 代码实现

#define _CRT_SECURE_NO_WARNINGS 1

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

typedef int Status;
typedef int ElemType;

typedef struct QNode
{
	ElemType data;
	struct QNode* next;
}QNode, * QueuePtr;

typedef struct
{
	QueuePtr front, rear;
}LinkQueue;
2.4.1 初始化
//初始化
Status QueueInit(LinkQueue* Q)
{
	//开辟空间
	Q->front = Q->rear = (QueuePtr)malloc(sizeof(QNode)); //注意要sizeof(QNode)
	//
	if (!Q->front)
	{
		exit(OVERFLOW);
	}

	Q->front->next = NULL;

	return OK;
}
2.4.2判空
//判空
Status QueueEmpty(LinkQueue Q)
{
	if (Q.front == Q.rear)
	{
		return TRUE;
	}
	else
	{
		return FALSE;
	}
}
2.4.3求队长
/求队长
int QueueLength(LinkQueue Q)
{
	QueuePtr p = Q.front;
	int i = 0;
	while (p != Q.rear)
	{
		p = p->next;
		i++;
	}

	return i;
}
2.4.4遍历输出
/遍历输出
Status QueueTraverse(LinkQueue Q)
{
	QueuePtr p = Q.front->next;

	while (p)
	{
		printf("%d ", p->data);
		p = p->next;
	}
	printf("\n");
	return OK;
}

在这里插入图片描述

2.4.5入队
//入队
Status EnterQueue(LinkQueue* Q, ElemType e)
{
	QueuePtr s = (QueuePtr)malloc(sizeof(QNode));
	if (!s)
	{
		exit(OVERFLOW);
	}
	s->data = e;
	s->next = NULL;

	Q->rear->next = s;
	Q->rear = s;

	return OK;
}

在这里插入图片描述

2.4.6获取队头元素
//读取队头元素
/* 若队列不空,则用e返回Q的队头元素,并返回OK,否则返回ERROR */
Status GetHead(LinkQueue Q, ElemType* e)
{
	//队空报错
	if (Q.front == Q.rear)
	{
		return ERROR;
	}

	QueuePtr p;
	p = Q.front->next;
	*e = p->data;

	return OK;
}

在这里插入图片描述

2.4.7出队
//出队
Status DeleteQueue(LinkQueue* Q, ElemType* e)
{
	if (Q->front == Q->rear)  //队空报错
	{
		return ERROR;
	}

	QueuePtr p;
	p = Q->front->next;
	*e = p->data;
	Q->front->next = p->next;
	if (p == Q->rear)
	{
		Q->rear = Q->front; //若要出队的元素为最后一个元素，则队列恢复到初始化的状态
	}
	free(p);

	return OK;

}

在这里插入图片描述

2.4.8清空
//清空
Status QueueClear(LinkQueue* Q)
{
	QueuePtr p, q;
	p = Q->front->next;
	while (p)
	{
		q = p;
		p = p->next;
		free(q);
	}
	Q->rear = Q->front;
	Q->front->next = NULL;

	return OK;
}

在这里插入图片描述

2.4.9销毁
//销毁队列空间
Status DestoryQueue(LinkQueue* Q)
{
	while (Q->front)
	{
		Q->rear = Q->front->next;  //从队头开始销毁队列空间
		free(Q->front);
		Q->front = Q->rear;
	}

	return OK;
}

在这里插入图片描述

2.5 完整代码

#define _CRT_SECURE_NO_WARNINGS 1

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

typedef int Status;
typedef int ElemType;

typedef struct QNode
{
	ElemType data;
	struct QNode* next;
}QNode, * QueuePtr;

typedef struct
{
	QueuePtr front, rear;
}LinkQueue;

//初始化
Status QueueInit(LinkQueue* Q)
{
	//开辟空间
	Q->front = Q->rear = (QueuePtr)malloc(sizeof(QNode)); //注意要sizeof(QNode)
	//
	if (!Q->front)
	{
		exit(OVERFLOW);
	}

	Q->front->next = NULL;

	return OK;
}


//销毁队列空间
Status DestoryQueue(LinkQueue* Q)
{
	while (Q->front)
	{
		Q->rear = Q->front->next;  //从队头开始销毁队列空间
		free(Q->front);
		Q->front = Q->rear;
	}

	return OK;
}

//判空
Status QueueEmpty(LinkQueue Q)
{
	if (Q.front == Q.rear)
	{
		return TRUE;
	}
	else
	{
		return FALSE;
	}
}

//求队长
int QueueLength(LinkQueue Q)
{
	QueuePtr p = Q.front;
	int i = 0;
	while (p != Q.rear)
	{
		p = p->next;
		i++;
	}

	return i;
}

//遍历输出
Status QueueTraverse(LinkQueue Q)
{
	QueuePtr p = Q.front->next;

	while (p)
	{
		printf("%d ", p->data);
		p = p->next;
	}
	printf("\n");
	return OK;
}

//入队
Status EnterQueue(LinkQueue* Q, ElemType e)
{
	QueuePtr s = (QueuePtr)malloc(sizeof(QNode));
	if (!s)
	{
		exit(OVERFLOW);
	}
	s->data = e;
	s->next = NULL;

	Q->rear->next = s;
	Q->rear = s;

	return OK;
}

//读取队头元素
/* 若队列不空,则用e返回Q的队头元素,并返回OK,否则返回ERROR */
Status GetHead(LinkQueue Q, ElemType* e)
{
	//队空报错
	if (Q.front == Q.rear)
	{
		return ERROR;
	}

	QueuePtr p;
	p = Q.front->next;
	*e = p->data;

	return OK;
}

//出队
Status DeleteQueue(LinkQueue* Q, ElemType* e)
{
	if (Q->front == Q->rear)  //队空报错
	{
		return ERROR;
	}

	QueuePtr p;
	p = Q->front->next;
	*e = p->data;
	Q->front->next = p->next;
	if (p == Q->rear)
	{
		Q->rear = Q->front; //若要出队的元素为最后一个元素，则队列恢复到初始化的状态
	}
	free(p);

	return OK;

}

//清空
Status QueueClear(LinkQueue* Q)
{
	QueuePtr p, q;
	p = Q->front->next;
	while (p)
	{
		q = p;
		p = p->next;
		free(q);
	}
	Q->rear = Q->front;
	Q->front->next = NULL;

	return OK;
}

void test01()
{
	//初始化链队
	LinkQueue Q;
	QueueInit(&Q);
	//判空
	Status i_empty = QueueEmpty(Q);
	printf("队列是否为空（1为是/0为否）：%d\n", i_empty);  //队列是否为空（1为是/0为否）：1
	//求队列长度
	int i_length = QueueLength(Q);
	printf("队列的长度为：%d\n", i_length);  //队列的长度为：0

	printf("-----------------------------------------\n");

	//入队
	for (int i = 0; i < 10; i++)
	{
		EnterQueue(&Q, i);
	}
	//判空
	i_empty = QueueEmpty(Q);
	printf("队列是否为空（1为是/0为否）：%d\n", i_empty);  //队列是否为空（1为是/0为否）：0
	//求队列长度
	i_length = QueueLength(Q);
	printf("队列的长度为：%d\n", i_length);  //	队列的长度为：10
	//遍历输出
	QueueTraverse(Q);  //0 1 2 3 4 5 6 7 8 9

	printf("-------------------------------------------------\n");

	//获取队头元素
	ElemType e1 = -1;
	GetHead(Q, &e1);
	printf("链队中的队头元素为：%d\n", e1);  //链队中的队头元素为：0

	printf("-------------------------------------------------\n");

	//出队
	ElemType e2;
	DeleteQueue(&Q, &e2);
	printf("链队中出队的元素为：%d\n", e2);  //链队中出队的元素为：0
	//判空
	i_empty = QueueEmpty(Q);
	printf("队列是否为空（1为是/0为否）：%d\n", i_empty);  //队列是否为空（1为是/0为否）：0
	//求队列长度
	i_length = QueueLength(Q);
	printf("队列的长度为：%d\n", i_length);  //	队列的长度为：9
	//遍历输出
	QueueTraverse(Q);  //1 2 3 4 5 6 7 8 9

	printf("-------------------------------------------------\n");

	//清空
	QueueClear(&Q);
	//判空
	i_empty = QueueEmpty(Q);
	printf("队列是否为空（1为是/0为否）：%d\n", i_empty);  //队列是否为空（1为是/0为否）：1
	//求队列长度
	i_length = QueueLength(Q);
	printf("队列的长度为：%d\n", i_length);  //	队列的长度为：0
	//遍历输出
	QueueTraverse(Q);  //

	printf("-------------------------------------------------\n");

	DestoryQueue(&Q);
	//判空
	i_empty = QueueEmpty(Q);
	printf("队列是否为空（1为是/0为否）：%d\n", i_empty);  //队列是否为空（1为是/0为否）：1
	//求队列长度
	i_length = QueueLength(Q);
	printf("队列的长度为：%d\n", i_length);  //	队列的长度为：0

}

int main()
{
	test01();

	return 0;
}

END

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值