数据结构之队列

最新推荐文章于 2024-08-16 10:42:04 发布
最新推荐文章于 2024-08-16 10:42:04 发布
阅读量1.1k 收藏 24
点赞数 43
文章标签： 数据结构 c语言 算法 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mr_Xuhhh/article/details/140725140
版权

队列

概念

概念：只允许在⼀端进⾏插⼊数据操作，在另⼀端进⾏删除数据操作的特殊线性表，队列具有先进先 出FIFO(First In First Out)

⼊队列：进⾏插⼊操作的⼀端称为队尾

出队列：进⾏删除操作的⼀端称为队头
在这里插入图片描述

队列底层结构选型

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

原因如下：
在这里插入图片描述

结构

//定义队列节点结构
struct	QueueNode
{
    int data;
    struct QueueNode*next;
}
struct Queue
{
    struct QueueNode*phead;
    struct QueueNode*tail;
}

队列的底层是链表，但是这里和单链表不同的是要写两个结构体，因为一个是确认底层的，还有一个是确定队列的结构的，因为队列要有队头和队尾

入队列

需要进行分类讨论：队列不为空和队列为空两种情况

在这里插入图片描述

如果队列不为空我们需要尾插一个新元素，然后让ptail指向新元素，如果队列为空，让phead=ptail指向新的元素

代码如下：

// ⼊队列，队尾
void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	//申请新节点
	QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
	if (newnode == NULL)
	{
		perror("malloc fail!");
		exit(1);
	}
	newnode->data = x;
	newnode->next = NULL;
	//ptail newnode
	if (pq->phead == NULL)
	{
		//队列为空
		pq->phead = pq->ptail = newnode;
	}
	else
	{
		//队列不为空
		pq->ptail->next = newnode;
		pq->ptail = newnode;
	}
	pq->size++;
}

出队列

和栈出数据非常的相似都需要判断队列是否为空 队列为空，不可出队列；队列不为空，可以出队列

但是这里也需要注意两种情况

  • 有多个节点的情况下
  • 只有一个节点的情况下

在这里插入图片描述

当队列不为空的时候采取头删的方式，然后将phead移向下一节点，如果为空，释放phead

代码如下：

//队列判空
bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->phead && pq->ptail == NULL;
}
// 出队列，队头
void QueuePop(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	//只有一个节点的情况,避免ptail变成野指针
	if (pq->phead == pq->ptail)
	{
		free(pq->phead);
		pq->phead = pq->ptail = NULL;
	}
	else
	{
		//删除队头元素
		QueueNode* next = pq->phead->next;
		free(pq->phead);
		pq->phead = next;
	}
	--pq->size;
}

求有效元素个数

// ⼊队列，队尾
pq->size++;
// 出队列，队头
--pq->size;

元素个数，作为下标的话，指向的是最后一个有效元素的下一个位置

源码

Queue.h

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

//定义队列结构
typedef int	QDataType;
typedef struct QueueNode
{
	int data;
	struct QueueNode* next;
}QueueNode;
 typedef struct Queue
{
	QueueNode*phead;
	QueueNode*ptail;
	int size;//保存队列有效数据个数
}Queue;
 //初始化队列
 void QueueInit(Queue* pq);
 // ⼊队列，队尾
 void QueuePush(Queue* pq, QDataType x);
 // 出队列，队头
 void QueuePop(Queue* pq);
 //队列判空
 bool QueueEmpty(Queue* pq);
 //取队头数据
 QDataType QueueFront(Queue* pq);
 //取队尾数据
 QDataType QueueBack(Queue* pq);
 //队列有效元素个数
 int QueueSize(Queue* pq);
 //销毁队列
 void QueueDestroy(Queue* pq);

Queue.c

#define _CRT_SECURE_NO_WARNINGS 1
#include "Queue.h"
//初始化队列
void QueueInit(Queue* pq)
{
	assert(pq);
	pq->phead = pq->ptail = NULL;
	pq->size = 0;
}
// ⼊队列，队尾
void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	//申请新节点
	QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
	if (newnode == NULL)
	{
		perror("malloc fail!");
		exit(1);
	}
	newnode->data = x;
	newnode->next = NULL;
	//ptail newnode
	if (pq->phead == NULL)
	{
		//队列为空
		pq->phead = pq->ptail = newnode;
	}
	else
	{
		//队列不为空
		pq->ptail->next = newnode;
		pq->ptail = newnode;
	}
	pq->size++;
}
//队列判空
bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->phead && pq->ptail == NULL;
}
// 出队列，队头
void QueuePop(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	//只有一个节点的情况,避免ptail变成野指针
	if (pq->phead == pq->ptail)
	{
		free(pq->phead);
		pq->phead = pq->ptail = NULL;
	}
	else
	{
		//删除队头元素
		QueueNode* next = pq->phead->next;
		free(pq->phead);
		pq->phead = next;
	}
	--pq->size;
}
//取队头数据
QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	return pq->phead->data;
}
//取队尾数据
QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	return pq->ptail->data;
}
//队列有效元素个数
int QueueSize(Queue* pq)
{
	assert(pq);
	/*int size = 0;
	QueueNode* pcur = pq->phead;
	while (pcur)
	{
		size++;
		pcur = pcur->next;
	}
	return size;*/
	return pq->size;
}
//销毁队列
void QueueDestroy(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	QueueNode* pcur = pq->phead;
	while (pcur)
	{
		QueueNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	pq->phead = pq->ptail = NULL;
	pq->size = 0;
}

test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include "Queue.h"
void QueueTest01()
{
	Queue q;
	QueueInit(&q);
	QueuePush(&q, 1);
	QueuePush(&q, 2);
	QueuePush(&q, 3);
	QueuePush(&q, 4);
	
	//QueuePop(&q);

	//printf("head:%d\n", QueueFront(&q));
	//printf("tail:%d\n", QueueBack(&q));
	printf("size:%d\n", QueueSize(&q));

	QueueDestroy(&q);
}
int main()
{
	QueueTest01();
	return 0;
}

栈VS队列

在这里插入图片描述

栈的结构图

栈的特性：先进后出（后进先出）

栈的底层结构是数组

逻辑结构：线性的

物理结构：线性的

在这里插入图片描述

队列的结构图

队列的底层结构是单链表

逻辑结构：线性的

物理结构：不一定是线性的

算法题：用队列实现栈

请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。

实现 MyStack 类：

  • void push(int x) 将元素 x 压入栈顶。
  • int pop() 移除并返回栈顶元素。
  • int top() 返回栈顶元素。
  • boolean empty() 如果栈是空的，返回 true ；否则，返回 false 。

注意：

  • 你只能使用队列的标准操作 —— 也就是 push to back、peek/pop from front、size 和 is empty 这些操作。
  • 你所使用的语言也许不支持队列。 你可以使用 list （列表）或者 deque（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。

示例：

输入：
["MyStack", "push", "push", "top", "pop", "empty"]
[[], [1], [2], [], [], []]
输出：
[null, null, null, 2, 2, false]

解释：
MyStack myStack = new MyStack();
myStack.push(1);
myStack.push(2);
myStack.top(); // 返回 2
myStack.pop(); // 返回 2
myStack.empty(); // 返回 False

提示：

  • 1 <= x <= 9
  • 最多调用100 次 push、pop、top 和 empty
  • 每次调用 pop 和 top 都保证栈不为空

思路：

首先要想到队列的性质：先进先出和栈的性质：先进后出

接下来来好好看这道题的思路

  • 创建两个队列Q1,Q2

在这里插入图片描述

我们举个例子：

拿1，2，3，4这四个数字举例子

出栈：找不为空的队列，将size-1个数据导入到另一个队列中

入栈：往不为空队列中插入数据

取栈顶元素：找不为空的队列，取队尾元素 （不出栈）

步骤如下：

  • 插入1，2，3
  • 出栈一次
  • 插入4
  • 全部出栈

必须保证其中至少一个队列为空

代码如下：

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

算法题：用栈实现队列

请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）：

实现 MyQueue 类：

  • void push(int x) 将元素 x 推到队列的末尾
  • int pop() 从队列的开头移除并返回元素
  • int peek() 返回队列开头的元素
  • boolean empty() 如果队列为空，返回 true ；否则，返回 false

说明：

  • 你 只能 使用标准的栈操作 —— 也就是只有 push to top, peek/pop from top, size, 和 is empty 操作是合法的。
  • 你所使用的语言也许不支持栈。你可以使用 list 或者 deque（双端队列）来模拟一个栈，只要是标准的栈操作即可。

示例 1：

输入：
["MyQueue", "push", "push", "peek", "pop", "empty"]
[[], [1], [2], [], [], []]
输出：
[null, null, null, 1, 1, false]

解释：
MyQueue myQueue = new MyQueue();
myQueue.push(1); // queue is: [1]
myQueue.push(2); // queue is: [1, 2] (leftmost is front of the queue)
myQueue.peek(); // return 1
myQueue.pop(); // return 1, queue is [2]
myQueue.empty(); // return false

提示：

  • 1 <= x <= 9
  • 最多调用 100 次 push、pop、peek 和 empty
  • 假设所有操作都是有效的 （例如，一个空的队列不会调用 pop 或者 peek 操作）

思路：

创建两个栈 pushST,popST

在这里插入图片描述

入队：往pushST中插入数据

出队：判断popST是否为空，不为空直接出数据（pop）；为空的话，将pushST中的数据导入到popST中再pop出去

取队头元素：跟出队一样，但是这里只取数据不pop出去

代码如下：
在这里插入图片描述
在这里插入图片描述

算法题：设计循环队列（非常硬核）

设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。

循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。

你的实现应该支持如下操作：

  • MyCircularQueue(k): 构造器，设置队列长度为 k 。
  • Front: 从队首获取元素。如果队列为空，返回 -1 。
  • Rear: 获取队尾元素。如果队列为空，返回 -1 。
  • enQueue(value): 向循环队列插入一个元素。如果成功插入则返回真。
  • deQueue(): 从循环队列中删除一个元素。如果成功删除则返回真。
  • isEmpty(): 检查循环队列是否为空。
  • isFull(): 检查循环队列是否已满。

示例：

MyCircularQueue circularQueue = new MyCircularQueue(3); // 设置长度为 3
circularQueue.enQueue(1);  // 返回 true
circularQueue.enQueue(2);  // 返回 true
circularQueue.enQueue(3);  // 返回 true
circularQueue.enQueue(4);  // 返回 false，队列已满
circularQueue.Rear();  // 返回 3
circularQueue.isFull();  // 返回 true
circularQueue.deQueue();  // 返回 true
circularQueue.enQueue(4);  // 返回 true
circularQueue.Rear();  // 返回 4

提示：

  • 所有的值都在 0 至 1000 的范围内；
  • 操作数将在 1 至 1000 的范围内；
  • 请不要使用内置的队列库。

思路：

我们知道队列的底层结构是链表，但是也是可以通过数组的形式实现的。

假设用链表来解决问题

在这里插入图片描述

如果数据满了，我们需要删除数据会比较繁琐，要先保留头节点的下一节点，然后phead向后走，最前面置空；链表还存在指针的消耗

如果用数组解决问题

在这里插入图片描述

因为插入数据：循环队列满了，就不能插入数据了

优点在于空间固定，更推荐底层结构为数组

  • 创建两个变量，front表示开头的位置，rear表示最后的位置，但是front==rear 无法判断究竟是空间已经满了还是说空了
  • 在这里插入图片描述

多申请出来的一块空间是用来占位置的，来判断是否满了。

这样子做有什么好处呢？不用去额外申请一个结构体变量去计算有效元素个数，提高程序的效率

代码如下：

//定义循环队列的结构
typedef struct {
    int* arr;//大小不确定，所以要动态开辟
    int front;//头
    int rear;//尾
    int capacity;
} MyCircularQueue;


MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* pst = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    pst->arr = (int*)malloc(sizeof(int) * (k + 1));
    pst->front = pst->rear = 0;
    pst->capacity = k;
    return pst;
}

bool myCircularQueueIsFull(MyCircularQueue* obj)
{
    return (obj->rear + 1) % (obj->capacity + 1) == obj->front;
}
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    //队列满了，不能插入数据
    if (myCircularQueueIsFull(obj))
    {
        return false;
    }
    obj->arr[obj->rear++] = value;
    obj->rear %= obj->capacity + 1;//obj->rear=obj->rear%(obj->capacity+1);
    return true;
}
bool myCircularQueueIsEmpty(MyCircularQueue* obj)
{
    return obj->rear == obj->front;
}
bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    //队列不为空
    if (myCircularQueueIsEmpty(obj))
    {
        return false;
    }
    //队列不为空
    obj->front++;
    obj->front %= obj->capacity + 1;
    return true;
}

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

int myCircularQueueRear(MyCircularQueue* obj) {
    if (myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    int prev = obj->rear - 1;//这里创建变量是为了防止rear=0的时候再-1导致越界
    if (obj->rear == 0)
    {
        prev = obj->capacity;//此时prev走的相当于是数组大小
    }
    return obj->arr[prev];
}

void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->arr);
    free(obj);
    obj = NULL;//和销毁顺序表相似，顺序表底层是数组
}

/**
 * Your MyCircularQueue struct will be instantiated and called as such:
 * MyCircularQueue* obj = myCircularQueueCreate(k);
 * bool param_1 = myCircularQueueEnQueue(obj, value);

 * bool param_2 = myCircularQueueDeQueue(obj);

 * int param_3 = myCircularQueueFront(obj);

 * int param_4 = myCircularQueueRear(obj);

 * bool param_5 = myCircularQueueIsEmpty(obj);

 * bool param_6 = myCircularQueueIsFull(obj);

 * myCircularQueueFree(obj);
*/

感谢还能看到这里的你，祝你天天开心，每天有所进步！！！
在这里插入图片描述

Mr_Xuhhh
关注
  • 43
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 13
    评论
【数据结构】队列-顺序队列、循环队列、链队、双端队列
Sicilly的博客
07-24 1292
定义 队列是只允许在一端进行插入，而在另一端进行删除的线性表。 队头（Front）：允许删除的一端，又称为队首。 队尾（Rear）： 允许插入的一端。 先进入队列的元素必然先离开队列，即先进先出（First In First Out）简称FIFO。 **对比：**栈中元素后进去的必然先出来，即后进先出LIFO（Last In First Out）。 顺序队列 用数组来实现队列，可以将队首放在数组下...
数据结构-----队列总结
柯南的博客
10-10 2003
一.何为队列？ 在数据结构中，在有序列表中数据的输入输出分别是由不同端口处理的，输出端称为前端，输入端称为后端，这样会使得先进入的数据先被取出，即它具有先进先出的特性。 二.队列都分为那几类？ 我们最常见的队列有：顺序队列，循环队列，链队列以及双向队列； 不过，我们除了必须掌握这几种常见队列也要对不常见的队列进行了解和熟悉，比如说：K队列，优先队列和无锁队列； 三.深入了解各种队列 1
数据结构 07-队列概念、分类、Python 中使用列表 list 实现
一分耕耘一分收获
06-06 1303
1. 队列简介 1.1 队列的概念 1.2 队列的类型 1.2.1 顺序队列 1.2.1 循环队列 1.2.2 双端队列 2. Python 中使用列表 list 实现队列 2.1 顺序队列的常规操作和代码实现 2.2 循环队列的常规操作和代码实现 2.3双端队列的常规操作和代码实现 ......
数据结构中的队列_数据结构中的队列类型
culing2941的博客
09-16 1185
数据结构中的队列Queue is an important structure for storing and retrieving data and hence is used extensively among all the data structures. Queue, just like any queue (queues for bus or tickets etc.) follows...
数据结构——队列知识总结
qq_43215434的博客
11-11 1928
1、队列的逻辑结构 队列：只允许在一端进行插入操作，而另一端进行删除操作的线性表。 空队列：不含任何数据元素的队列。 允许插入（也称入队、进队）的一端称为队尾，允许删除（也称出队）的一端称为队头。 操纵特性：先进先出。 2、队列的抽象数据类型定义： ADT Queue Data 队列中元素具有相同类型及先进先出特性， 相邻元素具有前驱和后继关系 O...
Java数据结构之队列的简单定义与使用方法
08-29
Java数据结构之队列的简单定义与使用方法 Java数据结构之队列是计算机科学中的一种基本数据结构，具有先进先出的特点。队列是一种特殊的线性表，元素的添加和删除只能在队列的两端进行，即队头和队尾。Java中实现...
数据结构之队列.rar
04-07
这个压缩包文件“数据结构之队列.rar”显然是关于队列数据结构的深入探讨，特别是结合了C++编程语言的应用。 队列的基本概念： 队列是一种线性数据结构，其一端允许元素的插入（称为后端或尾部），另一端允许元素的...
数据结构之队列的java实现
12-22
队列也是一种数据结构，类似于栈，只是与栈相反，在队列中先插入的数据也先被移除，即先进先出(FIFO，First In First Out)。队列可以理解成排队，比如，食堂窗口排的队，越在前面的，越早得到服务而先离开。在银行...
数据结构-使用javascript讲解数据结构之队列.zip
02-12
在这个专题中，我们重点关注的是使用JavaScript语言来讲解的数据结构之一：队列。队列是一种线性数据结构，其操作特性类似于现实生活中的排队等候，遵循“先进先出”（FIFO）的原则。 在JavaScript中，队列可以通过...
数据结构之队列（Java版）
01-21
1.队列概述：队列是一个有序表，可以用数组或链表实现（本篇讲的是用数组实现），遵循先入先出（FIFO）原则，即先存入队列的数据，要先取出，后存入的要后取出。 2.用数组实现队列的思路 使用数组的声明如下图，其中...
数据结构—队列Queue（数据类型int）
精神小伙
08-03 2781
#include&amp;lt;malloc.h&amp;gt; #include&amp;lt;assert.h&amp;gt; typedef int QueueDataType; typedef struct QueueNode { QueueDataType _data; struct QueueNode* _next; }QueueNode; typedef struct Queue { Q...
数据结构：八大数据结构分类
swadian2008的博客
03-24 5130
数据结构是计算机科学中用来组织和存储数据的一种方式。以下是常见的一些数据结构：数组(Array)：一组连续的内存空间，用来存储相同类型的数据。可以根据下标随机访问元素。但是在数组中插入或删除元素比较困难，因为需要移动后面的元素。栈(Stack)：一种后进先出的数据结构。只允许在栈顶插入和删除元素。通常用数组或链表实现。队列(Queue)：一种先进先出的数据结构。只允许在队尾插入元素，在队头删除元素。通常用数组或链表实现。
常用数据结构——队列及其应用
热门推荐
Tiko.T的部落格
09-28 1万+
队列和栈作为一种最简单最基本的常用数据结构，可以说在许多方面都应用广泛。在程序运行时，他们可以保存程序运行路径中各个点的信息，以便用于回溯操作或其他需要访问已经访问过的节点信息的操作。这里对队列的特点、作用做出描述、并简单地用不同途径实现了队列的基本功能。并介绍了队列的典型应用——迷宫问题。
数据结构——循环队列存储结构以及实现
Cary程祺
10-30 5941
队列的顺序存储结构，是将元素存在一个一维数组中，队头所在的位置下标是0，当要入队操作时，直接在队尾后一个位置插入一个结点即可，时间复杂度为O(1)。而出队列，出队的元素下标为0，所以队列中所有的元素都要向前移动，时间复杂度为O(n)。如果不去限制队头的元素必须存在下标为0的位置，那么也可以做到时间复杂度为O(1)。为了避免只有一个元素时，队头队尾重合使得处理变得麻烦，于是设置两个指针，front指向
数据结构之树的存储结构
最新发布
DKPT的博客
08-16 567
孩子链表表示法将树中所有节点存储在一个顺序表中，每个数据元素有两个域：数据域和存放该节点第一个孩子地址的指针域。同时，为树中每个节点构建一个单链表，链表中的节点也有两个域：存放该孩子节点在顺序表中的数组下标和指向下一个孩子的指针。对于完全二叉树，如果父节点的索引是i（假设从0开始计数），那么它的左子节点的索引是2i+1，右子节点的索引是2i+2。数组的第一个元素存储树的根节点。双亲表示法通过采用一维数组来存储树中的节点，其中每个节点被赋予一个结构体类型，包含数据域和父节点位置域（parent域）。
评论 13
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值