学习记录——day17 数据结构 队列 链式队列

已于 2024-07-25 14:56:09 修改
阅读量553 收藏 6
点赞数 5
文章标签： 学习 数据结构
于 2024-07-23 15:25:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_64918301/article/details/140626282
版权

队列介绍

1、队列也是操作受限的线性表:所有操作只能在端点处进行，其删除和插入必须在不同端进行

2、允许插入操作的一端称为队尾，允许删除操作的一端称为队头

3、特点:先进先出(FIFO)

4、分类：

        顺序存储的栈称为顺序栈

        链式存储的队列，称为链式队列

顺序队列

1、使用一片连续存储的空间存储队列，并且给定两个变量，分别记录队头和队尾下标

2、普通顺序队列使用中，存在“假溢满”现象

        假溢满:队列中明明还有存储空间，但是由于队尾已经达到了数组的最大下标，不能在继续                          入队元素了

3、为了解决“假溢满”现象，我们引入了循环顺序队列

循环顺序队列

循环顺序队列:通过相关操作，当对头或队尾达到数组最大下标时，可以返回到下标为0的位置

注：以下均使用人为浪费一个空间的方法判满

1、创建

头节点类型定义

//类型重定义
typedef int datatype;


//队列类型结构体
typedef struct Queue
{
    datatype data[MAX];
    int head;
    int tail;

}SeqQueue, *SeqQueuePtr;

创建队列

SeqQueuePtr queue_create()
{
    SeqQueuePtr Q = (SeqQueuePtr)malloc(sizeof(SeqQueue));
    if(NULL == Q)
    {
        return NULL;
    }

    bzero(Q->data,sizeof(Q->data));
    Q->front = Q->tail = 0;

    printf("创建成功 \n");

    return Q;
}

2、判空判满

int queue_empty(SeqQueuePtr Q)
{
    return Q->tail == Q->front;
}

int queue_full(SeqQueuePtr Q)
{
    return (Q->tail+1)%MAX == Q->front;
}

3、插入

void queue_push(SeqQueuePtr Q ,datatype e)
{
    if (NULL == Q || queue_full(Q))
    {
        return;
    }
    
    Q->data[Q->tail] = e;

    Q->tail = (Q->tail+1)%MAX;

    return;
}

4、遍历

void queue_show(SeqQueuePtr Q)
{
    if (NULL == Q)
    {
        return;
    }

    printf("遍历结果:");
    for (int i = Q->front; i !=Q->tail; i=(i+1)%MAX)
    {
        printf("%d\t",Q->data[i]);
    }
    putchar(10);
    return;
}

5、出队

void queue_pop(SeqQueuePtr Q)
{
    if (NULL == Q || queue_empty(Q))
    {
        return;
    }
    
    printf("%d 出队\n",Q->data[Q->front]);

    Q->front = (Q->front+1)%MAX;
}

6、求实际大小

int queue_size(SeqQueuePtr Q)
{
    if (NULL == Q)
    {
        return -1;
    }

    //不使用循环求大小

    int size = ((Q->tail-Q->front)+MAX)%MAX;

    return size;
}

7、销毁

void queue_destroy(SeqQueuePtr Q)
{
    if (NULL != Q)
    {
        free(Q);
        Q = NULL;
    }
    
    printf("boom!!\n");

    return;
}

8、完整代码

dui_lie.h

#ifndef DUI_LEI
#define DUI_LEI

#include <myhead.h>

#define MAX 8
typedef int datatype;

typedef struct 
{
    datatype data[MAX];
    int front;
    int tail;
}SeqQueue,*SeqQueuePtr;

SeqQueuePtr queue_create();

int queue_empty(SeqQueuePtr Q);

int queue_full(SeqQueuePtr Q);

void queue_push(SeqQueuePtr Q ,datatype e);

void queue_show(SeqQueuePtr Q);

void queue_pop(SeqQueuePtr Q);

int queue_size(SeqQueuePtr Q);

void queue_destroy(SeqQueuePtr Q);


#endif // !DUI_LEI.H

dui_lie.c

#include "dui_lie.h"
#include <myhead.h>

SeqQueuePtr queue_create()
{
    SeqQueuePtr Q = (SeqQueuePtr)malloc(sizeof(SeqQueue)*MAX);
    if(NULL == Q)
    {
        return NULL;
    }

    bzero(Q->data,sizeof(Q->data));
    Q->front = Q->tail = 0;

    printf("创建成功 \n");

    return Q;
}

int queue_empty(SeqQueuePtr Q)
{
    return Q->tail == Q->front;
}

int queue_full(SeqQueuePtr Q)
{
    return (Q->tail+1)%MAX == Q->front;
}

void queue_push(SeqQueuePtr Q ,datatype e)
{
    if (NULL == Q || queue_full(Q))
    {
        return;
    }
    
    Q->data[Q->tail] = e;

    Q->tail = (Q->tail+1)%MAX;

    return;
}

void queue_show(SeqQueuePtr Q)
{
    if (NULL == Q)
    {
        return;
    }

    printf("遍历结果:");
    for (int i = Q->front; i !=Q->tail; i=(i+1)%MAX)
    {
        printf("%d\t",Q->data[i]);
    }
    putchar(10);
    return;
}

void queue_pop(SeqQueuePtr Q)
{
    if (NULL == Q || queue_empty(Q))
    {
        return;
    }
    
    printf("%d 出队\n",Q->data[Q->front]);

    Q->front = (Q->front+1)%MAX;
}

int queue_size(SeqQueuePtr Q)
{
    if (NULL == Q)
    {
        return -1;
    }

    //不使用循环求大小

    int size = ((Q->tail-Q->front)+MAX)%MAX;

    return size;
}

void queue_destroy(SeqQueuePtr Q)
{
    if (NULL != Q)
    {
        free(Q);
        Q = NULL;
    }
    
    printf("boom!!\n");

    return;
}

main.c

#include "dui_lie.h"
int main(int argc, char const *argv[])
{
    SeqQueuePtr Q = queue_create();
    if (NULL == Q)
    {
        return -1;
    }

    queue_push(Q,90);
    queue_push(Q,80);
    queue_push(Q,100);
    queue_push(Q,20);
    queue_show(Q);

    queue_pop(Q);
    queue_pop(Q);
    queue_show(Q);

    printf("数组实际大小为%d:\n",queue_size(Q));

    queue_destroy(Q);
    return 0;
}

链式队列

链式存储的队列称为链式队列

实现原理:
        单向链表头插尾删实现:链表的头部就是队尾，链表的尾部就是队头                                

        单向链表头删尾插实现:链表的头部就是队头，链表的尾部就是队尾

        但是，上述操作中，都要用到链表尾部节点，都需要遍历整个链表完成，于是专门使用一个指针指向队尾，称为尾指针

00.h

#ifndef DAY17_1
#define DAY17_1

#include <myhead.h>

//类型重定义
typedef int datatype;

//节点结构体
typedef struct Node
{
    union 
    {
        datatype data;
        int len;
    };
    
    struct Node *next;
    
}Node, *NodePtr;

//头节点结构体
typedef struct Queue
{
    NodePtr head;
    NodePtr tail;

}Queue, *QueuePtr;

//队列创建
QueuePtr queue_create();

//判空
int queue_empty(QueuePtr Q);

//头插
int queue_push(QueuePtr Q,datatype);

//遍历
int queue_show(QueuePtr Q);

//出队
int queue_pop(QueuePtr Q);

//输出实际大小
int queue_size(QueuePtr Q);

//销毁
void queue_destroy(QueuePtr Q);

#endif // DAY17_1

00.c

#include "00.h"

//先创建队列 然后创建链表，将队列的两个指针指向链表
QueuePtr queue_create()
{
    //申请队列的空间
    QueuePtr Q = (QueuePtr)malloc(sizeof(Queue));
    if (NULL == Q)
    {
        printf("创建失败\n");
        return NULL;
    }

    //创建链表
    Q->head = (NodePtr)malloc(sizeof(Node));

    if (Q->head == NULL)
    {
        printf("创建失败\n");
        free(Q);
        return NULL;
    }

    Q->head->len = 0;
    Q->head->next = NULL;
    
    Q->tail = Q->head;

    return Q;
}


int queue_empty(QueuePtr Q)
{
    return Q->head->len == 0;
}

int queue_push(QueuePtr Q,datatype e)
{
    if (NULL == Q)
    {
       return -1;
    }

    NodePtr p = (NodePtr)malloc(sizeof(Node));
    if (NULL == p)
    {
        return -1;
    }
    
    p->data = e;
    p->next = NULL;

    Q->tail->next = p;

    Q->tail = p;

    Q->head->len++;
    
}

int queue_show(QueuePtr Q)
{
    if (NULL == Q || queue_empty(Q))
    {
        return -1;
    }
    NodePtr q = Q->head->next;

    while (q)
    {
        printf("%d\t",q->data);

        q = q->next;
    }
    putchar(10);
}

int queue_pop(QueuePtr Q)
{
    if (NULL == Q)
    {
        return -1;
    }
    

    NodePtr p = Q->head->next;
    Q->head->next = p->next;
    printf("%d 出队\n",p->data);
    free(p);
    p = NULL;

    //如果所有节点都出列成功，将尾节点重新指向头节点
    if (Q->tail == NULL)//Q->head->next == NULL
    {
        Q->tail = Q->head;
    }
    

    Q->head->len--;
}

int queue_size(QueuePtr Q)
{
    if (NULL == Q)
    {
        return -1;
    }
    
    return Q->head->len;
}

void queue_destroy(QueuePtr Q)
{
    if (NULL == Q)
    {
        return;
    }
    
    //释放所有节点
    while (!queue_empty(Q))
    {
        queue_pop(Q);
    }
    
    //释放头结点
    free(Q->head);
    Q->head = Q->tail = NULL;

    //释放队列空间
    free(Q);
    Q = NULL;
}

main.c

#include "00.h"

int main(int argc, char const *argv[])
{
    QueuePtr Q = queue_create();
    if (NULL == Q)
    {
        return -1;
    }
    queue_push(Q,233);
    queue_push(Q,1314);
    queue_push(Q,520);

    queue_show(Q);

    queue_pop(Q);
    queue_pop(Q);
    queue_pop(Q);
    
    queue_destroy(Q);

    return 0;
}

子座
关注
学习记录——day14 数据结构 线性表
weixin_64918301的博客
07-18 950
1、数据：实际能够被计算机识别、存储、处理的用于描述客观事实的符号2、实际的基本单位：数据元素数据元素：就是能够完整描述事物的基本单位3、数据的最小单位：数据项数据项：用于组成数据元素的不可分割的最小单位4、数据对象：由多个数据元素组成的一个集合称为数据对象5、数据之间的关系：数据项 ==》 数据元素 ==》 数据对象 ==》 数据。
嵌入式学习——数据结构（队列、二叉树）——day49
qq_47798402的博客
06-21 329
高速设备和低速设备利用缓冲区进行协调匹配。8. 树——一对多（与线性一对一不同）（二叉树的思想是递归）8.4 完全二叉树（从满二叉树中从左至右、从前置后插入）3. 串口数据的通信利用队列进行协调。2. 缓冲区——先进先出的队列。节点的度：该节点后继节点的个数。8.1 深度和（广）度（数的度（广度））7. 队列和栈的区别——队列应用更广泛。4. 顺序队列——循环队列（非重点）8.3 满二叉树（树都是饱满的）8.2 二叉树（（广）度为2）1. 满二叉树第k层节点个数。叶子节点：没有后继节点。
学习记录——day16 操作受限的线性表 链式栈
weixin_64918301的博客
07-22 239
1、在之前的内容，无论是顺序表还是链表，都是详细处理的线性表，既可以在端点处进行操作也 可以在中间位置操作2、现实生活中，有很多并不需要在中间进行操作的序列，只在端点处进行操作，这样的线性表，我们称为操作受限的线性表3、根据不同的受限情况，线性表分为:栈、队列4、栈:插入和删除操作都只允许在同一端进行队列:插入和删除操作都只允许在异端进行。
数据结构学习——栈和队列
YiHeboy的博客
07-07 197
栈和队列
嵌入式学习——数据结构（单向无头链表）——day46
qq_47798402的博客
06-17 266
它不仅包括数据元素的存储方式，还包括数据元素之间的关系，以及对数据进行操作的方法和算法。数据结构的选择和设计直接影响算法的效率和程序的性能，是计算机科学与编程中非常重要的基础。它衡量的是算法的执行时间随输入规模的变化情况，通常用大O记号表示，如O(n)、O(log n)等。3. 散列存储（哈希存储）将数据元素的存储位置与关键码之间建立确定对应关系从而实现查找的存储方式。顺序表、链式表、顺序栈、链式栈、顺序队列、链式队列、二叉树、哈希表。1. 线性结构（一对一）表、数组、链表、队列、栈。
数据结构学习笔记——机械研究生Day_1
qq_53000090的博客
06-29 298
小白数据结构学习笔记
坚持代码实现数据结构DAY04——队列
weixin_45944993的博客
03-12 186
前言：我之前有看过一些博主说，他们工作时要求做一个银行排队系统； 当然实现的方法各种各样，今天介绍的是我们数据结构中的队列queue,当然c++里面有现成的可以用，甚至还有优先队列，但了解原理也很重要啊！ 依旧是我百度copy 的图 当然除了线性队列还有循环队列，之前刷过的题里面就涉及到了，依旧上图 1、Queue CreatQueue( int MaxSize )：生成长度为MaxSize的...
嘉明的数据结构学习Day5——作栈和队列以及它们的顺序存储与链式存储的实现
Zcymatics的博客
04-28 641
栈与队列是什么 栈和队列其实就是操作受限制的线性表。 下面来复习一下线性表的概念 具有n个相同类型元素的有限序列 有的人就会问，那么它们受限在哪里呢？ 栈：只允许一段插入和删除。 队列：只允许一端插入一端删除。 栈 前面说了栈是一种受限的线性表，因为它只允许插入和删除操作都在一端进行。 栈的专业术语 栈顶：即允许插入和删除的一端 栈底：即不允许删除和插入的一端 空栈：栈中不包含任何元素 LIFO后进先出 or FILO先进后出 例子：弹夹、烤串 栈的基本操作 初始化空栈栈 判断是否为空栈 出栈 入栈 读取栈
算法学习笔记Day1 ——数据结构和算法的框架思维
m0_61940795的博客
04-05 243
对于任何数据结构，所进行的操作无非就是遍历+访问，具体一点就是增删改查，遍历方式分为线性（for/while）和非线性（递归），数组是典型的线性遍历，链表是二者结合，二叉树就是典型的递归遍历。其中数组特点是物理上连续、结构紧凑，支持随机访问，但是O(N)增删，因为需要平移数组；是数组（顺序存储）和链表（链式存储），不管是哈希表、树、图、堆栈、队列等，其基本实现方法都只有数组和链表两种。的题目，培养框架思维，因为所有递归算法都是树的遍历，这样在后续学习DP和回溯等算法时会势如破竹。
数据结构(Java)——Day10(双向链表，栈)
LengchenAl的博客
11-24 758
数据结构(Java)——Day10(双向链表，栈)
Leap Day1——数据结构与算法 抽象数据类型、算法分析和效率(1)
2401_84150154的博客
05-06 982
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数初中级Android工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。因此收集整理了一份《2024年Web前端开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点！
【C++养成计划】队列 —— 快速上手STL queue类（Day13）
不积跬步，无以至千里！
08-20 4254
小白专属的《C++21天养成计划》，21天快速入门！
数据结构学习笔记Day7（完结篇）
qq_48484114的博客
04-10 1029
数据结构学习笔记Day7（完结篇），7天了解数据结构，进步每一天！
2022暑初二信息竞赛学习笔记集锦
C2024XSC249的博客
08-23 314
学习笔记：并查集 树状数组 Hash 图的概念 最短路 最小生成树 倍增 RMQ 拓扑排序 欧拉回路
嵌入式通信协议：UART简明学习笔记
weixin_73867577的博客
10-31 800
学习UART串口的简明学习笔记
ORB-SLAM2源码学习：ORBextractor.cc：IC_Angle 利用灰度质心法求解关键点方向角
2301_76831056的博客
11-01 679
IC_Angle 利用灰度质心法求解关键点方向角并在computeOrientation函数中被调用计算图像中所有特征点的方向。
嵌入式通信协议：MODBUS简明学习笔记
weixin_73867577的博客
11-02 300
学习Modbus的简明学习笔记
SPI通信详解-学习笔记
最新发布
qq_45059758的博客
11-04 230
SPI通信
diffusion model 学习笔记
wubing's 博客
11-01 970
郎之万公式: 描述了粒子做随机布朗运动 (粒子位置随时间变化的关系), 是一种 SDE, 描述了 由梯度力(即.即我们在无条件模型 DDPM 估计的噪声中添加一个微小的扰动(. 基本上,在采样一半时,基本上预测的。输出的是噪声的估计, 这个估计的噪声。通过上面的公式，我们可以知道，当知道。),就可以作为条件模型的噪声估计.首先,假设我们已经有了一个训练好的。: 每一步中保留的原始信号的比例。的计算有各种不同的方法，). 已经接近于真实的。)影响的系统的时间演化.也就是,我们训练的网络。
Python学习：Json与Csv数据存储实战——爬虫Day12
在本篇关于爬虫学习的文章中，主要关注的是数据存储技术中的JSON和CSV格式，以及如何在Python中处理这两种常见的数据交换格式。文章从JSON的定义和特点开始讲解，指出JSON是一种轻量级的数据交换格式，相较于XML，其...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值