第三章代码题（二）-CSDN博客

本文链接：https://blog.csdn.net/ylxb2234/article/details/131882328

文章详细介绍了如何使用循环链表实现队列的入队、出队、置空和判空操作，包括两种不同的循环队列实现方式，一种仅用队尾指针，另一种通过队尾指针和元素个数，以及一种通过额外的标志位来判断队空和队满。还包含了代码示例和初始化过程。

摘要由CSDN通过智能技术生成

前篇：

第一章代码题_永无魇足的博客-CSDN博客

第二章代码题（一）_永无魇足的博客-CSDN博客

第二章代码题（二）_永无魇足的博客-CSDN博客

第二章代码题（三）_永无魇足的博客-CSDN博客

第三章代码题（一）_永无魇足的博客-CSDN博客

6.用循环链表表示队列，并且只有队尾指针。

答案：

注意指针一直指向队尾，入队是在队尾插入，注意循环链表插入结点的过程。

入队：

//入队
int EnQueue(Qrear &p,ElemType val) {

	//创建一个新结点，用来进行入队
	LNode* L = (LNode *)malloc(sizeof(LNode));
	if (!L)
	{
		printf("内存分配失败!\n");
		return 0;
	}

	L->data = val;

	//将新生成的结点插入到表尾后面，注意表尾后面是表头。
	L->next = p.rear->next;
	p.rear->next = L;

	//表尾指针更新
	p.rear = L;
	return 1;
}

出队是在队头出，注意头结点。空队的条件是队尾的next仍然指向队尾。

出队：

//出队
int  DeQueue(Qrear& p) {
	//队尾指针和它的下一个指向结点相等
	if (p.rear == p.rear->next)
	{
		printf("队列为空!\n");
		return 0;
	}
	LNode* q;
	//因为带有头结点，队尾的next的next才是第一个数据结点
	q = p.rear->next->next;
//更新出队部分的链表的连接
	p.rear->next->next = p.rear->next->next->next;
//num拿到出队的元素
	ElemType num = q->data;
	free(q);
	return num;
}

置空，我直接把队尾移向头结点,然后把指针指向头结点本身。

置空队：

//置空队
int  Empty(Qrear& p) {
	if (p.rear == p.rear->next)
	{
		printf("队列为空!\n");
		return 0;
	}
	else
	{
       //让尾部指针移动到链表头结点
		p.rear = p.rear->next;

		//还原初始状态
		p.rear->next = p.rear;
		return 1;
	}

   }

判空队：

//判空队
int  isEmpty(Qrear *p) {
	return  p->rear->next==p->rear;
}

第7题和第8题实际是循环链表顺序实现的另外两种方式。因为设置队尾和队头指针不可避免地需要浪费掉一个空间，而7,8题可以避免这种浪费

7.循环队列，只有队尾指针rear和队中元素的个数quelen

判断队空和队满的条件发生了变化。队空应该是quelen==0, 队满应该是quelen==MAXSIZE。

入队：

//入队
int EnQueue(SeQueue &s,ElemType val) {
	if (s.quelen==MAXSIZE)
	{
		printf("队列已满，无法入队");
		return 0;
	}

	//将val赋给对应位置
	s.elem[s.rear] = val;
	//指针进行移动
	s.rear = (s.rear + 1) % MAXSIZE;
	//长度加1
	s.quelen ++;
	return 1;
}

出队：

//出队
int DeQueue(SeQueue &s,ElemType *num) {
	//队列为空
	if (s.quelen==0)
	{
		printf("队列为空,无法出队");
		return 0;
	}

	//没有队头指针，但是在出队时因为是从队头出，每次出一个，元素个数就会减1，队头实际位置就会加1，(s.rear - s.quelen + MAXSIZE) % MAXSIZE能准确的表示队头的位置
//获得当前队头元素的位置
	*num = s.elem[(s.rear - s.quelen + MAXSIZE) % MAXSIZE];
//队列实际元素长度减1
	s.quelen--;
	return 1;
}

需要注意的是，有些入队代码以及出队代码中有些顺序和我写的不一样，我发现是初始化设置不同引起的。以下是我的初始化程序，有些人可能把队尾指针初始定义为-1：

//初始化循环队列
void InitCycleQueue(SeQueue *s) {
	//初始队尾指针指向位置0，长度为0
	s->quelen = 0;
	s->rear = 0;
}

不过因为考试的时候只需要写入队和出队，我认为这些方面并不会影响代码的正确性。

验证：

#include<stdio.h>;
#define MAXSIZE 5

typedef int ElemType;

typedef struct {
	ElemType elem[MAXSIZE];
	int rear, quelen;
}SeQueue;

//初始化循环队列
void InitCycleQueue(SeQueue *s) {
	//初始队尾指针指向位置0，长度为0
	s->quelen = 0;
	s->rear = 0;
}

//入队
int EnQueue(SeQueue &s,ElemType val) {
	if (s.quelen==MAXSIZE)
	{
		printf("队列已满，无法入队");
		return 0;
	}

	//将val赋给对应位置
	s.elem[s.rear] = val;
	//指针进行移动
	s.rear = (s.rear + 1) % MAXSIZE;
	//长度加1
	s.quelen ++;
	return 1;
}

//出队
int DeQueue(SeQueue &s,ElemType *num) {
	//队列为空
	if (s.quelen==0)
	{
		printf("队列为空,无法出队");
		return 0;
	}

	//没有队头指针
	*num = s.elem[(s.rear - s.quelen + MAXSIZE) % MAXSIZE];
	s.quelen--;
	return 1;
}

//显示
void  showSeQueue(SeQueue *s,int length) {
	if (s->quelen==0)
	{
		printf("队列为空，无输出");
		return ;
	}
	//要从队头开始进行遍历输出
	for (int i = (s->rear - s->quelen + MAXSIZE) % MAXSIZE; i < length; i++)
	{
		printf("%d", s->elem[i]);
	}
	printf("\n");
}
int main() {
	SeQueue s;
	InitCycleQueue(&s);
	int val;
	for (int i = 0; i < MAXSIZE; i++)
	{
		//请求用户输入新节点的值
		printf("请输入第%d个节点的值", i + 1);
		scanf_s("%d", &val);
		EnQueue(s, val);
	}
	showSeQueue(&s, MAXSIZE);
	ElemType num=0;
	DeQueue(s, &num);
	showSeQueue(&s, MAXSIZE);
}

执行结果：

8.循环队列，在队头(front)队尾(rear)的指针的基础上增加一个标志域tag。

判断队空和队满的条件发生了变化。队空应该是tag==0&&front==rear, 队满应该是tag==1&&front==rear。

初始化：

//初始化循环队列
void InitCycleQueue(SeQueue* s) {
	//初始队尾指针和队头指针指向位置相等，tag为0
	s->tag = 0;
	s->rear = s->front=0;
}

入队：

//入队
int EnQueue(SeQueue& s, ElemType val) {
	if (s.tag==1 && s.front==s.rear)
	{
		printf("队列已满，无法入队\n");
		return 0;
	}

	//将val赋给对应位置
	s.elem[s.rear] = val;
	//指针进行移动
	s.rear = (s.rear + 1) % MAXSIZE;
//tag为1表示队满，这只会在入队时出现，所以直接入队让它等于1，由于判断队满还有rear==front，所以不影响判定
	s.tag = 1;
	return 1;
}

出队：

//出队
int DeQueue(SeQueue& s, ElemType* num) {
	//队列为空
	if (s.tag == 0 && s.front == s.rear)
	{
		printf("队列为空,无法出队\n");
		return 0;
	}
	//将队头给num
	*num = s.elem[s.front];
	//队头指针进行移动
	s.front = (s.front + 1) % MAXSIZE;
//队空只会出现在出队时
	s.tag = 0;
	return 1;
}

验证：

#include<stdio.h>;
#define MAXSIZE 5

typedef int ElemType;

typedef struct {
	ElemType elem[MAXSIZE];
	int rear, front, tag;
}SeQueue;

//初始化循环队列
void InitCycleQueue(SeQueue* s) {
	//初始队尾指针和队头指针指向位置相等，tag为0
	s->tag = 0;
	s->rear = s->front=0;
}

//入队
int EnQueue(SeQueue& s, ElemType val) {
	if (s.tag==1 && s.front==s.rear)
	{
		printf("队列已满，无法入队\n");
		return 0;
	}

	//将val赋给对应位置
	s.elem[s.rear] = val;
	//指针进行移动
	s.rear = (s.rear + 1) % MAXSIZE;
	s.tag = 1;
	return 1;
}

//出队
int DeQueue(SeQueue& s, ElemType* num) {
	//队列为空
	if (s.tag == 0 && s.front == s.rear)
	{
		printf("队列为空,无法出队\n");
		return 0;
	}
	//将队头给num
	*num = s.elem[s.front];
	//队头指针进行移动
	s.front = (s.front + 1) % MAXSIZE;
	s.tag = 0;
	return 1;
}

//显示
void  showSeQueue(SeQueue* s, int length) {
	if (s->tag == 0 && s->front == s->rear)
	{
		printf("队列为空，无输出\n");
		return;
	}
	//要从队头开始进行遍历输出
	for (int i =s->front; i < length; i++)
	{
		printf("%d", s->elem[i]);
	}
	printf("\n");
}
int main() {
	SeQueue s;
	InitCycleQueue(&s);
	int val;
	for (int i = 0; i < MAXSIZE; i++)
	{
		//请求用户输入新节点的值
		printf("请输入第%d个节点的值", i + 1);
		scanf_s("%d", &val);
		EnQueue(s, val);
	}
	showSeQueue(&s, MAXSIZE);
	ElemType num = 0;
	DeQueue(s, &num);
	showSeQueue(&s, MAXSIZE);
}

执行结果：