数据结构_队列

最新推荐文章于 2024-04-14 16:58:11 发布
最新推荐文章于 2024-04-14 16:58:11 发布
阅读量728 收藏
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构 链表 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43853178/article/details/126286494
版权

队列类似于日常生活中的排队，它也是一种特殊的线性表。队列和栈有相反的逻辑，但是却属于同类结构。

文章目录

队列的介绍

定义: 队列是一种特殊的线性表，它只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out) 的原则。

入队列：从队列的队尾插入数据的操作
出队列：从队列的队头删除数据的操作

队列的遵循的原则如下图所示
在这里插入图片描述
与排队做核酸一样，先排队的人先做，做完离开，后来的人从站在队尾，直到做完核酸离开。

队列的结构

队列是在两端进行操作的，如果采用顺序表的结构的话，出队列时需要将队列中其它元素都向前移动一位，比较麻烦，因此一般情况下队列用链表来实现比较好。下图是队列的抽象结构
在这里插入图片描述

队列的结构体的定义

typedef int QDataType;

// 链式结构的队列 

// 队列中的结点
typedef struct QListNode
{
	struct QListNode* next;
	QDataType data;
}QNode;

// 队列的结构 
typedef struct Queue
{
	QNode* front;
	QNode* rear;
}Queue;

队列由一个个结点构成，所以需要定义队列中结点的结构体，队列的结构体中定义头结点和尾结点，因为队列只会队头结点和尾结点操作。

队列的实现

（1）队列初始化

void QueueInit(Queue* q)
{
	assert(q);

	q->front = NULL;
	q->rear = NULL;
}

队列是需要初始化的，初始时，头结点和尾结点指针都指向NULL。

（2）判断队列是否为空。为空返回1，非空返回0。

int QueueEmpty(Queue* q)
{
	assert(q);

	return q->front == NULL;
}

因为后面的多个操作需要判断队列是否为空，所以先实现这个函数。

（3）入队列

void QueuePush(Queue* q, QDataType data)
{
	assert(q);
	// 创建结点
	QNode* newnode = (QNode*)malloc(sizeof(QNode));

	if (newnode == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	// 为结点赋值
	newnode->data = data;
	newnode->next = NULL;
	// 判断队列是否为空
	if (QueueEmpty(q))
	{
		// 队列为空，插入队列的结点既是头结点也是尾结点
		q->front = q->rear = newnode;
	}
	else 
	{
		// 队列非空，让尾结点指向要插入的结点，然后插入的结点为新的尾结点
		q->rear->next = newnode;
		q->rear = newnode;
	}
}

入队列的步骤：

  1. 先创建一个没有指向的结点，给结点赋值；
  2. 判断队列是否为空
    空：插入队列的结点既是头结点也是尾结点
    非空：让尾结点指向要插入的结点，然后插入的结点为新的尾结点

（4）出队列

void QueuePop(Queue* q)
{
	assert(q);
	assert(!QueueEmpty(q));

	// 如果只剩一个结点的情况
	if (q->front->next == NULL)
	{
		free(q->front);
		q->front = q->rear = NULL;
	}
	else
	{
		QNode* next = q->front->next;
		free(q->front);
		q->front = next;
	}
}

出队列时需要判断队列中是否只有一个结点。队列中只有一个结点时，出队列后要让队头指针和队尾指针都指向NULL。

（5）队头数据

QDataType QueueFront(Queue* q)
{
	assert(q);
	assert(!QueueEmpty(q));

	return q->front->data;
}

（6）队尾数据

QDataType QueueBack(Queue* q)
{
	assert(q);
	assert(!QueueEmpty(q));

	return q->rear->data;
}

（7）队列中元素个数

int QueueSize(Queue* q)
{
	assert(q);

	int count = 0;

	QNode* cur = q->front;

	while (cur)
	{
		count++;
		cur = cur->next;
	}

	return count;
}

（8）销毁队列

void QueueDestroy(Queue* q)
{
	assert(q);

	QNode* cur = q->front;

	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
	q->front = q->rear = NULL;
}

完整代码及测试程序

一共三个文件

  1. Queue.h
  2. Queue.c
  3. Test_Queue.c
#pragma once
#include<stdio.h>
#include<assert.h>
#include<malloc.h>
#include<assert.h>

typedef int QDataType;

// 链式结构：表示队列 
// 队列中的结点
typedef struct QListNode
{
	struct QListNode* next;
	QDataType data;
}QNode;

// 队列的结构 
typedef struct Queue
{
	QNode* front;
	QNode* rear;
}Queue;

// 初始化队列 
void QueueInit(Queue* q);

// 队尾入队列 
void QueuePush(Queue* q, QDataType data);

// 队头出队列 
void QueuePop(Queue* q);

// 获取队列头部元素 
QDataType QueueFront(Queue* q);

// 获取队列队尾元素 
QDataType QueueBack(Queue* q);

// 获取队列中有效元素个数 
int QueueSize(Queue* q);

// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
int QueueEmpty(Queue* q);

// 销毁队列 
void QueueDestroy(Queue* q);

#include"Queue.h"


void QueueInit(Queue* q)
{
	assert(q);

	q->front = NULL;
	q->rear = NULL;
}

void QueuePush(Queue* q, QDataType data)
{
	assert(q);

	QNode* newnode = (QNode*)malloc(sizeof(QNode));

	if (newnode == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}

	newnode->data = data;
	newnode->next = NULL;

	if (QueueEmpty(q))
	{
		q->front = q->rear = newnode;
	}
	else 
	{
		q->rear->next = newnode;
		q->rear = newnode;
	}

}

void QueuePop(Queue* q)
{
	assert(q);
	assert(!QueueEmpty(q));

	// 如果只剩一个结点的情况
	if (q->front->next == NULL)
	{
		free(q->front);
		q->front = q->rear = NULL;
	}
	else
	{
		QNode* next = q->front->next;
		free(q->front);
		q->front = next;
	}

}

QDataType QueueFront(Queue* q)
{
	assert(q);
	assert(!QueueEmpty(q));

	return q->front->data;
}

QDataType QueueBack(Queue* q)
{
	assert(q);
	assert(!QueueEmpty(q));

	return q->rear->data;
}

int QueueSize(Queue* q)
{
	assert(q);

	int count = 0;

	QNode* cur = q->front;

	while (cur)
	{
		count++;
		cur = cur->next;
	}

	return count;
}

// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
int QueueEmpty(Queue* q)
{
	assert(q);

	return q->front == NULL;
}

// 销毁队列 
void QueueDestroy(Queue* q)
{
	assert(q);

	QNode* cur = q->front;

	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
	q->front = q->rear = NULL;
}

#include"Queue.h"


Test()
{
	Queue q;
	QueueInit(&q);

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

	printf("队头：%d ", QueueFront(&q));
	printf("队尾：%d\n", QueueBack(&q));
	printf("出队列：\n");
	QueuePop(&q);
	printf("队头：%d", QueueFront(&q));
	printf("队尾：%d\n", QueueBack(&q));
	printf("队列大小：%d\n", QueueSize(&q));
	printf("全部出队列：");

	while (!QueueEmpty(&q))
	{
		printf("%d ", QueueFront(&q));
		QueuePop(&q);
	}

	QueueDestroy(&q);

}

int main()
{
	Test();

	return 0;
}

循环队列

循环队列的介绍

循环队列可以使用数组来实现的，它里面能够存储的最大元素个数是固定的，它可以在数组前面的元素出队列后，把前面的位置当成尾来插入数据，因此可以实现对数组的这内存的循环使用，也就是说可以重复利用之前用过的空间。但是操作逻辑还是跟队列一致，先进先出、后进后出，因此称为循环队列。
要实现循环队列，那肯定在队尾下标超出数组下标后，要让队尾下标回到0位置，再插入，但是这个时候会遇到队空队满无法判断的问题，如下图所示，在队满和队空时会遇到同样的情况tail==front
在这里插入图片描述

为了解决上述问题，可以采取空一个位置的方式设计队列。接下来结合下面这个图来说明循环队列的实现方式。
在这里插入图片描述
在上图中A、B、C指的是队列的三种状态，顺序是从A到C，这三种状态演示了如何循环使用数组。在队列中，front是队头元素的下标，tail是队尾元素的下标+1，绿色填充方块是插入的数据，灰色是空下来的空间。假设队列最大可以存储k个元素(上图中为9)，但是我们需要开辟k+1个单位的空间（下标从0到9，k+1=9+1=10），将tail位置的空间空出来。当下标超过数组下标是时，回到数组开始的下标（也就是让下标等于0），即tail和font的值在区间[0,9]上循环，很多书上是用取余，本质都是让超过数组下标后回到开始的下标。此时队空的判断条件为tail==front，队满的判断条件为tail+1==front。

A状态：front=0，tail=9，tail+1==9+1==10，超过数组下标了，所以把tail+1看作0（这块具体可以参考判断队列满的代码，代码中实际上是定义了一个变量，用这个变量来跟front比较），此时正好等于front，所以是队满状态；在B状态：先出2个数据，此时front=2，那么根据前面的条件判断队非满，所以在9位置处插入数据，然后tail++，此时tail==10== 9+1 == k+1，所以让tail=0；C状态：插入一个数据后，tail=1，此时tail+1==(1+1)==2==front，表示队列已满。

循环队列的实现

结构体的定义

typedef struct {
    int* a; // 数组
    int k; // 队列最多能存多少个元素
    int front; // 队头下标
    int tail; // 队尾（队尾元素的下一个下标）
} MyCircularQueue;

注意： k指的是队列中可以放进去的元素个数，不是开辟的数组大小。k为9时，开辟的空间应该k+1个。

（1）队列初始化

MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    obj->a = (int*)malloc(sizeof(int)* (k+1));
    obj->k = k;
    obj->front = 0;
    obj->tail = 0;

    return obj;
}

（2）判断队列是否为空

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    return obj->front == obj->tail;
}

（3）判断队列是否已满

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    // 如果满的话tail+1 == front 
    int tailNext = obj->tail + 1;
    
    if (tailNext == obj->k+1) // 类似于对k+1取余
    {
        tailNext = 0;
    }

    return tailNext == obj->front;
}

定义变量tailNext的原因： 避免tai在数组最后一个位置时，tail+1超过数组下标，应该回到数组下标0位置，但是又不能让tail+1等于0，所以用这个tailNext这个临时变量来帮助判断。

（4）往队列中插入数据

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    
    if (myCircularQueueIsFull(obj))
    {
        return false;
    }
    else
    {
        obj->a[obj->tail] = value;
        obj->tail++;

        if (obj->tail == obj->k+1) // 超出数组下标后回到0位置
        {
            obj->tail = 0;
        }

        return true;
    }
}

（5）从队列中出数据

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if (myCircularQueueIsEmpty(obj))
    {
        return false;
    }
    else
    {
        obj->front++;
        if (obj->front == obj->k+1)
        {
            obj->front = 0;
        }

        return true;
    }
}

（6）队头数据

int myCircularQueueFront(MyCircularQueue* obj) {
    if (myCircularQueueIsEmpty(obj))
        return -1;
    else 
        return obj->a[obj->front];
}

（7）队尾数据

int myCircularQueueRear(MyCircularQueue* obj) {
    if (myCircularQueueIsEmpty(obj))
        return -1;
    else 
    {
        int tailPrev = obj->tail-1;

        if (tailPrev == -1) // 如果tail指向队列第一个位置，则队尾在第k个位置
        {
            tailPrev = obj->k;
        }

        return obj->a[tailPrev];
    }
}

（8）销毁队列

void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->a);
    free(obj);
}

完整代码

typedef struct {
    int* a; // 数组
    int k; // 队列最多能存多少个数据
    int front; // 队头
    int tail; // 队尾（队尾数据的下一个下标）

} MyCircularQueue;

// 创建循环队列
MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    obj->a = (int*)malloc(sizeof(int)* (k+1));
    obj->k = k;
    obj->front = 0;
    obj->tail = 0;

    return obj;

}

// 判断队列是否为空
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    return obj->front == obj->tail;
}

// 判断队列是否已满
bool myCircularQueueIsFull(MyCircularQueue* obj) {
    // 如果满的话tail+1 == front 
    int tailNext = obj->tail + 1;
    if (tailNext == obj->k+1)
    {
        tailNext = 0;
    }

    return tailNext == obj->front;
}

// 往队列中插入数据
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    
    if (myCircularQueueIsFull(obj))
    {
        return false;
    }
    else
    {
        obj->a[obj->tail] = value;
        obj->tail++;

        if (obj->tail == obj->k+1)
        {
            obj->tail = 0;
        }

        return true;
    }
}

// 从队列中出数据
bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if (myCircularQueueIsEmpty(obj))
    {
        return false;
    }
    else
    {
        obj->front++;
        if (obj->front == obj->k+1)
        {
            obj->front = 0;
        }

        return true;
    }
}

// 队头数据 
int myCircularQueueFront(MyCircularQueue* obj) {
    if (myCircularQueueIsEmpty(obj))
        return -1;
    else 
        return obj->a[obj->front];
}

// 队尾数据
int myCircularQueueRear(MyCircularQueue* obj) {
    if (myCircularQueueIsEmpty(obj))
        return -1;
    else 
    {
        int tailPrev = obj->tail-1;

        if (tailPrev == -1) // 如果tail指向队列第一个位置，则队尾在第k个位置
        {
            tailPrev = obj->k;
        }

        return obj->a[tailPrev];
    }
 
}

// 销毁队列
void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->a);
    free(obj);
}
从头开始的小白
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
结构体与队列
u013744104的博客
10-17 1782
队列的定义为先进先出，像排队一样。 队列的形式： 顺序队列：用数组表达。链式队列，用链表表达。循环队列：用数组表达 队列的元素的结构体： //Define a node typedef struct QuequeNode { int data; struct QuequeNode* next; }QueueNode; 队列本身的数据结构：包含头尾节点以及Size. 规则为尾进头出（方便操作） // Define a Linked Queue typedef struct LinkQueue
数据结构_队列_链表1
08-03
数据结构_队列_链表1
数据结构-C语言实现队列进队、出队等基本操作（内含图解）
m0_62211222的博客
08-16 6091
插入：先开辟新的结点，把数据放进去，并且让新的结点的next指向null，再让原来的tail指向新的结点。删除：先定义一个指针，指向原来的head的next，再删除head，然后更新head，让新的head指向刚刚定义的指针。注意：每次删除都要判断队列是否为空每次调用函数的时候都要断言传进来的结构体不为空。...
【数据结构之队列系列】队列详解
胡坚涛的博客
01-11 3430
前面我们学习了一种数据结构：栈，栈是一种只允许在一端尽进行插入删除的数据结构，而今天我们将学习另一种数据结构：队列，队列是一种支持在一端进行插入，在另一端进行删除的数据结构。
常用数据结构 ——— 队列（环形队列和顺序队列）
学习记录，交流学习
12-02 2373
主要介绍了顺序队列和环形队列的特点，以及用C语言实现了环形队列
一文教你数据结构体栈和队列的实现
小马同学的博客
12-11 5145
这篇文章是关于数据结构中栈和队列的实现，同时附函他的全部代码，相信大家看过这篇文章一定能够掌握栈和队列的实现！！！！！！！！！！
C语言数据结构005——队列
weixin_45084986的博客
06-28 5684
一、队列的基本概念 (1)定义:只能在表的一端进行插入操作，在表的另一端进行删除操作的线性表。 (2)特点：先进先出 示意图如下： 二、顺序存储结构的队列 有6个存储空间的顺序队列动态示意图 顺序队列的“假溢出”问题 ①假溢出 顺序队列因多次入队列和出队列操作后出现的虽有存储空间但不能进行入队列操作的情况。 ②如何解决顺序队列的假溢出问题？ 可采取四种方法： 1)采用循环队列； 2)按最大可能的进队操作次数设置顺序队列的最大元素个数； 3)修改出队算法，使每次出队列后都把队列中剩余数据元素向队头方向移动
数据结构之队列
qq_53010164的博客
04-11 2199
一、队列 (1)队列的概念 队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出(FIFO)的原则。 入队列：进行插入操作的一端称为队尾 出队列：进行删除操作的一端称为对头 如图： 二、队列的实现 队列既可以用数组和也可以用链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，每次删除队头，后面的元素就要向前移动，所以效率比较低 (1)问题1：结构体和指针变量传参 1.当我们创建的只是一个指针变量的时候，如果我们要改变这个指针变..
数据结构——队列的实现
勇气是明知不可为而为之
06-23 4623
这个结构体可以用来实现一个队列数据结构，其中 head 指向队列的开头，tail 指向队列的结尾，size 记录队列中节点的数量。通常情况下，向队列中添加一个节点会使 tail 指针指向新的节点，从队列中移除一个节点会使 head 指针指向下一个节点，并更新 size 的值。如果队列不为空，则将队列的 tail 节点的 next 指针指向 newnode，表示将 newnode 插入到队列的尾部，并将 tail 指针指向 newnode，表示 newnode 现在是队列中的最后一个节点。
【数据结构】队列详解
fighting小泽的博客
05-19 2073
🌸作者简介：目前正在学习C语言和数据结构。
数据结构之【队列】
weixin_40989362的博客
08-09 676
队列：先进先出，就是一块线性表，必须从头front的一方出队，从尾巴rear一方入队 我们生活中的队列就是这样的，出队的时候每次必须从a1出队，           当头出队后，尾巴就向前移动到下标为0处，这样的效率太低了，我们应该提高效率，每次头front出队了，就不需要向前移动 队头不需要每次都向前移动 如果front==rear的时候队为空，每次入队一个尾巴就向后面移动...
队列实现栈_栈_数据结构_队列_
09-30
C++用队列实现栈，供刷leetcode以及数据结构学习者使用。
stack&queue_reachicb_栈_数据结构_队列_小猫钓鱼_
09-29
小猫钓鱼纸牌游戏。A和B两个同学玩简单的纸牌游戏，每人手里有n张牌，两人轮流出牌并依次排列在桌面上，每次出掉手里的第1张牌，出牌后如果发现桌面上有跟刚才打出的牌的数字相同的牌，则把到相同的那张牌结束的全部...
fifo.rar_fifo_fifo 28335_fifo 数据结构_队列FIFO的数据结构
09-22
标准的先进先出队列数据结构,已经调试过的，可以直接应用到项目中
实验4栈和队列_栈_数据结构_creaturexqi_队列_
10-03
数据结构：栈和队列的实现内有两个文件夹 分别有栈 和 队列 的代码实现
【C 数据结构】循环链表
普罗米修斯的博客
04-11 677
在init重创建的结点next指向空，而在主函数调用创建之后手动 将head头结点的next指针指向自身。找到需要删除的结点，将其前一个结点的next指针直接指向删除结点的下一个结点。问题就是获取到链表的节点数同时也需要完成一次遍历才可以达成目标。在原有的双向链表的基础上，将尾部结点和头部结点进行互相连接。循环链表的尾指针指向的是链表的开头。
常见的数据结构
甄知一二的博客
04-13 873
链表在新增、删除数据都比较容易，可以在 O(1) 的时间复杂度内完成。但对于，不管是按照位置的查找还是按照数值条件的查找，。这显然就是 O(n) 的时间复杂度定一个奇数个元素的链表，查找出这个链表中间位置的结点的数值———一个巧妙的办法，就是利用进行处理。其中快指针每次循环向后跳转两次，而慢指针每次向后跳转一次链表的基本操作？。
C语言中的数据结构--链表的应用2（3）
2301_78694309的博客
04-11 1203
链表的应用（2）
数据结构——算法的时间复杂度和空间复杂度
最新发布
2301_76613753的博客
04-14 1238
今天我们来学习一下数据结构和算法的时间和空间复杂度，了解如何来评价一个算法的好坏。一、数据结构和算法数据结构是计算机存储、组织数据的方式，指相互之间存在一种或多种特定关系的数据元素的集合，是在内存中用来管理数据的结构。算法就是定义良好的计算过程，他取一个或一组的值为输入，并产生出一个或一组值作为输出。简单来说算法就是一系列的计算步骤，用来将输入数据转化成输出结果。算法定义了如何在数据结构上执行操作。
数据结构复习队列和栈
07-30
数据结构中的队列和栈是两种常见的数据结构。队列是一种先进先出（FIFO）的数据结构，而栈是一种后进先出（LIFO）的数据结构。 队列的基本概念包括定义和常见基本操作。队列可以使用顺序存储结构或链式存储结构来...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值