07 队列

已于 2024-01-25 17:48:02 修改
阅读量382 收藏 10
点赞数 7
分类专栏： 02 数据结构 初阶 文章标签： 数据结构 c语言 算法 开发语言
于 2024-01-25 01:00:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43422358/article/details/135834110
版权

目录

1.队列
2.实现
3.OJ题

1. 队列

只允许在一段进行插入数据操作，在另一端进行数据删除操作的特殊线性表，队列具有先进先出FIFO（First In Firtst Out），插入操作的叫队尾，删除操作的叫队头

在这里插入图片描述

2. 实现

队列可以用数组和链表的结构实现，需要从两端出操作数据，所以用链表的结构更优一点

在这里插入图片描述

队列的设计需要两层结构体，一层结构体是节点结构体，另一层是队列结构

头文件

#pragma once
#include <stdbool.h>

typedef int DATATYPE;

//节点
typedef struct _Node
{
	DATATYPE data;
	struct _Node* next;
}Node;

//队列
typedef struct _Queue
{
	struct _Node* head;
	struct _Node* tail;
	int size;
}Queue;

// 初始化
void Init(Queue* que);
// 入队
void Push(Queue* que, DATATYPE data);
// 出队
void Pop(Queue* que);
// 是否为空
bool Empty(Queue* que);
// 返回队首
DATATYPE Front(Queue* que);
// 返回队尾
DATATYPE Back(Queue* que);
// 队列大小
int Size(Queue* que);
// 销毁
void Destory(Queue* que);

实现文件

#include "Queue.h"
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

void Init(Queue* que)
{
	assert(que);
	//置空
	que->head = que->tail = NULL;
	que->size = 0;
}

void Push(Queue* que, DATATYPE data)
{
	assert(que);

	Node* newnode = (Node*)malloc(sizeof(Node));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return;
	}

	newnode->data = data;
	newnode->next = NULL;
	//空队,不为空
	if (que->head == NULL)
	{
		//防止一个空,另一个不为空
		assert(que->tail == NULL);
		que->head = que->tail = newnode;
	}
	else
	{
		que->tail->next = newnode;
		que->tail = newnode;
	}

	que->size++;
}

void Pop(Queue* que)
{
	assert(que);
	assert(!Empty(que));

	//一个节点,多个节点
	if (que->head->next == NULL)
	{
		free(que->head);
		que->head = que->tail = NULL;
	}
	else
	{
		//头删
		Node* del = que->head;
		que->head = que->head->next;
		free(del);
	}
	que->size--;
}

bool Empty(Queue* que)
{
	assert(que);
	//que.head == NULL && que.tail == NULL
	return que->size == 0;
}

DATATYPE Front(Queue* que)
{
	assert(que);
	assert(!Empty(que));

	return que->head->data;
}

DATATYPE Back(Queue* que)
{
	assert(que);
	assert(!Empty(que));

	return que->tail->data;
}

int Size(Queue* que)
{
	assert(que);

	return que->size;
}

void Destory(Queue* que)
{
	assert(que);

	Node* cur = que->head;
	while (cur != NULL)
	{
		Node* del = cur;
		cur = cur->next;
		free(del);
	}

	que->head = que->tail = NULL;
	que->size = 0;
}

主文件

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "Queue.h"

int main()
{
	Queue que;
	Init(&que);
	Push(&que, 1);
	Push(&que, 2);
	Push(&que, 3);
	Push(&que, 4);
	printf("%d ", Front(&que));
	printf("%d \r\n", Back(&que));
	Pop(&que);
	while (!Empty(&que))
	{
		printf("%d ", Front(&que));
		printf("%d \r\n", Back(&que));
		Pop(&que);
	}
	Destory(&que);
	return 0;
}

3. OJ题

3.1 用队列实现栈

https://leetcode.cn/problems/implement-stack-using-queues/description/
在这里插入图片描述

思路
利用前面写的队列。用队列实现栈的关键点在于，队列是先进先出，栈是先进后出。这时，可以用两个栈，需要出数据时将一个栈的所有数据捯到另一个栈中，留下最后一个数据，然后出队，这个就是栈的栈顶元素。每次需要出数据反复这样。入数据时，找一个不为空的入，不为空的出数据捯一遍后，刚好剩下刚进入的数据，栈为空也可以这样

在这里插入图片描述

//引入队列
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

typedef int DATATYPE;

//节点
typedef struct _Node
{
	DATATYPE data;
	struct _Node* next;
}Node;

//队列
typedef struct _Queue
{
	struct _Node* head;
	struct _Node* tail;
	int size;
}Queue;

void Init(Queue* que)
{
	assert(que);
	//置空
	que->head = que->tail = NULL;
	que->size = 0;
}

void Push(Queue* que, DATATYPE data)
{
	assert(que);

	Node* newnode = (Node*)malloc(sizeof(Node));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return;
	}

	newnode->data = data;
	newnode->next = NULL;
	//空队,不为空
	if (que->head == NULL)
	{
		//防止一个空,另一个不为空
		assert(que->tail == NULL);
		que->head = que->tail = newnode;
	}
	else
	{
		que->tail->next = newnode;
		que->tail = newnode;
	}

	que->size++;
}

bool Empty(Queue* que)
{
	assert(que);
	//que.head == NULL && que.tail == NULL
	return que->size == 0;
}
void Pop(Queue* que)
{
	assert(que);
	assert(!Empty(que));

	//一个节点,多个节点
	if (que->head->next == NULL)
	{
		free(que->head);
		que->head = que->tail = NULL;
	}
	else
	{
		//头删
		Node* del = que->head;
		que->head = que->head->next;
		free(del);
	}
	que->size--;
}

DATATYPE Front(Queue* que)
{
	assert(que);
	assert(!Empty(que));

	return que->head->data;
}

DATATYPE Back(Queue* que)
{
	assert(que);
	assert(!Empty(que));

	return que->tail->data;
}

int Size(Queue* que)
{
	assert(que);

	return que->size;
}

void Destory(Queue* que)
{
	assert(que);

	Node* cur = que->head;
	while (cur != NULL)
	{
		Node* del = cur;
		cur = cur->next;
		free(del);
	}

	que->head = que->tail = NULL;
	que->size = 0;
}


//------------------------------------------------------------------------
//实现栈
typedef struct {
    Queue que1;
    Queue que2;
} MyStack;


MyStack* myStackCreate() {
    
    MyStack* stk = (MyStack*)malloc(sizeof(MyStack));
    Init(&stk->que1);
    Init(&stk->que2);
    return stk;
}

void myStackPush(MyStack* obj, int x) {
    //往空队列插入
    if(Empty(&obj->que1))
        Push(&obj->que1, x);
    else
        Push(&obj->que2, x);
}

int myStackPop(MyStack* obj) {
    
    //定义空和非空,如果错误交换
    Queue* empty = &obj->que1;
    Queue* noempty = &obj->que2;

    if(Empty(&obj->que2))
    {
        empty = &obj->que2;
        noempty = &obj->que1;
    }
    //非空的大于1个往另一个队列捯
    while(Size(noempty) > 1)
    {
        Push(empty, Front(noempty));
        Pop(noempty);
    }

    int x = Front(noempty);
    Pop(noempty);
    return x;
}


int myStackTop(MyStack* obj) {

  //定义空和非空,如果错误交换
    Queue* empty = &obj->que1;
    Queue* noempty = &obj->que2;

    if(Empty(&obj->que2))
    {
        empty = &obj->que2;
        noempty = &obj->que1;
    }

    return Back(noempty);
}

bool myStackEmpty(MyStack* obj) {
    
    return Empty(&obj->que1) && Empty(&obj->que2);
}

void myStackFree(MyStack* obj) {
    Destory(&obj->que1);
    Destory(&obj->que2);
    free(obj);
}

/**
 * Your MyStack struct will be instantiated and called as such:
 * MyStack* obj = myStackCreate();
 * myStackPush(obj, x);
 
 * int param_2 = myStackPop(obj);
 
 * int param_3 = myStackTop(obj);
 
 * bool param_4 = myStackEmpty(obj);
 
 * myStackFree(obj);
*/

3.2 栈实现队列

https://leetcode.cn/problems/implement-queue-using-stacks/

在这里插入图片描述

思路
利用实现的栈。栈实现队列同样需要两个栈，由于栈是先进后出，当我们捯一遍数据后，刚好会把所有数据顺序反过来，所以只需要捯一次。利用这种特性，可以将两个栈分为只仅数据的和出数据的。刚开始出栈为空，需要出数据时，从入栈捯数据过来然后出栈顶元素

在这里插入图片描述

//引用栈结构
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

typedef int DATATYPE;

typedef struct _Stack
{
	DATATYPE* ary;
	int top;        //指向下一个存放数据的位置
	int capacity;
}Stk;


void Init(Stk* stack)
{
    assert(stack);

    stack->ary = NULL;
    stack->top = 0;   //指向栈顶下一个位置
    stack->capacity = 0;
}

void Push(Stk* stack, DATATYPE data)
{
    assert(stack);

    //需要扩容
    if (stack->top == stack->capacity)
    {
        int newcap = stack->capacity == 0 ? 4 : stack->capacity * 2;
        DATATYPE* temp = (DATATYPE*)realloc(stack->ary, sizeof(DATATYPE) * newcap);
        if (temp == NULL)
        {
            perror("realloc fail");
            return;
        }
        
        stack->ary = temp;
        stack->capacity = newcap;  
    }
    //存数据
    stack->ary[stack->top] = data;
    stack->top++;
}

bool Empty(Stk* stack)
{
    assert(stack);

    return stack->top == 0;
}

void Pop(Stk* stack)
{
    assert(stack);
    assert(!Empty(stack));

    stack->top--;
}

DATATYPE Top(Stk* stack)
{
    assert(stack);
    assert(!Empty(stack));

    return stack->ary[stack->top - 1];
}

int Size(Stk* stack)
{
    assert(stack);

    return stack->top;
}

void Destory(Stk* stack)
{
    assert(stack);

    free(stack->ary);
    stack->ary = NULL;
    stack->capacity = 0;
    stack->top = 0;
}

//------------------------------------------------------------------------
//实现队列
typedef struct {
    Stk stpush;
    Stk stpop;
} MyQueue;


MyQueue* myQueueCreate() {
    
    MyQueue* obj = (MyQueue*)malloc(sizeof(MyQueue));
    Init(&obj->stpush);
    Init(&obj->stpop);

    return obj;
}

void myQueuePush(MyQueue* obj, int x) {
    
    Push(&obj->stpush, x);
}

int myQueuePop(MyQueue* obj) {
   
    int ch = myQueuePeek(obj);
    Pop(&obj->stpop);
    return ch;
}

int myQueuePeek(MyQueue* obj) {
    if(Empty(&obj->stpop))
    {
        while(!Empty(&obj->stpush))
        {
            Push(&obj->stpop, Top(&obj->stpush));
            Pop(&obj->stpush);
        }
    }
    return Top(&obj->stpop);
}

bool myQueueEmpty(MyQueue* obj) {
    
    return Empty(&obj->stpush) && Empty(&obj->stpop);
}

void myQueueFree(MyQueue* obj) {
    Destory(&obj->stpush);
    Destory(&obj->stpop);
    free(obj);
}

/**
 * Your MyQueue struct will be instantiated and called as such:
 * MyQueue* obj = myQueueCreate();
 * myQueuePush(obj, x);
 
 * int param_2 = myQueuePop(obj);
 
 * int param_3 = myQueuePeek(obj);
 
 * bool param_4 = myQueueEmpty(obj);
 
 * myQueueFree(obj);
*/

3.3 环形队列

https://leetcode.cn/problems/design-circular-queue/
在这里插入图片描述
思路
环形队列用数组来实现。如果空间大小是8，就存7个元素，最后一个元素用来判断是否满了，用front和reor两个下标记录队头和队尾。删除就增加front，插入增加rero，如果这两个有一个超过了k，也就是总元素大小，就重新置为0
在这里插入图片描述

在这里插入图片描述



typedef struct {
    int* ary;
    int front;
    int reor;
    int k;
} MyCircularQueue;

MyCircularQueue* myCircularQueueCreate(int k) {

    MyCircularQueue* que = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    que->ary = (int*)malloc(sizeof(int) * (k + 1));
    que->front = que->reor = 0;
    que->k = k;
    return que;
}
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    return obj->reor == obj->front;
}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    return (obj->reor + 1) % (obj->k + 1) == obj->front;
}
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if (!myCircularQueueIsFull(obj)) {
        obj->ary[obj->reor] = value;
        obj->reor++;
        obj->reor = obj->reor % (obj->k + 1);
        return true;
    }
    return false;
}

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

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

int myCircularQueueRear(MyCircularQueue* obj) {
    if (myCircularQueueIsEmpty(obj))
        return -1;
    // return obj->ary[(obj->reor + obj->k) % (obj->k + 1)]
    if (obj->reor == 0)
        return obj->ary[obj->k];
    return obj->ary[obj->reor - 1];
}

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

在这里插入图片描述

平常情况下reor-front就可以算出长度，但如果reor循环加到front的左边，这时候就要加数组的长度%N取到长度

在这里插入图片描述
下面的就是（1-3+6）%6 =4，存了4个数据

且听吟风°
关注
  • 7
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
延时队列
IT界的一只菜鸟
05-19 483
延时队列 一、延时队列的应用 什么是延时队列？顾名思义：首先它要具有队列的特性，再给它附加一个延迟消费队列消息的功能，也就是说可以指定队列中的消息在哪个时间点被消费。 延时队列在项目中的应用还是比较多的，尤其像电商类平台： 1、订单成功后，在30分钟内没有支付，自动取消订单 2、外卖平台发送订餐通知，下单成功后60s给用户推送短信。 3、如果订单一直处于某一个未完结状态时，及时处理关单，并退还库存 4、淘宝新建商户一个月内还没上传商品信息，将冻结商铺等 。。。。 上边的这些场景都可以应用延时队列解决。 二、
07-Redis队列Stream、Redis多线程详解-ev.rar
03-08
07-Redis队列Stream、Redis多线程详解_ev.07-Redis队列Stream、Redis多线程详解_ev.07-Redis队列Stream、Redis多线程详解_ev.07-Redis队列Stream、Redis多线程详解_ev.07-Redis队列Stream、Redis多线程详解_ev.07-...
《大话数据结构》07 队列
阿钊侃技术的博客
04-19 910
本文讲解了一个非常重要的数据结构：队列，并与之前讲解过的栈进行了对比。
07队列，图文讲解极其易懂。
Ustinianljm的博客
12-15 3282
通俗易懂，图文搭配
07 ｜ 队列
编程｜成长｜生活，保持好奇心。
05-11 108
队列是一种常用的数据结构，它最大的特点是“先入先出”，即先进入队列中的元素最先出来。在面试时经常需要使用队列来解决与广度优先搜索相关的问题。
常用队列模式
HideInTime的博客
08-01 489
ActiveMQ、RabbitMQ、RocketMQ、Kafka对比 骑驴瞧视频2019-07-31 16:23:50 主要介绍四种常用的消息队列（ActiveMQ / RabbitMQ / RocketMQ / Kafka）的主要特性、优点、缺点。 一、ActiveMQ ActiveMQ 是由 Apache 出品，ActiveMQ 是一个完全支持JMS1.1 和 J2EE 1.4 规范...
LeetCode 75 part 07 队列
Ricardo的博客
09-30 133
【代码】LeetCode 75 part 07 队列。
队列操作
Peter_tang6的博客
07-24 770
前面学习了基于顺序表以及链式表的堆栈操作，这里的链式表指单向链表，这篇文章学习同样是基于顺序表以及链式表的队列操作。 队列与堆栈的不同之处在于队列是先进先出，即队列的两边都可以进行操作，一头压入，另一头弹出。这就需要用到头指针和尾指针两个指针，为了避免指针指向空的内存，因此这两个头尾指针可以循环，而且当队列处于空或者满状态的时候，头尾指针均可能重合。 基于顺序表的实现，初始化空
RocketMQ的延迟队列实现
阿呆的专栏
04-16 2863
例如Slot案例中写入的三条数据对应的两条延迟消息（均为延迟时间：2023-04-16 20:00:00）之间，夹杂着一条更晚触发的延迟消息（2023-04-16 20:05:00）老版本延迟队列仅支持几个延迟时间，而不是任意延迟时间，新版本进行了升级，可以支持任意版本。
并发07：阻塞队列
qq_28326501的博客
09-05 74
一：什么是阻塞队列 阻塞队列，也就是 BlockingQueue，它是一个接口。BlockingQueue 继承了 Queue 接口，是队列的一种。BlockingQueue 是线程安全的。 阻塞队列 BlockingQueue 主要实现分别为ArrayBlockingQueue、LinkedBlockingQueue、SynchronousQueue、DelayQueue、PriorityBlockingQueue 和 LinkedTransferQueue ...
自定义队列,XML,文件夹
07-23
从提供的压缩包文件名来看，可能包含了一些测试截图（test_fail.png、test_success.png）以及几个可能的测试文件（test_07_20、test_07_21_02、test_07_21）。这些文件可能是自定义队列和XML处理的测试结果，或者是...
NOIP提高组初赛复习3_队列(2020.10.07).pdf
12-16
队列是一种重要的数据结构，常被用于解决计算机科学和编程中的各种问题，特别是在处理顺序执行的任务和资源分配中。在NOIP（全国青少年信息学奥林匹克联赛）中，队列是提高组初赛复习的重要知识点之一。以下是关于...
捷波HA07UA11
01-31
AHCI模式的引入旨在提供串行ATA设备的原生命令队列（NCQ）功能，该功能允许硬盘内部优化读写顺序，从而提高数据传输速度。与传统的IDE（集成驱动电子）模式相比，AHCI模式提供了更高的性能和更丰富的错误处理机制。 ...
PHP消息队列实现及应用.txt
09-09
3-1 Redis (07:28) 3-2 Redis队列秒杀实现 (14:29) 第4章 RabbitMQ：更专业的消息系统实现方案 以RabbitMQ为例讲解了一些专业消息系统的原理，并使用官方的DEMO，演示其中的一个模块的使用方法。了解这类消息系统...
高阶数据结构——LRU Cache
最新发布
weixin_74310945的博客
08-09 645
LRU是Least Recently Used的缩写，意思是最近最少使用，它是一种Cache替换算法。什么是Cache？狭义的Cache指的是位于CPU和主存间的快速RAM， 通常它不像系统主存那样使用DRAM技术，而使用昂贵但较快速的SRAM技术。广义上的Cache指的是位于速度相差较大的两种硬件之间， 用于协调两者数据传输速度差异的结构。
常见8种数据结构
qq_43575301的博客
08-08 1946
应用于需要后进先出访问元素的场景，如函数调用栈、表达式求值等。应用于需要先进先出访问元素的场景，如任务调度、消息队列等。适用于优先队列，堆排序和实现高效的合并K个有序链表问题。应用于需要表示层次结构的场景，比如文件系统、组织结构等。应用于需要表示网络结构的场景，如社交网络、交通网络等。应用于需要快速查找和插入操作的场景，如字典、缓存等。一般应用于需要快速随机访问元素的场景。适用于需要频繁插入和删除元素的场景。
基础算法模板
2301_79235379的博客
08-08 509
欢迎订阅专栏，数据结构实验，期末大作业，前端后端，算法都有哦，想我发哪个方面的资源或文章可以私信我，免费的哦。
数据结构--第六天
xujiashuo1的博客
08-08 1253
树是由。
NOIP提高组初赛：队列及其应用复习(2020.10.07)
本文档主要针对NOIP提高组初赛的复习，详细讲解了队列（Queue）这一数据结构及其在算法中的应用。队列是一种特殊的线性数据结构，它具有“先进先出”（First In First Out，FIFO）的特点，与栈（Stack）形成鲜明对比...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值