Linux的链表sys/queue.h

最新推荐文章于 2023-07-06 10:20:26 发布
最新推荐文章于 2023-07-06 10:20:26 发布
阅读量1k 收藏 8
点赞数
分类专栏： linux linux内核
原文链接：https://blog.csdn.net/pcokk/article/details/86656270
版权

Linux的链表sys/queue.h

环境

Ubuntu16.04 x86_64 GNU/Linux , 4.15.0-43-generic

介绍

<sys/queue.h> 实现了5种数据结构 :

	singly-linked list  
	list 
	simple queue 
	tail queue 
	circular queue

下面对他们分别进行介绍

List

List是双向链表 : head节点不包含指向最后一个节点的指针，其结构如下图 :

在这里插入图片描述

Description :

	A list is headed by a single forward pointer (or an array of forward 
	pointers for a hash table header). The elements are doubly linked 
	so that an arbitrary element can be removed without a need to 
	traverse the list. New elements can be added to the list before
	or after an existing element or at the head of the list. A list
	may only be traversed in the forward direction.

Interface :

	LIST_INIT(head) :对head进行初始化
	LIST_INSERT_HEAD(head, elm, field) : 从list头部插入elm
	LIST_REMOVE(elm, field) : 将elm从list中删除
	LIST_INSERT_AFTER(listelm, elm, field) : 将elm插入到listelm后面
	LIST_INSERT_BEFORE(listelm, elm, field) : 将elm插入到liistelm之前
	LIST_FOREACH(var, head, field) : 循环遍历所有节点, var为中间变量 
	LIST_EMPTY(head) : 判断list是否为空
	LIST_FIRST(head) : 获取第一个节点
	LIST_NEXT(elm, field) : 获取elm的下一个节点

Example：

#include <sys/queue.h>
#include <stdlib.h>
#include <stdio.h>

struct node {
	LIST_ENTRY(node) next;
	int num;
};

LIST_HEAD(head, node);

struct head* lhead = NULL;


int main(int argc, char* argv[]){
	lhead = (struct head*)malloc(sizeof(struct head));
	LIST_INIT(lhead);
	
	struct node *var;
	struct node *num_1 = (struct node *)malloc(sizeof(struct node));
	num_1->num = 1;
	LIST_INSERT_HEAD(lhead, num_1, next);
	LIST_FOREACH(var, lhead, next){
		printf("%d->", var->num);
	}
	printf("null\n");

	struct node *num_2 = (struct node *)malloc(sizeof(struct node));
	num_2->num = 2;
	struct node *num_3 = (struct node *)malloc(sizeof(struct node));
	num_3->num = 3;
	LIST_INSERT_HEAD(lhead, num_2, next);
	LIST_INSERT_HEAD(lhead, num_3, next);
	LIST_FOREACH(var, lhead, next){
		printf("%d->", var->num);
	}
	printf("null\n");
	
	struct node *num_4 = (struct node *)malloc(sizeof(struct node));
	num_4->num = 4;
	struct node *num_5 = (struct node *)malloc(sizeof(struct node));
	num_5->num = 5;
	LIST_INSERT_BEFORE(num_3, num_4, next);
	LIST_INSERT_AFTER(num_3, num_5, next);
	LIST_FOREACH(var, lhead, next){
		printf("%d->", var->num);
	}
	printf("null\n");
	
	LIST_REMOVE(num_3, next);
	LIST_FOREACH(var, lhead, next){
		printf("%d->", var->num);
	}
	printf("null\n");
	var = LIST_NEXT(num_4, next);
	printf("4's next is %d\n", var->num);
	return 0;
}

Singly-linked list

singly-linked list 是单向链表，head不包含指向最后一个元素的指针，其结构如下图:
在这里插入图片描述

Description :

	* A singly-linked list is headed by a single forward pointer. The
	* elements are singly linked for minimum space and pointer manipulation
	* overhead at the expense of O(n) removal for arbitrary elements. New
	* elements can be added to the list after an existing element or at the
	* head of the list.  Elements being removed from the head of the list
	* should use the explicit macro for this purpose for optimum
	* efficiency. A singly-linked list may only be traversed in the forward
	* direction.  Singly-linked lists are ideal for applications with large
	* datasets and few or no removals or for implementing a LIFO queue.

Interface :

	SLIST_INIT(head) : 对head进行初始化
	SLIST_INSERT_HEAD(head, elm, field) : 从list头部插入elm
	SLIST_INSERT_AFTER(slistelm, elm, field) : 将elm 插入到slistelm后面
	SLIST_REMOVE_HEAD(head, field) : 从list的头部删除一个节点
	SLIST_REMOVE(head, elm, type, field) : 从list中删除elm
	SLIST_FOREACH(var, head, field) : 循环遍历所有节点, var为中间变量 
	SLIST_EMPTY(head) : 判断list是否为空
	SLIST_FIRST(head) : 获取第一个节点
	SLIST_NEXT(elm, field) : 获取elm的下一个节点

Example：

#include <sys/queue.h>
#include <stdlib.h>
#include <stdio.h>

struct node{
	SLIST_ENTRY(node) next;
	int num;
};
SLIST_HEAD(head, node);
struct head *lhead = 0;
int main(int argc, char* argv[]){
	lhead = (struct head*)malloc(sizeof(struct head));
	SLIST_INIT(lhead);
	
	struct node *var;

	struct node* num_1 = (struct node*)malloc(sizeof(struct node));
	num_1->num = 1;
	SLIST_INSERT_HEAD(lhead, num_1, next);
	SLIST_FOREACH(var, lhead, next){
		printf("%d->",var->num);
	}
	printf("null\n");

	struct node* num_2 = (struct node*)malloc(sizeof(struct node));
	num_2->num = 2;
	struct node* num_3 = (struct node*)malloc(sizeof(struct node));
	num_3->num = 3;	
	struct node* num_4 = (struct node*)malloc(sizeof(struct node));
	num_4->num = 4;
	SLIST_INSERT_AFTER(num_1, num_2, next);
	SLIST_INSERT_AFTER(num_1, num_3, next);
	SLIST_INSERT_AFTER(num_1, num_4, next);
	SLIST_FOREACH(var, lhead, next){
		printf("%d->",var->num);
	}
	printf("null\n");

	SLIST_REMOVE_HEAD(lhead, next);
	SLIST_FOREACH(var, lhead, next){
		printf("%d->",var->num);
	}
	printf("null\n");

	SLIST_REMOVE(lhead, num_3, node, next);
	SLIST_FOREACH(var, lhead, next){
		printf("%d->",var->num);
	}
	printf("null\n");
	return 0;
}

Singly-linked tail queue(Simple queue)

Simple queue同Singly-linked tail queue, 将接口前缀改为SIMPLEQ_ , 并且没有CONCAT方法，下面的description使用的为simple queue的description，两者的实现几乎完全一致。
Singly-linked tail queue是单向链表，head节点包含指向最后一个节点的指针，其结构图如下:
在这里插入图片描述

Description :

	* A simple queue is headed by a pair of pointers, one the head of the
	* list and the other to the tail of the list. The elements are singly
	* linked to save space, so elements can only be removed from the
	* head of the list. New elements can be added to the list after
	* an existing element, at the head of the list, or at the end of the
	* list. A simple queue may only be traversed in the forward direction.

Interface :

	STAILQ_INIT(head) : 对head进行初始化
	STAILQ_INSERT_HEAD(head, elm, field) : 从queue头部插入elm
	STAILQ_INSERT_TAIL(head, elm, field) : 从queue尾部插入elm
	STAILQ_INSERT_AFTER(head, listelm, elm, field) : 将elm 插入到listelm后面
	STAILQ_REMOVE_HEAD(head, field) : 从queue头部删去一个节点
	STAILQ_REMOVE(head, elm, type, field) : 将queue中的elm删除
	STAILQ_FOREACH(var, head, field) : 循环遍历所有节点, var为中间变量 
	STAILQ_CONCAT(head1, head2) : 将两个queue拼接，head1为拼接后的queue的头部，head2被重新初始化
	STAILQ_EMPTY(head): 判断queue是否为空
	STAILQ_FIRST(head): 获取第一个节点
	STAILQ_NEXT(elm, next): 获取elm的下一个节点

Example：

#include <sys/queue.h>
#include <stdlib.h>
#include <stdio.h>

struct node{
	STAILQ_ENTRY(node) next;
	int num;
};
STAILQ_HEAD(head, node);
struct head *lhead = 0;
struct head *llhead = 0;

int main(int argc, char* argv[]){
	lhead = (struct head*)malloc(sizeof(struct head));
	STAILQ_INIT(lhead);
	
	struct node* var = 0;
	struct node* num[9];
	for(int i=0; i<9; i++){
		num[i] = (struct node*)malloc(sizeof(struct node));
		num[i]->num = i;
	}
	STAILQ_INSERT_HEAD(lhead, num[0], next);
	STAILQ_INSERT_HEAD(lhead, num[1], next);
	STAILQ_INSERT_TAIL(lhead, num[2], next);
	STAILQ_INSERT_AFTER(lhead, num[1], num[3], next);
	STAILQ_INSERT_TAIL(lhead, num[4], next);
	STAILQ_FOREACH(var, lhead, next){
		printf("%d->", var->num);
	}
	printf("null\n");
	
	llhead = (struct head*)malloc(sizeof(struct head));
	STAILQ_INIT(llhead);
	
	STAILQ_INSERT_TAIL(llhead, num[5], next);
	STAILQ_INSERT_TAIL(llhead, num[6], next);
	STAILQ_INSERT_TAIL(llhead, num[7], next);
	STAILQ_INSERT_TAIL(llhead, num[8], next);
	STAILQ_FOREACH(var, llhead, next){
		printf("%d->", var->num);
	}
	printf("null\n");
	
	STAILQ_REMOVE(llhead, num[6], node, next);
	STAILQ_FOREACH(var, llhead, next){
		printf("%d->", var->num);
	}
	printf("null\n");
	
	STAILQ_REMOVE_HEAD(llhead, next);
	STAILQ_FOREACH(var, llhead, next){
		printf("%d->", var->num);
	}
	printf("null\n");

	STAILQ_CONCAT(lhead, llhead);
	STAILQ_FOREACH(var, lhead, next){
		printf("%d->", var->num);
	}
	printf("null\n");
	return 0;
}

Tail queue

Tail queue是 双向链，head节点包含指向最后一个节点的指针，其结构图如下:
在这里插入图片描述

Description :

	* A tail queue is headed by a pair of pointers, one to the head of the
	* list and the other to the tail of the list. The elements are doubly
	* linked so that an arbitrary element can be removed without a need to
	* traverse the list. New elements can be added to the list before or
	* after an existing element, at the head of the list, or at the end of
	* the list. A tail queue may be traversed in either direction

Interface :

	TAILQ_INIT(head) : 对head进行初始化
	TAILQ_INSERT_HEAD(head, elm, field) : 从queue头部插入elm
	TAILQ_INSERT_TAIL(head, elm, field) : 从queue尾部插入elm
	TAILQ_INSERT_AFTER(head, listelm, elm, field) ：将elm 插入到listelm后面
	TAILQ_INSERT_BEFORE(listelm, elm, field) ：将elm 插入到listelm前面
	TAILQ_REMOVE(head, elm, field) : 将queue中的elm删除
	TAILQ_FOREACH(var, head, field) : 正向遍历所有节点, var为中间变量
	TAILQ_FOREACH_REVERSE(var, head, headname, field): 反向遍历所有节点, var为中间变量
	TAILQ_CONCAT(head1, head2, field)：将两个queue拼接，head1为拼接后的queue的头部，head2被重新初始化
	TAILQ_EMPTY(head) ：判断queue是否为空
	TAILQ_FIRST(head) ：获取第一个节点
	TAILQ_NEXT(elm, field) ： 获取elm的下一个节点
	TAILQ_LAST(elm, headname) ：获取最后一个节点
	TAILQ_PREV(elm, headname, field) : 获取elm的前一个节点

Example：

#include <sys/queue.h>
#include <stdlib.h>
#include <stdio.h>


struct node{
	TAILQ_ENTRY(node) next;
	int num;
};
TAILQ_HEAD(head, node);
struct head *lhead = 0;
struct head *llhead = 0;

int main(int argc, char* argv[]){
	lhead = (struct head*)malloc(sizeof(struct head));
	TAILQ_INIT(lhead);
	
	struct node* var = 0;
	struct node* num[9];
	for(int i=0; i<9; i++){
		num[i] = (struct node*)malloc(sizeof(struct node));
		num[i]->num = i;
	}
	TAILQ_INSERT_HEAD(lhead, num[0], next);
	TAILQ_INSERT_HEAD(lhead, num[1], next);
	TAILQ_INSERT_TAIL(lhead, num[2], next);
	TAILQ_INSERT_AFTER(lhead, num[1], num[3], next);
	TAILQ_INSERT_BEFORE(num[2], num[4], next);
	TAILQ_FOREACH(var, lhead, next){
		printf("%d->", var->num);
	}
	printf("null\n");
	
	llhead = (struct head*)malloc(sizeof(struct head));
	TAILQ_INIT(llhead);

	TAILQ_INSERT_TAIL(llhead, num[5], next);
	TAILQ_INSERT_TAIL(llhead, num[6], next);
	TAILQ_INSERT_TAIL(llhead, num[7], next);
	TAILQ_INSERT_TAIL(llhead, num[8], next);
	TAILQ_FOREACH(var, llhead, next){
		printf("%d->", var->num);
	}
	printf("null\n");
	
	TAILQ_REMOVE(llhead, num[6], next);
	TAILQ_FOREACH(var, llhead, next){
		printf("%d->", var->num);
	}
	printf("null\n");
	
	TAILQ_FOREACH_REVERSE(var, lhead, head, next){
		printf("%d->", var->num);
	}
	printf("null\n");
		
	TAILQ_CONCAT(lhead, llhead, next);
	TAILQ_FOREACH(var, lhead, next){
		printf("%d->", var->num);
	}
	printf("null\n");
	return 0;
}

Circular queue

Circular queue是环状双向链表, head节点包含指向最后一个节点的指针，最后一个节点的next指向head节点, 其结构图如下:
在这里插入图片描述

Description :

	* A circle queue is headed by a pair of pointers, one to the head of the
	* list and the other to the tail of the list. The elements are doubly
	* linked so that an arbitrary element can be removed without a need to
	* traverse the list. New elements can be added to the list before or after
	* an existing element, at the head of the list, or at the end of the list.
	* A circle queue may be traversed in either direction, but has a more
	* complex end of list detection.

Interface :

	CIRCLEQ_INIT(head) : 对head进行初始化
	CIRCLEQ_INSERT_AFTER(head, listelm, elm, field) : 将elm 插入到listelm后面
	CIRCLEQ_INSERT_BEFORE(head, listelm, elm, field) : 将elm 插入到listelm前面
	CIRCLEQ_INSERT_HEAD(head, elm, field)：从queue头部插入elm
	CIRCLEQ_INSERT_TAIL(head, elm, field)：从queue尾部插入elm
	CIRCLEQ_REMOVE(head, elm, field) : 将queue中的elm删除
	CIRCLEQ_FOREACH(var, head, field) : 正向遍历所有节点, var为中间变量
	CIRCLEQ_FOREACH_RESERVE(var, head, field) : 反向遍历所有节点, var为中间变量
	CIRCLEQ_EMPTY(head) : 判断queue是否为空
	CIRCLEQ_FIRST(head) : 获取第一个节点
	CIRCLEQ_LAST(head) : 获取最后一个节点
	CIRCLEQ_NEXT(elm, field) : 获取elm的下一个节点
	CIRCLEQ_PREV(elm, field) : 获取elm的上一个节点
	CIRCLEQ_LOOP_NEXT(head, elm, field) : 获取elm的下一个节点(会跳过头节点)
	CIRCLEQ_LOOP_PREV(head, elm, field) : 获取elm的上一个节点(会跳过头节点)

Example：

#include <sys/queue.h>
#include <stdlib.h>
#include <stdio.h>

struct node{
	CIRCLEQ_ENTRY(node) next;
	int num;
};
CIRCLEQ_HEAD(head, node);
struct head *lhead = 0;

int main(int argc, char* argv[]){
	lhead = (struct head*)malloc(sizeof(struct head));
	CIRCLEQ_INIT(lhead);
	
	struct node* var = 0;
	struct node* num[9];
	for(int i=0; i < 9; i++){
		num[i] = (struct node*)malloc(sizeof(struct node));
		num[i]->num = i; 
	}
	
	CIRCLEQ_INSERT_HEAD(lhead, num[0], next);
	CIRCLEQ_INSERT_HEAD(lhead, num[1], next);
	CIRCLEQ_INSERT_TAIL(lhead, num[2], next);
	CIRCLEQ_INSERT_AFTER(lhead, num[1], num[3], next);
	CIRCLEQ_INSERT_BEFORE(lhead, num[2], num[4], next);
	CIRCLEQ_FOREACH(var, lhead, next){
		printf("%d->", var->num);
	}
	printf("null\n");
	
	CIRCLEQ_REMOVE(lhead, num[0], next);
	CIRCLEQ_FOREACH(var, lhead, next){
		printf("%d->", var->num);
	}
	printf("null\n");
	
	CIRCLEQ_FOREACH_REVERSE(var, lhead, next){
		printf("%d->", var->num);
	}
	printf("null\n");
	return 0;
}
-草原骑士-
关注
  • 0
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux内核经典队列queue.h详解
小银子
06-28 5272
一、前言 相信有一定编程经验的你，在项目中经常会遇到队列、链表、ringbuffer等问题。刚开始的时候，都有过自己编写代码（造轮子）的经验。但随着工作经验的提升，经常会发现： 以前自己造的轮子还有很多漏洞，并不能满足现在或将来的产品需求；甚至已经给现有产品埋下了坑； 接触的越来越多，发现有很多经典开源的库（GitHub），已经实现了以前自己造的轮子，而且开源库做的更好（应该是非常的好）。 那...
Linux的队列 std/queue.h
pcokk的博客
01-26 2866
Linux的队列 queue.h 环境介绍ListSingly-linked listSingly-linked tail queue(Simple queue)Tail queueCircular queue 环境 Ubuntu16.04 x86_64 GNU/Linux , 4.15.0-43-generic 介绍 &lt;sys/queue.h&gt; 实现了5种数据结构 : sing...
Linux内嵌链表（sys/queue.h）详解
热门推荐
tissar的博客
02-11 1万+
Linux 内嵌链表（sys/queue.h）详解queue 简介SLISTSTAILQLISTTAILQCIRCLEQ例程 queue 简介 C语言不像C++语言可以使用STL，在编程中需要用到链表时，通常需要程序员重新设计链表的结构体。不统一的编程规范会增加代码的阅读难度，而且链表的正确性需要验证。 头文件queue.h为C语言中的链表提供了更加标准规范的编程接口。如今的版本多为伯克利加州大...
Linux C语言使用＜sys/queue.h＞非递归遍历指定目录下的所有文件及目录
m0_60964043的博客
07-06 209
Linux C语言使用queue.h头文件中定义的结构体和接口来实现非递归目录的遍历，并对之前的版本进行一些优化。
sys/queue.h
qq_35782149的博客
03-15 1009
queue 简介 SLIST( 单链表 ) STAILQ LIST （双向链表 ） SIMPLEQ (简单队列) TAILQ( 尾队列 ) CIRCLEQ （循环队列） 例程
数据结构之线性表(bsd, sys/queue.h)
Once_day的回忆
05-28 1132
线性表（linear list）存在唯一的头部数据和尾部数据，而且中间的每个数据都有一个前驱元素和后驱元素。线性表是有限个元素的序列，如一维数组和链表。每个数据元素可由若干个数据项构成。a1a2an−1ana1​a2​....an−1​an​**数据元素n即为线性表的长度。**也可以看到每个元素都有个确切的位置，并且长度也可根据需要增长和缩短。本文介绍的线性表以linux自带的为例子，该列表来自于FreeBSD中的一个头文件。
嵌入式大杂烩周记 | 第 3 期：sys/queue.h
嵌入式大杂烩
02-21 844
大家好，我是杂烩君。 嵌入式大杂烩周记主要是一些实用项目学习分享，每周一篇，每篇一个主题。 内容主要来源于我们之前收集的资料： https://gitee.com/zhengnianli/EmbedSummary 本期主角：sys/queue.h queue.h是Linux、FreeBSD中的一个头文件。 FreeBSD：FreeBSD 是一种类 UNIX操作系统。 这是一个很实用的头文件，因为这个头文件里全是宏定义操作，所以其不仅可以使用在Linux/嵌入式Linux项目中，也可以.
sys/queue.h分析
u013229693的博客
08-04 458
[转自:@astrotycoon](http://blog.csdn.net/astrotycoon/article/details/42917367) 这两天有兴趣学习使用了下系统头文件sys/queue.h中的链表/队列的实现，感觉实现的很是优美，关键是以后再也不需要自己实现这些基本的数据结构了，哈哈！ 我的系统环境是 正好需要使用队列，那么本篇就以其中的尾队列（
使用sys/queue.h
xue_nuo的博客
08-16 276
sys/queue.h 是FreeBSD中的链表函数，最新版为伯克利的8.5 此文件同样包含在Linux和FreeRTOS等发行版系统中 经历过时间的考验，当熟练使用此文件后，就不必再自己写基础函数了。 TIALQ的使用 全称叫 tial queue ...
linux上queue.h 队列的实现
07-09
linux上queue.h，可用于一直实现双向链表.亲测非常好用 linux上queue.h，可用于一直实现双向链表.亲测非常好用 linux上queue.h，可用于一直实现双向链表.亲测非常好用
linux内核链表list.h
05-17
内核链表
详解linux内核链表之list.h
12-14
本文将详述Linux内核中的链表实现，主要聚焦于`list.h`头文件中的相关概念、结构和函数，这对于理解和操作内核数据至关重要。 首先，`list.h`包含了Linux内核中双向链表的基本定义和操作。双向链表允许我们在列表的...
双链表类模板 CMyDoubleList.h 文件
07-25
双链表类模板 CMyDoubleList.h 文件
Linux内核通用链表linuxlist.h阅读.pdf
11-23
在Linux内核源码中，链表的实现被封装在`<linux/list.h>`头文件中。这个文件提供了简单易用的双向链表操作接口，便于程序员进行动态数据结构的管理。 链表的核心结构是`struct list_head`，它包含两个成员变量，...
倍加福ENA58IL-R-ProfiNET手册(译文)
07-11
本手册描述了配备PROFINET接口的Pepperl+Fuchs绝对旋转编码器如何集成到PROFINET网络中。 本手册适用于以下绝对旋转编码器类型： ■■Exx58N-...PN... ■Exx58N-。。。请注意。。。 ■■ENA58IL-...B17 ■ENA58IL-。。。B17
框架完整论文答辩PPT模板 (2)
07-11
【作品名称】：框架完整论文答辩PPT模板 (2) 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。
手持式DR设备，全球前8强生产商排名及市场份额调研数据.pdf
07-11
QYResearch是全球知名的大型咨询公司，行业涵盖各高科技行业产业链细分市场，横跨如半导体产业链（半导体设备及零部件、半导体材料、集成电路、制造、封测、分立器件、传感器、光电器件）、光伏产业链（设备、硅料/硅片、电池片、组件、辅料支架、逆变器、电站终端）、新能源汽车产业链（动力电池及材料、电驱电控、汽车半导体/电子、整车、充电桩）、通信产业链（通信系统设备、终端设备、电子元器件、射频前端、光模块、4G/5G/6G、宽带、IoT、数字经济、AI）、先进材料产业链（金属材料、高分子材料、陶瓷材料、纳米材料等）、机械制造产业链（数控机床、工程机械、电气机械、3C自动化、工业机器人、激光、工控、无人机）、食品药品、医疗器械、农业等。 邮箱：market@qyresearch.com
大学生创业计划书(16)三套材料.doc
最新发布
07-11
大学生创业计划书(16)三套材料.doc

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值