C/C++ FIFO queue - 先进先出队列

最新推荐文章于 2025-02-18 07:20:45 发布
最新推荐文章于 2025-02-18 07:20:45 发布
阅读量6k 收藏 10
点赞数 2
分类专栏： C++ tmp 文章标签： C/C++ FIFO queue - 队列 先进先出
世上没有白读的书，每一页都算数。
本文链接：https://blog.csdn.net/chengyq116/article/details/114055277
版权
本文围绕C/C++实现先进先出队列展开。介绍了队列是操作受限的线性表，有入队、出队操作，遵循先进先出原则。还阐述了三种实现方式，包括取出数据后移动元素、记录队首队尾位置、循环队列，最后提及用带头节点的双向循环链表实现队列。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

C/C++ FIFO queue - 先进先出队列

队列是一种特殊的线性表，只允许在表的前端 (front) 进行删除操作，而在表的后端 (rear) 进行插入操作。队列和栈都是操作受限制的线性表。队列中没有元素时，称为空队列。

进行插入操作的端称为队尾 - rear - tail - insert
进行删除操作的端称为队头 - front - head - delete

在队列中插入一个队列元素称为入队，从队列中删除一个队列元素称为出队。队列只允许在一端插入，在另一端删除，所以只有最早进入队列的元素才能最先从队列中删除，故队列又称为先进先出 (FIFO，first in first out) 线性表。

在这里插入图片描述

1. C/C++ FIFO queue

实现 1
取出第一个数据，后面的数据向前移动 (队首位置不会改变)。思想简单，但是效率低。
在这里插入图片描述
实现 2
记录队首和队尾位置。效率高，但是占用内存较大。
在这里插入图片描述
实现 3 - 循环队列
将数组当做一个首尾相连的圆环，删除元素时将队首标志往后移动，添加元素时若数组尾部已经没有空间，则考虑数组头部的空间是否空闲。如果空闲，则在数组头部进行插入。效率高，内存固定，但是思想较复杂。
在这里插入图片描述

2. 带头节点的双向循环链表实现队列 (FIFO queue)

//============================================================================
// Name        : FIFO queue - doubly linked list
// Author      : Yongqiang Cheng
// Version     : Version 1.0.0
// Copyright   : Copyright (c) 2019 Yongqiang Cheng
// Description : Hello World in C++, Ansi-style
//============================================================================

#ifndef _CRT_SECURE_NO_WARNINGS
#define _CRT_SECURE_NO_WARNINGS
#endif

#define MAX_NODE_LEN 401
#define NULL 0

#include <stdio.h>

typedef struct NODE {
	int data;
	struct NODE *prev;
	struct NODE *next;
} Node;

typedef struct QUEUE {
	struct NODE head;
	int count;
} Queue;

Node node_array[MAX_NODE_LEN];
int node_array_idx = 0;

void insert_first(Node *head, Node *node)
{
	node->next = head->next;
	node->prev = head;

	// equality: head->next->prev = node;
	node->next->prev = node;
	head->next = node;
}

void delete_node(const Node *node)
{
	Node *prev_node = node->prev;
	Node *next_node = node->next;
	// current node - node

	prev_node->next = next_node;
	next_node->prev = prev_node;
}

void delete_node_v1(const Node *node)
{
	// current node - node

	node->prev->next = node->next;
	node->next->prev = node->prev;
}

void delete_node_v2(Node *node)
{
	// current node - node

	node->prev->next = node->next;
	node->next->prev = node->prev;

	node->prev = node->next = node;
}

void init_queue(Queue *queue)
{
	(queue->head).prev = (queue->head).next = &(queue->head);
	queue->count = 0;
}

void in_queue(Queue *queue, Node *node)
{
	insert_first(&(queue->head), node);
	queue->count += 1;
}

Node* out_queue(Queue *queue)
{
	if (queue->count <= 0)
	{
		return NULL;
	}

	Node *ret = (queue->head).prev;
	delete_node(ret);
	queue->count -= 1;

	return ret;
}

void display(const Node *head)
{
	int n = 1;

	Node *node = head->next;
	while (node != head)
	{
		printf("node %d: %d\n", n, node->data);
		++n;
		node = node->next;
	}
}

void display_v1(const Node *head)
{
	int n = 1;

	Node *node = head->prev;
	while (node != head)
	{
		printf("node %d: %d\n", n, node->data);
		++n;
		node = node->prev;
	}
}

int main()
{
	// 头节点 (非头指针)
	Queue queue_data;

	init_queue(&queue_data);

	for (int i = 0; i < MAX_NODE_LEN; ++i)
	{
		node_array[i].prev = NULL;
		node_array[i].next = NULL;
		node_array[i].data = 0;
	}

	// insert 0
	node_array[0].data = 0;
	in_queue(&queue_data, &(node_array[0]));

	// insert 2
	node_array[2].data = 2;
	in_queue(&queue_data, &(node_array[2]));

	// insert 4
	node_array[4].data = 4;
	in_queue(&queue_data, &(node_array[4]));

	// insert 6
	node_array[6].data = 6;
	in_queue(&queue_data, &(node_array[6]));

	// insert 8
	node_array[8].data = 8;
	in_queue(&queue_data, &(node_array[8]));

	display(&(queue_data.head));
	printf("node number = %d\n", queue_data.count);

	// insert 10
	node_array[10].data = 10;
	in_queue(&queue_data, &(node_array[10]));
	printf("\ninqueue data %d:\n", 10);

	display(&(queue_data.head));
	printf("node number = %d\n", queue_data.count);

	for (int i = 0; i < 4; ++i) {
		Node *node = out_queue(&queue_data);
		if (node != NULL)
		{
			printf("\noutqueue data = %d\n", node->data);
		}

		display(&(queue_data.head));
		printf("node number = %d\n", queue_data.count);
	}

	// insert 12
	node_array[12].data = 12;
	in_queue(&queue_data, &(node_array[12]));
	printf("\ninqueue data %d:\n", 12);

	display(&(queue_data.head));
	printf("node number = %d\n", queue_data.count);

	// insert 14
	node_array[14].data = 14;
	in_queue(&queue_data, &(node_array[14]));
	printf("\ninqueue data %d:\n", 14);

	display(&(queue_data.head));
	printf("node number = %d\n", queue_data.count);

	// insert 16
	node_array[16].data = 16;
	in_queue(&queue_data, &(node_array[16]));
	printf("\ninqueue data %d:\n", 16);

	display(&(queue_data.head));
	printf("node number = %d\n", queue_data.count);

	for (int i = 0; i < 2; ++i) {
		Node *node = out_queue(&queue_data);
		if (node != NULL)
		{
			printf("\noutqueue data = %d\n", node->data);
		}

		display(&(queue_data.head));
		printf("node number = %d\n", queue_data.count);
	}

	// insert 18
	node_array[18].data = 18;
	in_queue(&queue_data, &(node_array[18]));
	printf("\ninqueue data %d:\n", 18);

	display(&(queue_data.head));
	printf("node number = %d\n", queue_data.count);

	return 0;
}


node 1: 8
node 2: 6
node 3: 4
node 4: 2
node 5: 0
node number = 5

inqueue data 10:
node 1: 10
node 2: 8
node 3: 6
node 4: 4
node 5: 2
node 6: 0
node number = 6

outqueue data = 0
node 1: 10
node 2: 8
node 3: 6
node 4: 4
node 5: 2
node number = 5

outqueue data = 2
node 1: 10
node 2: 8
node 3: 6
node 4: 4
node number = 4

outqueue data = 4
node 1: 10
node 2: 8
node 3: 6
node number = 3

outqueue data = 6
node 1: 10
node 2: 8
node number = 2

inqueue data 12:
node 1: 12
node 2: 10
node 3: 8
node number = 3

inqueue data 14:
node 1: 14
node 2: 12
node 3: 10
node 4: 8
node number = 4

inqueue data 16:
node 1: 16
node 2: 14
node 3: 12
node 4: 10
node 5: 8
node number = 5

outqueue data = 8
node 1: 16
node 2: 14
node 3: 12
node 4: 10
node number = 4

outqueue data = 10
node 1: 16
node 2: 14
node 3: 12
node number = 3

inqueue data 18:
node 1: 18
node 2: 16
node 3: 14
node 4: 12
node number = 4
请按任意键继续. . .

References

C/C++ 队列queue算法详解及源码
希望我的博客，能帮上你解决学习中工作中所遇到的问题
06-27 2458
队列（Queue）是一种常用的数据结构，它采用先进先出（First-In-First-Out, FIFO）的原则来管理数据。队列算法的基本操作包括入队（enqueue）、出队（dequeue）和判空（empty）。队列算法的基本操作包括入队（enqueue）、出队（dequeue）和判空（empty）。队列算法的基本操作包括入队（enqueue）、出队（dequeue）和判空（empty）。队列算法的基本操作包括入队（enqueue）、出队（dequeue）和判空（empty）。
C++实现先进先出（FIFO）功能
PixelLogic的博客
09-12 757
在计算机科学中，先进先出（First-In-First-Out，FIFO）是一种常见的数据结构和算法。在这篇文章中，我们将探讨如何使用C++编程语言实现FIFO功能，并提供相应的源代码。FIFO是一种队列（Queue）数据结构，其中第一个进入队列的元素是第一个被处理或删除的元素。函数可以检查队列是否为空，如果为空，则输出"Queue is empty.“，否则输出"Queue is not empty.”。首先访问的元素是10，然后删除了第一个元素后，新的第一个元素是20。函数删除队列中的第一个元素。
C++ 先进先出算法（FIFO）
07-09
用C++写的先进先出（FIFO）的模拟算法，标志了缺页的位置，还有计算缺页率
C++ queue：数据结构的“排队哲学”与“先进先出法则
最新发布
muzibuku的博客
02-18 664
就像一位公正的排队管理员，确保数据严格遵循“先进先出（FIFO）”的法则，维护秩序与效率。这种“先来先服务”的规则正是**队列（Queue）**的核心思想！是C++标准模板库（STL）提供的容器适配器，基于其他容器（如。成为你的得力助手——它不仅是容器，更是程序秩序与效率的守护者！以其严格的FIFO规则，成为处理顺序性任务的理想工具。下次当你需要管理“先到先得”的任务流时，不妨让。作为底层容器，但也可指定其他容器（需支持。）实现，专门用于FIFO操作。若指定不兼容的底层容器（如。
c++stl之queue
爱CV
11-28 576
queue 操作 queue 只能访问 queue<T> 容器适配器的第一个和最后一个元素。只能在容器的末尾添加新元素，只能从头部移除元素。： front()：返回 queue 中第一个元素的引用。如果 queue 是常量，就返回一个常引用；如果 queue 为空，返回值是未定义的。 back()：返回 queue 中最后一个元素的引用。如果 queue 是常量，就返回一个常引用；如果 queue 为空，返回值是未定义的。 push(const T& obj)：在 queue 的
Java数据结构与算法[原创]——队列
weixin_34383618的博客
03-23 137
声明：码字不易，转载请注明出处，欢迎文章下方讨论交流。 前言：Java数据结构与算法专题会不定时更新，欢迎各位读者监督。本文介绍数据结构中的队列（queue）的概念、存储结构、队列的特点，文末给出java实现循环队列的代码实现供读者参考学习。 1.队列的概念 队列正如其名，队列就像一支队伍，有队首(head)和队尾(tail)以及队列长度...
c++ 队列（FIFO）
olopl的博客
12-31 765
C++中队列的实现可以使用STL中的queue容器来实现。queue是一个先进先出（FIFO）的容器，可以用于存储一系列的元素，并提供了一些常用的操作函数。
「队列」实现FIFO队列（先进先出队列|queue）的功能 / 数据结构模版（C++）
dakingffo的博客
08-05 1794
队列，是一种基本的数据结构，也是一种数据适配器。本文实现了这种数据结构。
C/C++ queue队列算法详解及源码
希望我的博客，能帮上你解决学习中工作中所遇到的问题
05-17 7420
队列（queue）是一种先进先出（FIFO）的数据结构，类似于现实中的排队。在队列中，元素只能在队列的一端（称为队尾）添加，而在另一端（称为队头）移除。队列按照FIFO的顺序进行操作，即先进入队列的元素将先被处理，后进入队列的元素将后被处理。
queue-link.zip_C++队列_打印 队列_队列
09-23
在C++编程中，队列是一种非常基础且重要的数据结构，它遵循“先进先出”（FIFO，First In First Out）的原则。队列通常用于处理任务调度、数据缓冲、多线程通信等问题。本教程将详细介绍如何在C++中实现队列，包括...
fifo.rar_Visual C++ fifo_系统调用FIFO_队列fifo
09-22
在IT行业中，FIFO（First In First Out，先进先出）是一种常见的数据结构，尤其在计算机内存管理和进程通信中有着广泛的应用。Visual C++ 是一个强大的C++开发环境，能够帮助开发者实现各种复杂的编程任务，包括创建...
先进先出算法
08-21
使用先进先出算法，c++编译，同时还可以计算缺页率，代码运行准确无误
练习：c++版本FIFO队列
04-07
自己练习用：c++版本FIFO队列. 因为是练习，用了template模板。
VC++自己写的先进先出队列的例子_QueueDemo
02-21
该程序使用VC++2008实现了先进先出队列的工作原理，对处理大量需要等待的数据非常有用
C++版本队列，先进先出
weixin_46739730的博客
02-16 160
【代码】C++版本队列，先进先出。
C++之队列和优先队列
Lavi的专栏
08-01 5252
转载自：http://www.cppblog.com/wanghaiguang/archive/2012/06/05/177644.html http://www.cnblogs.com/heqinghui/archive/2013/07/30/3225407.html http://blog.csdn.net/sun_168/article/details/7680911 C++
C++多线程编程学习三 [FIFO队列设计]
nellson的专栏
02-06 1790
   在网络编程中，FIFO队列是经常使用到的一个数据缓冲机制，同时这也是一个生产者与消费者问题，在设计过程中要注意以下几点。队列大小设计要科学，对于服务的强度而言，有一个最优化长度，要通过测试去发掘。数据竞争保护，通过设定条件互斥量，对涉及队列的操作进行保护。事件通知策略，两个线程，一个读，一个写，每写一个数据到队列中就要进行“事件通知”，而读消息每     次读消息前都要检测事件是否处在信号通
【数据结构】【C++STL】FIFO队列&优先队列
weixin_30535565的博客
05-22 254
C++的STL中提供了有关队列的东西 很方便 作为一个懒人既然有现成的 肯定就不会手写了… 首先都需要打头文件queue FIFO队列是先进先出的 就好像排队一样 STL定义FIFO队列 queue<类型>变量名 //可用类型 int char data等等 优先队列的话是有优先级存在的 STL定义优先队列 priorit...
字典写入excel_Excel中“先出式”出货的问题，以后出库太方便了
weixin_39944074的博客
11-05 392
来自Excel之家，侵联系删先说一下，我们这里说的先进先出，不是数据结构上的队列……就只是一种就事论事——百度是这么说的，先进先出是根据先入库先发出的原则，对于发出的存货以先入库存货的单价计算发出存货成本的方法……这事看起来很复杂，代码实现起来……简单。举个例子。下图是一份库存表。B列是产品名称，D列是单价，C列是进货数量，E列是已出库的数量，F列是实际存货的数量……下图是一张出货单。本着没事就偷...
C++实现队列结构-FIFO先进先出程序示例
资源摘要信息:"该压缩包中包含了一个关于FIFO（First In First Out，先进先出）的C++程序。FIFO是一种常见的数据管理策略，它广泛应用于各种系统中，比如操作系统中的任务调度、CPU缓存、打印队列、网络通信的流量...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Yongqiang Cheng

梦想不是浮躁，而是沉淀和积累。

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值