Nine Day 队列-链式和循环式

已于 2022-05-16 10:59:41 修改
阅读量291 收藏
点赞数 4
文章标签： 链表 数据结构
于 2022-05-16 09:52:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_60459642/article/details/124780292
版权
本文介绍了链表和数组两种方式实现队列的数据结构，包括队列的基本概念、链式队列的创建、入队、出队操作，以及循环数组队列的满队和空队条件。通过代码详细展示了如何用C语言实现这两种队列，并给出了测试用例。队列在餐厅就餐和排队取餐等场景中有不同的适用性。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

队列定义：

队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。

链式：

用链表定义队列，头节点进入，末节点出队，实现先进先出。

图样：

fd6b7992cf884584a5ee20065d6b0d33.png

代码实现：

1）定义队列

这样俩个struct 有利于封装队列。

typedef struct LinkNode {
	int data;
	struct LinkNode* next;
}*LinkNodePtr; 

typedef struct LinkQueue{
	LinkNodePtr front;
	LinkNodePtr rear;
}*LinkQueuePtr;

2）初始化队列

LinkQueuePtr initQueue(){
	LinkQueuePtr resultPtr = (LinkQueuePtr)malloc(sizeof(LinkQueue));
	//The header, the data is not uesful.
	LinkNodePtr headerPtr = (LinkNodePtr)malloc(sizeof(LinkNode));
	headerPtr->next = NULL;
	
	resultPtr->front = headerPtr;
	resultPtr->rear = headerPtr;
	
	return resultPtr;
}

3）入队

void enqueue(LinkQueuePtr paraQueuePtr, int paraElement) {
	//Step 1.Creat a new node
	LinkNodePtr tempNodePtr = (LinkNodePtr)malloc(sizeof(LinkNode));
	tempNodePtr->data = paraElement;
	tempNodePtr->next = NULL;
	
	//Step 2.Link to the existing rear
	paraQueuePtr->rear->next = tempNodePtr;
	
	//Step 3.It is the new rear.
	paraQueuePtr->rear = tempNodePtr;
	 
}

4）出队

int dequeue(LinkQueuePtr paraQueuePtr) {
	
	int resultValue;
	LinkNodePtr tempNodePtr;
	
	//Step 1.Is the queue empty?
	if (paraQueuePtr->front == paraQueuePtr->rear) {
		printf("The queue is empty.\n");
		return -1;
	}
	
	//Step 2.Change the queue.
	tempNodePtr = paraQueuePtr->front->next;
	resultValue = tempNodePtr->data;
	paraQueuePtr->front->next = tempNodePtr->next;
	if (paraQueuePtr->rear == tempNodePtr) {
		paraQueuePtr->rear = paraQueuePtr->front;
	}
	//Step 3.Free space.
	free(tempNodePtr);
	tempNodePtr = NULL;

	//Step 4.Return.
	return resultValue;
	 
}//Of enqueue

5）测试代码

void testLinkQueue() {
	LinkQueuePtr tempQueuePtr;
	tempQueuePtr = initQueue();
	enqueue(tempQueuePtr, 10);
	enqueue(tempQueuePtr, 30);
	enqueue(tempQueuePtr, 50);
	
	outputLinkQueue(tempQueuePtr);
	
	printf("dequeue gets %d\n", dequeue(tempQueuePtr));
	printf("dequeue gets %d\n", dequeue(tempQueuePtr));
	printf("dequeue gets %d\n", dequeue(tempQueuePtr));
	printf("dequeue gets %d\n", dequeue(tempQueuePtr));
	
	outputLinkQueue(tempQueuePtr);
	
}//Of test.

6）总代码

#include <stdio.h>
#include <malloc.h>
/**
 * 链队列的节点。
 */

typedef struct LinkNode {
	int data;
	struct LinkNode* next;
}*LinkNodePtr; 

/**
 * 链对列。
 */

typedef struct LinkQueue{
	LinkNodePtr front;
	LinkNodePtr rear;
}*LinkQueuePtr;

/**
 * Construct an empty queue
 */
 
LinkQueuePtr initQueue(){
	LinkQueuePtr resultPtr = (LinkQueuePtr)malloc(sizeof(LinkQueue));
	//The header, the data is not uesful.
	LinkNodePtr headerPtr = (LinkNodePtr)malloc(sizeof(LinkNode));
	headerPtr->next = NULL;
	
	resultPtr->front = headerPtr;
	resultPtr->rear = headerPtr;
	
	return resultPtr;
}//Of initQueue

/**
 * OutPut The queue.
 */
 
void outputLinkQueue(LinkQueuePtr paraQueuePtr){
	LinkNodePtr tempPtr = paraQueuePtr->front->next;
	if (tempPtr == NULL) {
		printf("The link queue is empty\r\n");
		return;
	}
	while (tempPtr != NULL) {
		printf("%d ", tempPtr->data);
		tempPtr = tempPtr->next;
	}//Of while
	printf("\r\n");
}//Of outputLinkQueue.

/**
 * Enqueue.
 */

void enqueue(LinkQueuePtr paraQueuePtr, int paraElement) {
	//Step 1.Creat a new node
	LinkNodePtr tempNodePtr = (LinkNodePtr)malloc(sizeof(LinkNode));
	tempNodePtr->data = paraElement;
	tempNodePtr->next = NULL;
	
	//Step 2.Link to the existing rear
	paraQueuePtr->rear->next = tempNodePtr;
	
	//Step 3.It is the new rear.
	paraQueuePtr->rear = tempNodePtr;
	 
}//Of enqueue.

/**
 * Dequeue.
 * @returnThe value of header
 */
 
int dequeue(LinkQueuePtr paraQueuePtr) {
	
	int resultValue;
	LinkNodePtr tempNodePtr;
	
	//Step 1.Is the queue empty?
	if (paraQueuePtr->front == paraQueuePtr->rear) {
		printf("The queue is empty.\n");
		return -1;
	}
	
	//Step 2.Change the queue.
	tempNodePtr = paraQueuePtr->front->next;
	resultValue = tempNodePtr->data;
	paraQueuePtr->front->next = tempNodePtr->next;
	if (paraQueuePtr->rear == tempNodePtr) {
		paraQueuePtr->rear = paraQueuePtr->front;
	}
	//Step 3.Free space.
	free(tempNodePtr);
	tempNodePtr = NULL;

	//Step 4.Return.
	return resultValue;
	 
}//Of enqueue

/**
 * test
 */
 
void testLinkQueue() {
	LinkQueuePtr tempQueuePtr;
	tempQueuePtr = initQueue();
	enqueue(tempQueuePtr, 10);
	enqueue(tempQueuePtr, 30);
	enqueue(tempQueuePtr, 50);
	
	outputLinkQueue(tempQueuePtr);
	
	printf("dequeue gets %d\n", dequeue(tempQueuePtr));
	printf("dequeue gets %d\n", dequeue(tempQueuePtr));
	printf("dequeue gets %d\n", dequeue(tempQueuePtr));
	printf("dequeue gets %d\n", dequeue(tempQueuePtr));
	
	outputLinkQueue(tempQueuePtr);
	
}//Of test.
int main(void){
	testLinkQueue();
	return 0; 
}

循环式：

用数组实现队列，用除余（%）实现循环，也是先进先出。

图样：

这里附上满队和空对的图，说明满队所存放的不是数组的长度，为了区分满队和空对的判断。

及满队：(rear+1)%max = head

空对： rear%max = head

82953aa22f134d00922b158712d88f34.png

代码实现：

1）定义队列

typedef struct CircleIntQueue {
	int data[TOTAL_SPACE];
	int head;
	int tail;
}*CircleIntQueuePtr;

2）初始化队列

CircleIntQueuePtr initQueue() {
	CircleIntQueuePtr resultPtr = (CircleIntQueuePtr)malloc(sizeof(CircleIntQueue));
	resultPtr->head = 0;
	resultPtr->tail = 0;
	return resultPtr;
}

3）入队

void enqueue(CircleIntQueuePtr paraPtr, int paraValue) {
	//Step 1.Is full
	if ((paraPtr->tail + 1) % TOTAL_SPACE == paraPtr->head) {
		printf("Queue is full.\n");
		return;
	}
	//Step 2.add
	paraPtr->data[paraPtr->tail % TOTAL_SPACE] = paraValue;
	paraPtr->tail ++;
}

4）出队

int dequeue(CircleIntQueuePtr paraPtr) {
	int resultValue;
	//Step 1.is empty
	if (paraPtr->head == paraPtr->tail) {
		printf("No element in the queue.\n");
		return -1;
	}//Of if
	
	//Step 2.get and change
	resultValue = paraPtr->data[paraPtr->head % TOTAL_SPACE];
	paraPtr->head++;
	
	return resultValue;
}

5）测试代码

void testLinkQueue() {
	int i = 10;
	CircleIntQueuePtr tempPtr = initQueue();
	for (;i < 16; i++) {
		enqueue(tempPtr, i);
	}//Of i
	
	outputLinkQueue(tempPtr);
	
	for (i = 0; i < 6; i++) {
		printf("dequeue gets %d\n", dequeue(tempPtr));
	}//Of i
	
	enqueue(tempPtr, 8);
	outputLinkQueue(tempPtr);
}

6）总代码

#include <stdio.h>
#include <malloc.h>

#define TOTAL_SPACE 5

/**
 * Circle int queue.
 */
 
typedef struct CircleIntQueue {
	int data[TOTAL_SPACE];
	int head;
	int tail;
}*CircleIntQueuePtr;

/**
 * Initialize the queue.
 */
CircleIntQueuePtr initQueue() {
	CircleIntQueuePtr resultPtr = (CircleIntQueuePtr)malloc(sizeof(CircleIntQueue));
	resultPtr->head = 0;
	resultPtr->tail = 0;
	return resultPtr;
}//Of CircleIntQueuePtr.

/**
 * Enqueue.
 * 
 * @param paraValue The value of the new node.
 */
 
void enqueue(CircleIntQueuePtr paraPtr, int paraValue) {
	//Step 1.Is full
	if ((paraPtr->tail + 1) % TOTAL_SPACE == paraPtr->head) {
		printf("Queue is full.\n");
		return;
	}
	//Step 2.add
	paraPtr->data[paraPtr->tail % TOTAL_SPACE] = paraValue;
	paraPtr->tail ++;
}//Of enqueue

/**
 * Dequeue
 * @return The value at the head.
 */
int dequeue(CircleIntQueuePtr paraPtr) {
	int resultValue;
	//Step 1.is empty
	if (paraPtr->head == paraPtr->tail) {
		printf("No element in the queue.\n");
		return -1;
	}//Of if
	
	//Step 2.get and change
	resultValue = paraPtr->data[paraPtr->head % TOTAL_SPACE];
	paraPtr->head++;
	
	return resultValue;
}//Of dequeue.


/**
 * Output the queue.
 */
void outputLinkQueue(CircleIntQueuePtr paraPtr) {
	int i;
	if (paraPtr->head == paraPtr->tail) {
		printf("Empty queue.\n");
		return;
	}//Of if
	
	printf("Element in the queue: ");
	for (i = paraPtr->head; i < paraPtr->tail; i++) {
		printf("%d ", paraPtr->data[i % TOTAL_SPACE]);
	}//Of for i
	
	printf("\r\n");
	
}//Of output.

/**
 * test.
 */
void testLinkQueue() {
	int i = 10;
	CircleIntQueuePtr tempPtr = initQueue();
	for (;i < 16; i++) {
		enqueue(tempPtr, i);
	}//Of i
	
	outputLinkQueue(tempPtr);
	
	for (i = 0; i < 6; i++) {
		printf("dequeue gets %d\n", dequeue(tempPtr));
	}//Of i
	
	enqueue(tempPtr, 8);
	outputLinkQueue(tempPtr);
}//Of test

int main(void) {
	testLinkQueue();
	return 0;
}

总结：

我们可以看到循环链表大小固定，而链表式是可以一直增加的。

他们用于不同场景，列入餐厅就餐我们就用循环式，位置是有限的。

而在排队取餐时用的链表式。

回答老师的问题：

1）数组变量的空间分配是连续的

2）局部变量在该局部（该函数）中可以重复使用，一旦出了该函数，该变量被销毁，便不能再使用。

3）指针的地址，我理解为存储该指针的存储空间的名字（编号）;而指针的值，是指针所指向的变量的存储空间的名字（编号）。‘*’是取指针所指的空间所存储的值。

评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值