队列的数据结构

功德箱我每年都投

已于 2023-03-31 20:28:18 修改

阅读量353

点赞数 2

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

于 2023-03-28 20:55:48 首次发布

本文链接：https://blog.csdn.net/qq947467490/article/details/129816877

版权

数据结构专栏收录该内容

6 篇文章 1 订阅

订阅专栏

文章介绍了队列的基本概念，包括它的先进先出(FIFO)特性，以及如何通过数组和链表来实现队列。队列的常见操作如初始化、判断队列是否为空、销毁队列、入队、出队、获取队头和队尾元素等被详细阐述。此外，文章还讨论了循环队列的重要性，特别是在解决生产者消费者模型中的应用，以及在实现时需要注意的边界条件和额外空间需求。

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

一、队列的概念及结构

1.队列的概念

队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出的性质。 FIFO(First In First Out)

入队列：进行插入操作的一端称为队尾

出队列：进行删除操作的一端称为队头。

2.队列的结构

二、队列的实现

队列也可以数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头上出数据，效率会比较低。

实现功能

QueueInit 队列初始化
QueueEmpty 判断队列是否为空
QueueDestroy 队列销毁
QueuePush 入队
QueuePop 出队
QueueFront 返回队列的队头元素

QueueBack 返回队列的队尾元素
QueueSize 返回队列的大小

Queue.h

#pragma once
#define _CRT_NO_SECURE_WARNINGS

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

typedef int DataType;
typedef struct QueueNode
{
	struct QueueNode* next;
	DataType val;
}QueueNode;

typedef struct Queue
{
	struct QueueNode* head;
	struct QueueNode* tail;
}Queue;


extern void QueueInit(Queue* p);
extern void QueueDestroy(Queue* p);
extern void QueuePush(Queue* p, DataType x);
extern bool QueueEmpty(Queue* p);
extern int QueueSize(Queue* p);
extern void QueuePop(Queue* p);
extern DataType QueueFront(Queue* p);
extern DataType QueueBack(Queue* p);

Queue.c

#include"queue.h"


void QueueInit(Queue* p)
{
	assert(p);
	p->head = NULL;
	p->tail = NULL;
}


void QueueDestroy(Queue* p)
{
	assert(p);
	QueueNode* cur = p->head;
	while (cur)
	{
		QueueNode* next = cur->next;
		free(cur);
		cur = next;
	}
	p->head = p->tail = NULL;
}


void QueuePush(Queue* p, DataType x)
{
	assert(p);
	QueueNode* new_node = (QueueNode*)malloc(sizeof(QueueNode));
	if (!new_node)
	{
		perror("malloc");
		exit(-1);
	}
	new_node->val = x;
	new_node->next = NULL;
	if (QueueEmpty(p))
		p->head = p->tail = new_node;
	else
	{
		p->tail->next = new_node;
		p->tail = p->tail->next;
	}
}


bool QueueEmpty(Queue* p)
{
	assert(p);
	return (p->head == NULL) ? true : false;
}


int QueueSize(Queue* p)
{
	if (QueueEmpty(p)) return 0;
	int count = 1;
	QueueNode* tail = p->head;
	while (tail != p->tail)
	{
		tail = tail->next;
		count++;
	}
	return count;
}


void QueuePop(Queue* p)
{
	assert(p);
	if (QueueEmpty(p))
	{
		printf("The queue is empty!\n");
		return;
	}
	if (QueueSize(p) == 1)
	{
		free(p->head);
		p->head = p->tail = NULL;
	}
	else
	{
		QueueNode* next = p->head->next;
		free(p->head);
		p->head = next;
	}
}


DataType QueueFront(Queue* p)
{
	assert(p);
	if (QueueEmpty(p))
	{
		printf("The queue is empty!\n");
		return 0;
	}
	return p->head->val;
}


DataType QueueBack(Queue* p)
{
	assert(p);
	if (QueueEmpty(p))
	{
		printf("The queue is empty!\n");
		return 0;
	}
	return p->tail->val;
}

test.c

#include"queue.h"

void test1()
{
	Queue q;
	QueueInit(&q);

	QueuePush(&q, 1);
	QueuePush(&q, 2);
	QueuePush(&q, 3);
	QueuePush(&q, 4);

	QueuePop(&q);
	QueuePop(&q);
	QueuePop(&q);
	QueuePop(&q);
	QueuePop(&q);


	QueueDestroy(&q);
}

void test2()
{
	Queue q;
	QueueInit(&q);

	QueuePush(&q, 1);
	QueuePush(&q, 2);
	QueuePush(&q, 3);
	QueuePush(&q, 4);

	int val;

	val = QueueFront(&q);
	printf("%d\n", val);
	val = QueueBack(&q);
	printf("%d\n", val);

	QueuePop(&q);
	QueuePop(&q);
	QueuePop(&q);
	QueuePop(&q);

	val = QueueFront(&q);
	printf("%d\n", val);
	val = QueueBack(&q);
	printf("%d\n", val);

}


int main()
{
	test1();
	printf("------------------------------------------------\n");
	test2();

	return 0;
}