实战日记：以数组方式实现静态队列操作

已于 2023-05-16 10:35:12 修改
阅读量202 收藏
点赞数
分类专栏： 嵌入式学习日记 文章标签： 数据结构 程序人生 经验分享
于 2020-05-28 17:18:46 首次发布

学习背景

工作两年，大多数时间都是用一些常用的代码实现一些功能，对数据结构并没有怎么使用，也没有怎么花时间去了解，只知道队列是先进先出这些基本的东西（-.-），并没有去细究其中的实现过程，直到最近在做一个项目，用到串口收发，为避免极端情况下发生发送碰撞（在极短时间内有两条发送指令一起执行，导致从机无法做到数据的有效识别，比如一些正常的指令固定每隔几分钟发一次，在这个指令准备发送的时候一个条件触发的指令也被触发了，就会一瞬间发送两条指令），受同事启发使用队列结构，其实现效果为：当有指令需要通过串口发送时，将指令标识放入队列中，主函数每隔一定时间（假定为10ms）判断队列是否为空，如果不为空则从队列中取出指令标识，判断该指令标识属于哪一个指令，然后执行该指令的发送函数。

注：下文讲解的源码来自于网络，非本人所写，如有侵权请联系作者删除，本文主要借助于源码和实验讲解队列的实现过程

写这篇博客一方面为了记录自己所学到东西，一方面为了加强理解，同时将这篇文章发布出来，希望可以得到相应的指正！

队列

队列操作

常用队列包含的操作有：创建队列、添加数据、取出数据、判断队列是否为空

本文主要介绍以数组为模型的静态方式创建一个队列的方法，既然以数组为模型，那它大致应该是这样的：创建一个指定大小的数组，该数组的长度即为队列的大小，每当向队列中存一个数，也就是给数组的指定下标赋值，然后将下标+1，该下标应该是从0开始的，所以需要一个变量记录这个操作，我们先暂时将这个变量定义为in，同时还需要一个计数器count，每存一个数，count加1，每取出一个数count减1，这个count可以用来判断队列是否为空和是否溢出，同时还需要一个变量用来记录取数据的数组下标，因为队列是先进先出，所以这个变量也是从0开始的，也就是从数组下标0开始取数据

根据以上的叙述，所以定义出一个队列的结构体变量类型，如下：

typedef struct
{
  uint8_t out;	//记录取数据的数组下标
  uint8_t in;		//记录存数据的数组下标
  uint8_t count;	//已存入队列中的元素个数
  uint8_t queueSize;//队列大小
  uint8_t elementType;//元素的大小，也就是数组元素的大小
  QElementType* array;//存放你所定义的数组的指针
}
QUEUE_T;

创建队列

所谓创建队列，也就是队列的初始化，也就是对队列中各个元素的赋值，如下

#define QUEUE_SIZE 5 //队列大小

QUEUE_T MyQueue;//定义一个队列结构体变量

u8 MyQueue_pBuffer[QUEUE_SIZE];//对应队列的数组模型

u8 tx;//模拟的用于存放发送标志的变量

//函数源码
void queue_Init(QUEUE_T * pQueue, void * pBuffer, BYTE sizeOfElements, BYTE numberOfElements)
{
  pQueue->out = 0;
  pQueue->in = 0;
  pQueue->queueSize = numberOfElements;
  pQueue->count = 0;
  pQueue->elementType = sizeOfElements;
  pQueue->array = (BYTE*)pBuffer;
}

//初始化队列
queue_Init(&MyQueue,MyQueue_pBuffer,sizeof(MyQueue_pBuffer[0]),QUEUE_SIZE);

向队列中添加一个元素

//源码
BOOL queue_Enqueue(QUEUE_T * pQueue, void * pElement)
{
  if (pQueue->count >= pQueue->queueSize)
  {
    return FALSE;
  }
  else
  {
    BYTE i;
    BYTE* pEl = pElement;

    for (i = 0; i < pQueue->elementType; i++)
    {
      pQueue->array[ (pQueue->in)*(pQueue->elementType) + i ] = *(pEl + i);
    }

    pQueue->in = (pQueue->in + 1) % pQueue->queueSize;
    pQueue->count = pQueue->count + 1;
  }
  return TRUE;
}

//添加一个元素的调用例程
tx='1';
queue_Enqueue(&MyQueue,&tx);

从队列中取出一个元素

//源码
BOOL queue_Dequeue(QUEUE_T * pQueue, void * pElement)
{
  if (pQueue->count <= 0)
  {
    return FALSE;
  }
  else
  {
    BYTE i;
    BYTE* pEl = pElement;

    for (i = 0; i < pQueue->elementType; i++)
    {
      *(pEl + i) = pQueue->array[(pQueue->out) * (pQueue->elementType) + i];
    }

    pQueue->out = (pQueue->out + 1) % pQueue->queueSize;
    pQueue->count = pQueue->count - 1;
  }
  return TRUE;
}
//调用例程
u8 rtn;
queue_Dequeue(&MyQueue,&rtn)；

 我的测试实验

通过打印的内容观察分析队列原理，以下给出我的测试实验源码和实验结果，以助于理解队列，我的实验大致流程为：

创建队列（队列长度为5）

向队列中添加一个字符'1'

向队列中添加一个字符'2'

向队列中添加一个字符'3'

向队列中添加一个字符'4'

向队列中添加一个字符'5'

然后：取数据-取数据-存数据（字符‘4’）-取数据

实验源码

queue_Init(&MyQueue,MyQueue_pBuffer,sizeof(MyQueue_pBuffer[0]),QUEUE_SIZE);
	my_printf("out=%d ,in=%d ,count=%d ,queueSize=%d ,elementType=%d ,array=%s\r\n",MyQueue.out,MyQueue.in,MyQueue.count,MyQueue.queueSize,MyQueue.elementType,MyQueue.array);
	HAL_Delay(500);
	
	tx='1';
	my_printf("%d ",queue_Enqueue(&MyQueue,&tx));//存数据，同时打印返回值
	my_printf("out=%d ,in=%d ,count=%d ,queueSize=%d ,elementType=%d ,array=%s\r\n",MyQueue.out,MyQueue.in,MyQueue.count,MyQueue.queueSize,MyQueue.elementType,MyQueue.array);
	HAL_Delay(500);
	
	tx='2';
	my_printf("%d ",queue_Enqueue(&MyQueue,&tx));//存数据，同时打印返回值
	my_printf("out=%d ,in=%d ,count=%d ,queueSize=%d ,elementType=%d ,array=%s\r\n",MyQueue.out,MyQueue.in,MyQueue.count,MyQueue.queueSize,MyQueue.elementType,MyQueue.array);
	HAL_Delay(500);
	
	tx='3';
	my_printf("%d ",queue_Enqueue(&MyQueue,&tx));//存数据，同时打印返回值
	my_printf("out=%d ,in=%d ,count=%d ,queueSize=%d ,elementType=%d ,array=%s\r\n",MyQueue.out,MyQueue.in,MyQueue.count,MyQueue.queueSize,MyQueue.elementType,MyQueue.array);
	HAL_Delay(500);
	
	tx='4';
	my_printf("%d ",queue_Enqueue(&MyQueue,&tx));//存数据，同时打印返回值
	my_printf("out=%d ,in=%d ,count=%d ,queueSize=%d ,elementType=%d ,array=%s\r\n",MyQueue.out,MyQueue.in,MyQueue.count,MyQueue.queueSize,MyQueue.elementType,MyQueue.array);
	HAL_Delay(500);
	
	tx='5';
	my_printf("%d ",queue_Enqueue(&MyQueue,&tx));//存数据，同时打印返回值
	my_printf("out=%d ,in=%d ,count=%d ,queueSize=%d ,elementType=%d ,array=%s\r\n",MyQueue.out,MyQueue.in,MyQueue.count,MyQueue.queueSize,MyQueue.elementType,MyQueue.array);
	HAL_Delay(500);
	
	my_printf("%d ",queue_Dequeue(&MyQueue,&rtn));//取数据，同时打印返回值
	my_printf("rtn=%s ",&rtn);
	my_printf("out=%d ,in=%d ,count=%d ,queueSize=%d ,elementType=%d ,array=%s\r\n",MyQueue.out,MyQueue.in,MyQueue.count,MyQueue.queueSize,MyQueue.elementType,MyQueue.array);
	HAL_Delay(500);
	
	
	my_printf("%d ",queue_Dequeue(&MyQueue,&rtn));//取数据，同时打印返回值
	my_printf("rtn=%s ",&rtn);
	my_printf("out=%d ,in=%d ,count=%d ,queueSize=%d ,elementType=%d ,array=%s\r\n",MyQueue.out,MyQueue.in,MyQueue.count,MyQueue.queueSize,MyQueue.elementType,MyQueue.array);
	HAL_Delay(500);
	
	tx='4';
	my_printf("%d ",queue_Enqueue(&MyQueue,&tx));//存数据，同时打印返回值
	my_printf("out=%d ,in=%d ,count=%d ,queueSize=%d ,elementType=%d ,array=%s\r\n",MyQueue.out,MyQueue.in,MyQueue.count,MyQueue.queueSize,MyQueue.elementType,MyQueue.array);
	HAL_Delay(500);
	
	my_printf("%d ",queue_Dequeue(&MyQueue,&rtn));//取数据，同时打印返回值
	my_printf("rtn=%s ",&rtn);
	my_printf("out=%d ,in=%d ,count=%d ,queueSize=%d ,elementType=%d ,array=%s\r\n",MyQueue.out,MyQueue.in,MyQueue.count,MyQueue.queueSize,MyQueue.elementType,MyQueue.array);
	HAL_Delay(500);

实验结果

 

队列源码

最后贴出队列的源码，注：源码来自于网络，如有侵权，请联系作者删除

#include "myQueue.h"


void queue_Init(QUEUE_T * pQueue, void * pBuffer, BYTE sizeOfElements, BYTE numberOfElements)
{
  pQueue->out = 0;
  pQueue->in = 0;
  pQueue->queueSize = numberOfElements;
  pQueue->count = 0;
  pQueue->elementType = sizeOfElements;
  pQueue->array = (BYTE*)pBuffer;
}

BOOL queue_Enqueue(QUEUE_T * pQueue, void * pElement)
{
  if (pQueue->count >= pQueue->queueSize)
  {
    return FALSE;
  }
  else
  {
    BYTE i;
    BYTE* pEl = pElement;

    for (i = 0; i < pQueue->elementType; i++)
    {
      pQueue->array[ (pQueue->in)*(pQueue->elementType) + i ] = *(pEl + i);
    }

    pQueue->in = (pQueue->in + 1) % pQueue->queueSize;
    pQueue->count = pQueue->count + 1;
  }
  return TRUE;
}

BOOL queue_Dequeue(QUEUE_T * pQueue, void * pElement)
{
  if (pQueue->count <= 0)
  {
    return FALSE;
  }
  else
  {
    BYTE i;
    BYTE* pEl = pElement;

    for (i = 0; i < pQueue->elementType; i++)
    {
      *(pEl + i) = pQueue->array[(pQueue->out) * (pQueue->elementType) + i];
    }

    pQueue->out = (pQueue->out + 1) % pQueue->queueSize;
    pQueue->count = pQueue->count - 1;
  }
  return TRUE;
}

uint8_t queue_GetItemCount(QUEUE_T * pQueue)
{
  return pQueue->count;
}

#ifndef _MYQUEUE_H
#define _MYQUEUE_H


#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include "stdint.h"
#define BYTE uint8_t 
#define BOOL bool 
#define TRUE true 
#define FALSE false 
		
typedef uint8_t QElementType;

/**
 * In order to use the Queue module, a variable of this type must be declared before calling
 * \ref ZW_util_queue_Init.
 */
typedef struct
{
  uint8_t out;
  uint8_t in;
  uint8_t count;
  uint8_t queueSize;
  uint8_t elementType;
  QElementType* array;
}
QUEUE_T;

/**
 * @brief Initializes a given queue with a given buffer.
 * @param[in] pQueue Pointer to the queue to initialize.
 * @param[in] pBuffer Pointer to a buffer to initialize the queue with.
 * @param[in] sizeOfElements Size of elements in the given buffer.
 * @param[in] numberOfElements Number of elements in the given buffer.
 */
void queue_Init(QUEUE_T * pQueue, void * pBuffer, BYTE sizeOfElements, BYTE numberOfElements);

/**
 * @brief Enqueues a given element to a given queue.
 * @param[in] pQueue Pointer to a queue.
 * @param[in] pElement Pointer to an element.
 * @return TRUE if element was enqueued, FALSE otherwise.
 */
BOOL queue_Enqueue(QUEUE_T * pQueue, void * pElement);

/**
 * @brief Dequeues a given element from a given queue.
 * @param[in] pQueue Pointer to a queue.
 * @param[out] pElement Pointer to an element.
 * @return TRUE if element was dequeued, FALSE otherwise.
 */
BOOL queue_Dequeue(QUEUE_T * pQueue, void * pElement);

/**
 * @brief Get number of elements in queue.
 * @param[in] pQueue Pointer to a queue.
 * @return Number of queue elements.
 */
uint8_t queue_GetItemCount(QUEUE_T * pQueue);

#endif

嵌入式行者
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
数据结构与算法之队列与嵌入式软件的应用
weixin_38289027的博客
08-30 446
数据结构之队列篇 1 队列之特点及在嵌入式软件中的应用 队列（queue）是一个简单线性表，它是一个允许在一端进行插入操作，而在另一端进行删除操作的线性表。队列（queue）遵循先进先出（FIFO, First-In-First-Out）的特征，和**栈（LIFO, Last In First Out）**刚好相反。 主要鉴于FIFO的结构特点，在嵌入式软件应用中主要应用于异步处理的buffer，例如，在CAN或者SPI等接口在中断接收到数据，存放在队列中（入队），而实际的处理解析（出队）将在其他线程或者任
数据结构——静态队列
m0_73902371的博客
02-15 208
简要写了静态队列出队和入队功能
用数组实现队列--静态队列
fengel_cs的专栏
05-29 845
/* 一、关于静态队列的约定(目的是在C语言中描述方便) 1.定义：和栈相反，队列是一种先进先出的线性表，它只允许在表的一端进行插入，在另一端进行删除元素。在队列中，允许插入的一端叫队尾，允许删除的一端较队头，即入队只能从队尾入，出队只能从队头出。 2.初始化建空队列时，令front=rear=0；入队时，队尾指针rear增1；出队时队头指针增1。在非空队列中，队头指针front
队列-数组队列实现-DTU缓冲区原型.c
zeroboundary的专栏
07-11 3404
// 缓冲区-数组队列实现 可在VC6.0下编译通过 // 使用MTK平台做DTU产品的时候，需要将串口的数据缓存到内存，然后通过网络发送数据， // 所以要记录下来本次存入数据长度和数据内容，以便下次发往网络时可将本次存入数据整段发送出去 // 另外，MTK中，动态分配内存效率较整体分配内存稳定性差，采用数组队列形式实现 // 功能，向缓冲区读写数据 // 对外接口 dtu_buf
java 创建静态队列,队列(静态方式)
weixin_36354924的博客
03-20 298
队列是一种只允许在队尾插入元素，在队头插入元素的一种数据结构。就比如我们生活中的排队。队列最主要的是判断队空或者队满。队列的静态方式实现，利用数组设置一个循环的队列。代码如下：#include #include #include #define MaxSize 10/* run this program using the console pauser or add your own getch,...
C语言实现使用静态数组实现循环队列源码.zip
11-13
本资源“C语言实现使用静态数组实现循环队列源码.zip”提供了使用C语言编写的静态数组循环队列的实现，非常适合初学者学习和理解这一概念。 循环队列的基本思想是将一个固定大小的数组看作一个首尾相连的环形结构。...
C语言数组-C语言实现使用静态数组实现循环队列.zip
03-02
在本主题中，我们将深入探讨如何使用C语言中的静态数组来实现一个循环队列。循环队列是一种线性数据结构，它巧妙地利用了数组的特性，克服了普通队列在满时无法插入元素、空时无法删除元素的问题。 首先，了解数组...
ADS-TP:cvEB数组的实现
07-09
在高级编程语言中，如Java，数组的实现方式多样，其中一种是基于“紧凑虚拟扩展数组”（Compact Virtual Expanded Array，简称cvEB数组）的设计。这个概念常用于自定义高效的数据结构，尤其是在大型数据集处理和算法...
C语言实现使用静态数组实现循环队列
最新发布
03-07
本文将深入探讨如何使用静态数组来实现循环队列，这是一种在C语言中常见且重要的数据结构。 首先，理解循环队列的概念至关重要。循环队列是一种线性数据结构，它具有队列的基本属性——先进先出（First In First ...
aqueue-noptr:在数组上实现的就地队列，使用 BSD 许可证用 C 编写
07-11
传统的队列实现通常采用链表或动态数组，但这里我们关注的是一个特别的实现——aqueue-noptr，它使用静态数组作为基础，旨在提供更高效的内存管理和性能优化。 首先，让我们理解“就地”（in-place）这一概念。在...
嵌入式C语言那点事（二）栈与队列的实现
yuanlanjun
05-17 142
栈与队列的区别： 栈——先入后出，后入先出； 队列——先入先出，后入后出； 应用举例： 栈：函数调用时会将临时数据压栈；函数返回时再弹出来。 队列：一般，系统中的任务和消息经常使用队列。可以按任务或消息到来的先后顺序执行。 代码实现： 背景：使用C语言，在VS2008环境下，按栈与队列的原理，采用最简单易懂的方式，针对正整型（int）元素实现栈与队列。 原理：栈的存储空间使...
队列
u014694510的博客
05-29 166
队列跟栈一样，也是一种操作受限的线性表数据结构。它具有先进先出的特性，最基本的操作也是两个：入队 enqueue()，在队尾插入元素；出队 dequeue()，在队头删除元素。 顺序队列和链式队列 1、手写基于数组的实现方法：数组中的数据不连续问题如何解决。 // 用数组实现的队列 public class ArrayQueue { // 数组：items，数组大小：n pr...
嵌入式C语言入门——队列（顺序队列）
qq_35599308的博客
12-12 407
数据结构之队列顺序队列构造顺序队列顺序队列的初始化判断队列是否满判断队列是否为空顺序队列的入队顺序队列的出队顺序队列的读取 顺序队列 存放数据的队列数组当做收尾相接的表处理(对长度进行SIZE取余作为数组下标) 若定义队列数组长度为SIZE,能存放数据的只有SIZE-1个元素 队头,队尾指针从前进时从SIZE-1,直接进到0 队列满时,若rear向前进一步则会与front相遇 队头指针向前一...
嵌入式面试C集锦（7） 循环队列
muyepiao1的博客
08-17 219
//运行环境keil c51 //学习目的：循环队列的运用 /*关键算法： 在循环队列中，当队列为空时，有front=rear，而当所有队列空间全占满时， 也有front=rear。为了区别这两种情况，规定循环队列最多只能有MaxSize-1个 队列元素，当循环队列中只剩下一个空存储单元时，队列就已经满了。因此，队 列判空的条件时front=rear，而队列判满的条件时front=（rear+1）%MaxSize。 */ #include "reg51.h" #include <stdio.h&gt.
数据结构复习2-队列(c语言 数组实现)
weixin_44646468的博客
05-22 343
数据结构复习-队列(Queue）何为队列C语言 实现功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 何为队列 队列的意思，顾名思义，就像我们排队买票一样，最先来的人也最先买。 C语言 实现 使用数组实现是最简单的方法，首先需要两个
嵌入式中缓冲区队列的实现
遥远的星星
04-12 2208
在串口，IIC或SPI以及CAN等通信中，往往需要一次性发送一帧完整的数据，由于硬件发送的速度问题，硬件不能及时发送出去，就会导致数据丢失等一系列问题。通常采用建立缓冲区解决。队列可以有效的利用缓冲区空间，并且保证数据在发送和接收过程中的时序问题。现在网上有公开的队列源码，其一般由入队，出队，查询队列成员数量，创建队列，销毁队列等组成，相对比较完善，但是在串口等环境中使用存在过多的调用函数等问题。...
优先队列 c语言,最小堆 / 优先队列（C语言实现）
weixin_30291121的博客
05-19 538
最近找实习，复习下数据结构方面的内容。完全二叉树有两种形态，一种是：二叉树的所有子树要么没有孩子，要么一定有左孩子。另一种是：二叉树要么没有子树，要么一定左右子树都有。堆是一种经过排序的完全二叉树，其中任一非终端节点的数据值均不大于(或不小于)其左孩子和右孩子节点的值。最大堆和最小堆是二叉堆的两种形式。最大堆：根结点的键值是所有堆结点键值中最大者。最小堆：根结点的键值是所有堆结点键值中最小者。在优...
嵌入式系统的数据结构与算法
YellowMax
01-13 4812
嵌入式C语言数据结构之循环队列
叫我一声小明哥的博客
06-03 513
队列拥有先进先出特性，类似生活中的排队场景，多应用于缓冲区的设计等。循环队列就是当front或者rear即将产生数组越界时，将其置为0。本文用数组实现循环队列，感兴趣的朋友也可以用链表实现循环队列。以下为源码。queue.h#ifndef __QUEUE_H__ #define __QUEUE_H__ #include "stm32f10x.h" #include &lt;string.h&gt...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值