C语言队列-FIFO

最新推荐文章于 2024-07-20 17:08:18 发布
最新推荐文章于 2024-07-20 17:08:18 发布
阅读量1k 收藏 3
点赞数
分类专栏： 单片机C语言 C语言 文章标签： c语言 fpga开发 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_17208955/article/details/121694177
版权

app_FIFO.h

#include "main.h"
#include "app_FIFO.h"

#define MIN(a, b) ((a) < (b) ? (a) : (b))
#define MAX(a, b) ((a) < (b) ? (b) : (a))

#ifndef TRUE
#define TRUE  1
#endif
#ifndef FALSE
#define FALSE 0
#endif

#define SUCCESS				1
#define ERROR_NO_MEM		    0
#define ERROR_INVALID_LENGTH    		0


#define FIFO_LENGTH()           (p_fifo->Count)
#define IS_POWER_OF_TWO(SIZE)   is_power_of_2(SIZE)

/* 
判断数字是否是2的次幂
 */
#ifdef FIFI_2_POWER
static __INLINE uint8_t is_power_of_2(uint16_t n)
{
	return (n != 0 && ((n & (n - 1)) == 0));
}
#endif

/* 
计算队列的长度
 */
static __INLINE uint16_t fifo_length(FIFO_T * p_fifo)
{
    // uint16_t tmp = p_fifo->read_pos;
    // return p_fifo->write_pos - tmp;

    return p_fifo->Count;
}
/* 队列未使用的空间 */
static __INLINE uint16_t fifo_unused(FIFO_T *fifo)
{
#ifdef FIFI_2_POWER
	return (fifo->buf_size_mask + 1) - (fifo->write_pos - fifo->read_pos);
#else
    return fifo->write_pos - fifo->read_pos;
#endif
    
}


/**
 * @brief	写新数据到缓冲区
 * @param	p_fifo	: 指向队列的的实例
 * @param	m_pBuf: 队列指向的缓冲区
 * @param   buf_size: 队列的大小
 * @return	>0:成功 ; 0:失败
 */
int  FIFO_Init( FIFO_T* p_fifo ,uint8_t* m_pBuf ,uint16_t buf_size)
{
	if(!m_pBuf )return ERROR_NO_MEM;
	if(!buf_size)return ERROR_NO_MEM;

#ifdef FIFI_2_POWER
    // Check that the buffer size is a power of two.
    if (!IS_POWER_OF_TWO(buf_size))
    {
        return ERROR_INVALID_LENGTH;
    }

    /* 到这一步，buf_size_mask应该是除了最高bit位是0，其它全是1 */
    p_fifo->buf_size_mask = buf_size - 1;
#endif

	p_fifo->p_buf = m_pBuf;					/*缓冲区指针 */
	p_fifo->buf_size = buf_size;	

	p_fifo->read_pos = 0;
	p_fifo->write_pos = 0;			
	p_fifo->Count = 0;

    return SUCCESS;
}


//----------------static-------------------------------------------------------------
/**
 * @brief	查看指定位置的数据
 * @param	p_fifo	: 指向队列的的实例
 * @param	index: 队列的索引(下标)
 * @param   p_byte: 接收查看的数据指针
 */
static __INLINE void fifo_peek(FIFO_T * p_fifo, uint16_t index, uint8_t * p_byte)
{
#ifdef FIFI_2_POWER
    *p_byte = p_fifo->p_buf[(p_fifo->read_pos + index) & p_fifo->buf_size_mask];
#else
    
    *p_byte = p_fifo->p_buf[ index ];

#endif

}

/**
* @brief	从队列里取出一个数据，新读数据指针
* @param	p_fifo	: 指向队列的的实例
* @param   p_byte: 存放取出的数据
*/
static __INLINE void fifo_get(FIFO_T * p_fifo, uint8_t * p_byte)
{
//    fifo_peek(p_fifo, 0, p_byte);
	*p_byte = p_fifo->p_buf[ p_fifo->read_pos ];
	
    // p_fifo->read_pos++;
	p_fifo->read_pos = (++p_fifo->read_pos)%p_fifo->buf_size;
	p_fifo->Count -=1;

}


/**
* @brief	向队列里写入一个数据，新写数据指针
* @param	p_fifo	: 指向队列的的实例
* @param   byte: 要写入的数据
*/
static __INLINE void fifo_Input(FIFO_T * p_fifo, uint8_t byte)
{
#ifdef FIFI_2_POWER
    p_fifo->p_buf[p_fifo->write_pos & p_fifo->buf_size_mask] = byte;
#else
    p_fifo->p_buf[p_fifo->write_pos ] = byte;
#endif
    // p_fifo->write_pos++;
    p_fifo->write_pos = (++p_fifo->write_pos)%p_fifo->buf_size;
	// if(++p_fifo->write_pos >=p_fifo->buf_size)
	// {
	// 	p_fifo->write_pos =p_fifo->buf_size;
	// }
	p_fifo->Count+=1;
}

//====================================================================
/**
* @brief	如果队列还没满，就写入一个数据
* @param	p_fifo	: 指向队列的的实例
* @param   byte: 要写入的数据
* @return	>0:成功 ; =0:失败
* @remark  会更新写数据指针
*/
int app_fifo_Input(FIFO_T * p_fifo, uint8_t byte)
{
#ifdef FIFI_2_POWER
    if (FIFO_LENGTH() <= p_fifo->buf_size_mask)
#else
    if (FIFO_LENGTH() <= p_fifo->buf_size)
#endif
    {
        fifo_Input(p_fifo, byte);
        return SUCCESS;
    }

    return ERROR_NO_MEM;
}


/**
 * @brief	如果队列长度不为0，就取出一个数据
 * @param	p_fifo	: 指向队列的的实例
 * @param   p_byte: 接收查看的数据指针
 * @return	>0:成功 ; =0:失败
 * @remark  会更新读数据指针
 */
int app_fifo_get(FIFO_T * p_fifo, uint8_t * p_byte)
{
    if (FIFO_LENGTH() != 0)
    {
        fifo_get(p_fifo, p_byte);
        return SUCCESS;
    }

    return ERROR_NO_MEM;

}


/**
 * @brief	查看指定位置的数据
 * @param	p_fifo	: 指向队列的的实例
 * @param	index: 队列的索引(下标)
 * @param   p_byte: 接收查看的数据指针
 * @return	>0:成功 ; =0:失败
 * @remark  不会更新数据指针
 */
int app_fifo_peek(FIFO_T * p_fifo, uint16_t index, uint8_t * p_byte)
{
    if (FIFO_LENGTH() > index)
    {
        fifo_peek(p_fifo, index, p_byte);
        return SUCCESS;
    }

    return ERROR_NO_MEM;
}

//=============================================================

/**
 * @brief	写新数据到缓冲区
 * @param	p_fifo	: 指向队列的的实例
 * @param	m_pBuf: 队列指向的缓冲区
 * @param   p_size: 传入要读取的长度，返回读成功的长度，必须是变量(非常量)
 * @return	>0:成功 ; 0:失败
 */
int app_fifo_read(FIFO_T * p_fifo, uint8_t * p_byte_array, uint16_t * p_size)
{

    if(!p_fifo )return ERROR_NO_MEM;
    if(!p_size)return ERROR_NO_MEM;

    const uint16_t byte_count    = FIFO_LENGTH();//队列的长度
    const uint16_t requested_len = (*p_size);//取出的长度
    uint16_t       index         = 0;
    uint16_t       read_size     = MIN(requested_len, byte_count);//能取出的长度

    (*p_size) = byte_count;

    // Check if the FIFO is empty.
    // if (byte_count == 0)
    if (p_fifo->Count==0)
    {
        return ERROR_NO_MEM;
    }

    // Check if application has requested only the size.
    if (p_byte_array == NULL)
    {
        return ERROR_NO_MEM;
    }

    // Fetch bytes from the FIFO.
    while (index < read_size)
    {
        fifo_get(p_fifo, &p_byte_array[index++]);
    }

    (*p_size) = read_size;

    return SUCCESS;
}


/**
 * @brief	写新数据到缓冲区
 * @param	p_fifo	: 指向环形缓冲区的实例
 * @param	p_byte_array: 指向要写入环形缓冲区的数据地址
 * @param   p_size: 要写入前传入的数量,成功后写入的数量，必须是变量的地址
 * @return	1:成功写入; 0:写入失败 ;
 * @remark  此功能会更新队列,p_size返回成功写入的数量
 */
int app_fifo_write(FIFO_T * p_fifo, uint8_t const * p_byte_array, uint16_t * p_size)
{
    if(!p_fifo)return ERROR_NO_MEM;
    if(!p_size)return ERROR_NO_MEM;
#ifdef FIFI_2_POWER
    const uint16_t available_count = p_fifo->buf_size_mask - fifo_length(p_fifo) + 1;
#else
    const uint16_t available_count = p_fifo->buf_size - FIFO_LENGTH() ;
#endif
    const uint16_t requested_len   = (*p_size);
    uint16_t       index           = 0;
    uint16_t       write_size      = MIN(requested_len, available_count);

    (*p_size) = available_count;

    // Check if the FIFO is FULL.
    // if (available_count == 0)
    if (p_fifo->Count==p_fifo->buf_size)
    {
        return ERROR_NO_MEM;
    }

    // Check if application has requested only the size.
    if (p_byte_array == NULL)
    {
        return ERROR_NO_MEM;
    }

    //Fetch bytes from the FIFO.
    while (index < write_size)
    {
        fifo_Input(p_fifo, p_byte_array[index++]);
    }

    (*p_size) = write_size;

    return SUCCESS;
}

app_FIFO.c


#include "main.h"
#include "app_FIFO.h"

#define MIN(a, b) ((a) < (b) ? (a) : (b))
#define MAX(a, b) ((a) < (b) ? (b) : (a))

#ifndef TRUE
#define TRUE  1
#endif
#ifndef FALSE
#define FALSE 0
#endif

#define SUCCESS				1
#define ERROR_NO_MEM		    0
#define ERROR_INVALID_LENGTH    		0


#define FIFO_LENGTH()           (p_fifo->Count)
#define IS_POWER_OF_TWO(SIZE)   is_power_of_2(SIZE)

/* 
判断数字是否是2的次幂
 */
#ifdef FIFI_2_POWER
static __INLINE uint8_t is_power_of_2(uint16_t n)
{
	return (n != 0 && ((n & (n - 1)) == 0));
}
#endif

/* 
计算队列的长度
 */
static __INLINE uint16_t fifo_length(FIFO_T * p_fifo)
{
    // uint16_t tmp = p_fifo->read_pos;
    // return p_fifo->write_pos - tmp;

    return p_fifo->Count;
}
/* 队列未使用的空间 */
static __INLINE uint16_t fifo_unused(FIFO_T *fifo)
{
#ifdef FIFI_2_POWER
	return (fifo->buf_size_mask + 1) - (fifo->write_pos - fifo->read_pos);
#else
    return fifo->write_pos - fifo->read_pos;
#endif
    
}


/**
 * @brief	写新数据到缓冲区
 * @param	p_fifo	: 指向队列的的实例
 * @param	m_pBuf: 队列指向的缓冲区
 * @param   buf_size: 队列的大小
 * @return	>0:成功 ; 0:失败
 */
int  FIFO_Init( FIFO_T* p_fifo ,uint8_t* m_pBuf ,uint16_t buf_size)
{
	if(!m_pBuf )return ERROR_NO_MEM;
	if(!buf_size)return ERROR_NO_MEM;

#ifdef FIFI_2_POWER
    // Check that the buffer size is a power of two.
    if (!IS_POWER_OF_TWO(buf_size))
    {
        return ERROR_INVALID_LENGTH;
    }

    /* 到这一步，buf_size_mask应该是除了最高bit位是0，其它全是1 */
    p_fifo->buf_size_mask = buf_size - 1;
#endif

	p_fifo->p_buf = m_pBuf;					/*缓冲区指针 */
	p_fifo->buf_size = buf_size;	

	p_fifo->read_pos = 0;
	p_fifo->write_pos = 0;			
	p_fifo->Count = 0;

    return SUCCESS;
}


//----------------static-------------------------------------------------------------
/**
 * @brief	查看指定位置的数据
 * @param	p_fifo	: 指向队列的的实例
 * @param	index: 队列的索引(下标)
 * @param   p_byte: 接收查看的数据指针
 */
static __INLINE void fifo_peek(FIFO_T * p_fifo, uint16_t index, uint8_t * p_byte)
{
#ifdef FIFI_2_POWER
    *p_byte = p_fifo->p_buf[(p_fifo->read_pos + index) & p_fifo->buf_size_mask];
#else
    
    *p_byte = p_fifo->p_buf[ index ];

#endif

}

/**
* @brief	从队列里取出一个数据，新读数据指针
* @param	p_fifo	: 指向队列的的实例
* @param   p_byte: 存放取出的数据
*/
static __INLINE void fifo_get(FIFO_T * p_fifo, uint8_t * p_byte)
{
//    fifo_peek(p_fifo, 0, p_byte);
	*p_byte = p_fifo->p_buf[ p_fifo->read_pos ];
	
    // p_fifo->read_pos++;
	p_fifo->read_pos = (++p_fifo->read_pos)%p_fifo->buf_size;
	p_fifo->Count -=1;

}


/**
* @brief	向队列里写入一个数据，新写数据指针
* @param	p_fifo	: 指向队列的的实例
* @param   byte: 要写入的数据
*/
static __INLINE void fifo_Input(FIFO_T * p_fifo, uint8_t byte)
{
#ifdef FIFI_2_POWER
    p_fifo->p_buf[p_fifo->write_pos & p_fifo->buf_size_mask] = byte;
#else
    p_fifo->p_buf[p_fifo->write_pos ] = byte;
#endif
    // p_fifo->write_pos++;
    p_fifo->write_pos = (++p_fifo->write_pos)%p_fifo->buf_size;
	// if(++p_fifo->write_pos >=p_fifo->buf_size)
	// {
	// 	p_fifo->write_pos =p_fifo->buf_size;
	// }
	p_fifo->Count+=1;
}

//====================================================================
/**
* @brief	如果队列还没满，就写入一个数据
* @param	p_fifo	: 指向队列的的实例
* @param   byte: 要写入的数据
* @return	>0:成功 ; =0:失败
* @remark  会更新写数据指针
*/
int app_fifo_Input(FIFO_T * p_fifo, uint8_t byte)
{
#ifdef FIFI_2_POWER
    if (FIFO_LENGTH() <= p_fifo->buf_size_mask)
#else
    if (FIFO_LENGTH() <= p_fifo->buf_size)
#endif
    {
        fifo_Input(p_fifo, byte);
        return SUCCESS;
    }

    return ERROR_NO_MEM;
}


/**
 * @brief	如果队列长度不为0，就取出一个数据
 * @param	p_fifo	: 指向队列的的实例
 * @param   p_byte: 接收查看的数据指针
 * @return	>0:成功 ; =0:失败
 * @remark  会更新读数据指针
 */
int app_fifo_get(FIFO_T * p_fifo, uint8_t * p_byte)
{
    if (FIFO_LENGTH() != 0)
    {
        fifo_get(p_fifo, p_byte);
        return SUCCESS;
    }

    return ERROR_NO_MEM;

}


/**
 * @brief	查看指定位置的数据
 * @param	p_fifo	: 指向队列的的实例
 * @param	index: 队列的索引(下标)
 * @param   p_byte: 接收查看的数据指针
 * @return	>0:成功 ; =0:失败
 * @remark  不会更新数据指针
 */
int app_fifo_peek(FIFO_T * p_fifo, uint16_t index, uint8_t * p_byte)
{
    if (FIFO_LENGTH() > index)
    {
        fifo_peek(p_fifo, index, p_byte);
        return SUCCESS;
    }

    return ERROR_NO_MEM;
}

//=============================================================

/**
 * @brief	写新数据到缓冲区
 * @param	p_fifo	: 指向队列的的实例
 * @param	m_pBuf: 队列指向的缓冲区
 * @param   p_size: 传入要读取的长度，返回读成功的长度，必须是变量(非常量)
 * @return	>0:成功 ; 0:失败
 */
int app_fifo_read(FIFO_T * p_fifo, uint8_t * p_byte_array, uint16_t * p_size)
{

    if(!p_fifo )return ERROR_NO_MEM;
    if(!p_size)return ERROR_NO_MEM;

    const uint16_t byte_count    = FIFO_LENGTH();//队列的长度
    const uint16_t requested_len = (*p_size);//取出的长度
    uint16_t       index         = 0;
    uint16_t       read_size     = MIN(requested_len, byte_count);//能取出的长度

    (*p_size) = byte_count;

    // Check if the FIFO is empty.
    // if (byte_count == 0)
    if (p_fifo->Count==0)
    {
        return ERROR_NO_MEM;
    }

    // Check if application has requested only the size.
    if (p_byte_array == NULL)
    {
        return ERROR_NO_MEM;
    }

    // Fetch bytes from the FIFO.
    while (index < read_size)
    {
        fifo_get(p_fifo, &p_byte_array[index++]);
    }

    (*p_size) = read_size;

    return SUCCESS;
}


/**
 * @brief	写新数据到缓冲区
 * @param	p_fifo	: 指向环形缓冲区的实例
 * @param	p_byte_array: 指向要写入环形缓冲区的数据地址
 * @param   p_size: 要写入前传入的数量,成功后写入的数量，必须是变量的地址
 * @return	1:成功写入; 0:写入失败 ;
 * @remark  此功能会更新队列,p_size返回成功写入的数量
 */
int app_fifo_write(FIFO_T * p_fifo, uint8_t const * p_byte_array, uint16_t * p_size)
{
    if(!p_fifo)return ERROR_NO_MEM;
    if(!p_size)return ERROR_NO_MEM;
#ifdef FIFI_2_POWER
    const uint16_t available_count = p_fifo->buf_size_mask - fifo_length(p_fifo) + 1;
#else
    const uint16_t available_count = p_fifo->buf_size - FIFO_LENGTH() ;
#endif
    const uint16_t requested_len   = (*p_size);
    uint16_t       index           = 0;
    uint16_t       write_size      = MIN(requested_len, available_count);

    (*p_size) = available_count;

    // Check if the FIFO is FULL.
    // if (available_count == 0)
    if (p_fifo->Count==p_fifo->buf_size)
    {
        return ERROR_NO_MEM;
    }

    // Check if application has requested only the size.
    if (p_byte_array == NULL)
    {
        return ERROR_NO_MEM;
    }

    //Fetch bytes from the FIFO.
    while (index < write_size)
    {
        fifo_Input(p_fifo, p_byte_array[index++]);
    }

    (*p_size) = write_size;

    return SUCCESS;
}

测试程序
app_FIFO_test.h

#include "main.h"
#include "app_FIFO.h"
#include "stdio.h"

#define BUFSIZE			20
#define FIFO_BUFSIZE	10

uint8_t wBuf[BUFSIZE];
uint8_t rBuf[BUFSIZE];
uint8_t testdat[30];
uint8_t* pBuf;



FIFO_T txfifo;
uint16_t num=0;

void FIFO_tsetMain()
{
	pBuf=rBuf;
	for (size_t i = 0; i < BUFSIZE*2; i++)
		testdat[i]=i+1;

	FIFO_Init(&txfifo,wBuf,FIFO_BUFSIZE);

	uint8_t a=99;
	/*向 wBuf 写入99
	 write_pos 是1*/
	app_fifo_Input(&txfifo,a);
	/*向指向的队列写入3个数据，向 wBuf 写入1,2,3
	 write_pos 是4
	*/
	num=3;
	app_fifo_write(&txfifo,testdat,&num);

	/*向队列写入10个数据，已经超过队列的大小
	已经写入了3个这里其实只能写入6个，num将返回6，
	write_pos 是0
	*/
	num=10;
	if(app_fifo_write(&txfifo,testdat,&num) )
	 printf("成功写入 %d 个\r\n",num);

	/* 再向队列写入3个，
	队列已满，写入失败
	 */
	num=3;
	if(!app_fifo_write(&txfifo,testdat,&num) )
		printf("写入失败\r\n");

	/*读取一个数
	读数据指针是 1，
	写数据指针是 0 
	*/
	if(app_fifo_get(&txfifo,pBuf) )
	{
		printf("取出一个数 %d\r\n",*pBuf);
		pBuf+=1;
	}
	
	/* 
	查看位置是3的数据
	 */
	uint8_t pos =3,r=0;
	if(app_fifo_peek(&txfifo,pos,&r) )
		printf("位置%d的数是 %d\r\n",pos,r);

	/*
	取出3个数据，放在 rBuf[]中，
	读数据指针是 4，
	写数据指针是 0
	  */
	uint16_t n=3;
	if(app_fifo_read(&txfifo,pBuf,&n) )
	{
		printf("成功取出 %d 个\r\n",n);
		printf("读数据指针 %d 个\r\n",txfifo.read_pos);
		printf("写数据指针 %d 个\r\n",txfifo.write_pos);
		pBuf+=n;
	}

	/*
	取出10个数据，放在 rBuf[]中，
	实际可读取空间只有6个，
	读数据指针是 6+4，
	写数据指针是 0
	  */
	n=10;
	if(app_fifo_read(&txfifo,pBuf,&n) )
	{
		printf("成功取出 %d 个\r\n",n);
		printf("读数据指针 %d 个\r\n",txfifo.read_pos);
		printf("写数据指针 %d 个\r\n",txfifo.write_pos);
		pBuf+=n;
	}
//---------------------------------------------------------------

	num=7;
	if(app_fifo_write(&txfifo,testdat,&num))
	{
		printf("成功写入%d个",num);
		printf("读数据指针 %d 个\r\n",txfifo.read_pos);
		printf("写数据指针 %d 个\r\n",txfifo.write_pos);

	}

	num=3;
	pBuf=rBuf;
	if(app_fifo_read(&txfifo,pBuf,&num) )
	{
		printf("成功取出 %d 个\r\n",num);
		printf("读数据指针 %d 个\r\n",txfifo.read_pos);
		printf("写数据指针 %d 个\r\n",txfifo.write_pos);
		pBuf+=num;
	}

}
乱码笔记
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
资料结构使用C语言Data-Structures-Using-CPPT实用.ppt
11-02
5. **队列(Queue)**：先进先出（FIFO）的数据结构，适用于模拟线性处理过程，如任务调度。 6. **树状结构(Tree)**：模仿自然界中的树形结构，用于表示层次关系，如文件系统、二叉搜索树等。 7. **图形结构(Graph)*...
queue_C语言消息队列_
10-04
在队列中，消息按照先进先出（FIFO）的原则进行处理。发送进程将消息放入队列，而接收进程从队列中取出消息。这种设计使得消息发送和接收可以独立进行，提高了系统的并发性和可靠性。 在C语言中，我们可以创建一个...
C语言--队列（FIFO）
zwb_578209160的博客
05-31 5191
1、队列的定义 队列是一种先进先出（FIFO）的线性表，它只允许在表的一端进行插入，而在另一端删除元素。这和我们日常生活中排队是一样的，最早进入队列的元素最早离开。 在队列中，允许插入的一端叫做队尾（rear），允许删除的一端则称为队头（front）。 2、队列的基本操作 3、队列的分类 队列包含两种形式：链队列和顺序队列。 3.1、链队列 用链表表示的队列简称为链队列。一个链队列包含两个分别指向队头和队尾的指针（分别成为头指针和尾指针）。 3.1.1 单链队列的定义： //队.
c语言队列实现FIFO
royal_cf的博客
10-25 636
使用c语言实现队列，最多8个数据。
C语言环形队列缓冲-FIFO_RingBuffer
17208955的博客
12-03 1547
C语言环形队列缓冲-FIFO_RingBuffer
C语言--队列的创建及使用详解
2301_77637225的博客
11-25 2511
队列结构是一种变相的链表结构，相比于单独的链表，它多了一个包含队头指针和队尾指针的结构体，但其实质上，仍旧属于链表结构。只要掌握了链表结构，队列结构的实现会变得比较简单。
c语言 两字节fifo,c语言实现队列fifo
weixin_36406678的博客
05-17 410
fifo在嵌入式里面用的相当多，一般用到的通讯如iic, spi, uart，都会有一个fifo。fifo实现起来也比较简单，一般就是用一个数组，设置两个指针，读指针和写指针。相比之前的filo实现不同，这里我把错误标志直接设置在了fifo对象里面，这样也方便在应用中使用多个fifo而不会相互干扰。main.c#include #include "cfifo.h"int main(void){st...
c语言链表和fifo,FIFO 队列的链表和数组实现
weixin_34274163的博客
05-24 553
FIFO 队列的链表和数组实现数据结构FIFO (First-in, First-out，先进先出)队列：当执行delete操作时删除那些呆在队列中时间最长的元素。FIFO 队列是这样一个ADT，包含两个基本操作：插入(put)一个新的项、删除(get)一个最早插入的项。一、FIFO队列的链表实现FIFO 队列和下堆栈的区别在于新项的插入是在尾部，而不是在头部。因此实现程序要保存一个指向链表最后一...
【数据结构初阶】六、线性表中的队列（C语言 -- 链式结构实现队列）
正在努力学C呀！（要学好久呢......）
09-29 3472
线性表中的队列（链式结构实现队列）：1 . 队列（Queue）；2 . 队列的实现 ； 3 . 对应代码
C语言 队列(FIFO) 生产消费模型
嫦娥妹妹等等我的博客
02-11 430
此模型层面维度被压缩在 fcntl.h 没有使用高阶知识点 方便读者彻底领悟fcntl.h。根据gpt4 阿里千问修正细节 可编译为两个文件直接运行 春节尽力版。问GPT4回... 问阿里千问回... 腾讯百度不问没用。
力扣（leetcode）-- 设计循环队列--c语言--数据结构oj题-保姆级分析教程
最新发布
2303_77756141的博客
07-20 1188
本文章主在保姆级别分析实现循环队列这道题数据结构oj题，涵盖大量画图，便于理解。
FIFO_c语言fifo_fifo_
10-01
在实际应用中，C语言实现的FIFO可以广泛应用于各种场景，例如多线程通信中的消息队列、数据缓存管理，或者在硬件接口（如串口通信）的数据传输中。通过自定义大小，可以根据具体需求调整FIFO的存储容量，以优化内存...
queue_C语言队列_
10-02
在IT领域，队列是一种基本的数据结构，它遵循“先进先出”（FIFO, First In First Out）的原则。在C语言中，实现队列通常需要我们手动管理内存，这涉及到了指针、动态内存分配以及内存释放等概念。本文将深入探讨...
队列_队列、C语言_
10-02
队列是一种特殊的线性数据结构，它遵循“先进先出”（FIFO，First In First Out）的原则。在计算机科学中，队列被广泛应用于任务调度、数据缓冲、多线程通信等多个领域。C语言虽然没有内置的队列类型，但我们可以...
DMX512协议解析
17208955的博客
04-02 9778
1、 DMX512协议特点： （1）采用RS-485总线收发器，差分电压进行传输的，抗干扰能力强，信号可以进行长距离传输； （2）不论调光数据是否需要改变，主机都必须发送控制信号。 （3）由于数据帧之间的时间小于1s，所以在1s内没有收到新的数据帧，说明信号已经丢失； （4）因为是数据是调光用的，使用环境是不做安全要求的设备， 并且是不间断传输的，所以不需要复杂的校验。 2、 波特率：250000 一个bit位 4us 8个位(Slot:x) 4*8=32us，x是从1到512 如图： 3、下面是一帧数
DMX协议和RDM协议
17208955的博客
09-24 9480
DMX协议和RDM协议 1 DMX协议 1、 DMX512协议特点： （1）采用RS-485总线收发器，差分电压进行传输的，抗干扰能力强，信号可以进行长距离传输； （2）不论调光数据是否需要改变，主机都必须发送控制信号。 （3）由于数据帧之间的时间小于1s，所以在1s内没有收到新的数据帧，说明信号已经丢失； （4）因为是数据是调光用的，使用环境是不做安全要求的设备， 并且是不间断传输的，所以不需要复杂的校验。 2、 波特率：250000 一个bit位 4us 8个位(Slot:x) 4*8=32us，x
STM32 跳转系统BootLoader
17208955的博客
09-24 5695
STM32 跳转系统BootLoader STM32 进入系统 bootLoader 主要有两种方法： （1）一种是设置 boot 引脚，进入系统 bootLoader。 （2） 一种是应用程序跳转到系统 bootLoader。 串口1配置如下： 使用LL库可以使生成的代码能小一点。 GPIO使用HAL库可以打开HAL库定义，如果使用Flash库函数时就要打开HAL库，因为flash没有LL库。 boot.c源码如下： #include "main.h" #include "boot.h" #d
单路D触发器做自锁开关
17208955的博客
04-12 5069
1. 单路D型触发器如图 2. 功能图 3.引脚信息 4.真值表 5.仿真原理图， 单路D触发器只有一个D和Q，无Q‾\overline{\text{Q}}Q​，仿真图中无单路用多路代替。 1.初始上电状态 2.按按键
《数据结构》C语言版-李宛洲著
队列部分，解释了其先进先出（FIFO）的性质，队列结构以及在实际问题中的应用，例如模拟打印机队列。 对于非线性数据结构，主要讨论了树。书中涵盖了树的基本概念、术语，如内部节点、叶子节点的存储结构。接着，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值