链表之CIRCLEQ

最新推荐文章于 2023-07-06 10:20:26 发布
最新推荐文章于 2023-07-06 10:20:26 发布
阅读量1.4k 收藏 2
点赞数 3
分类专栏： 数据结构与算法 文章标签： 链表 数据结构 CIRCLEQ
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/longintchar/article/details/122907773
版权

文章目录

头文件

头文件来自我最近看的项目：apache-mynewt-core-1.9.0\sys\sys\include\sys\queue.h

仅截取部分。

/*
 * Circular queue declarations.
 */
#define	CIRCLEQ_HEAD(name, type)					\
struct name {								\
	struct type *cqh_first;		/* first element */		\
	struct type *cqh_last;		/* last element */		\
}

#define	CIRCLEQ_HEAD_INITIALIZER(head)					\
	{ (void *)&(head), (void *)&(head) }

#define	CIRCLEQ_ENTRY(type)						\
struct {								\
	struct type *cqe_next;		/* next element */		\
	struct type *cqe_prev;		/* previous element */		\
}

/*
 * Circular queue functions.
 */
#define	CIRCLEQ_EMPTY(head)	((head)->cqh_first == (void *)(head))

#define	CIRCLEQ_FIRST(head)	((head)->cqh_first)

#define	CIRCLEQ_FOREACH(var, head, field)				\
	for ((var) = CIRCLEQ_FIRST((head));				\
	    (var) != (void *)(head) || ((var) = NULL);			\
	    (var) = CIRCLEQ_NEXT((var), field))

#define	CIRCLEQ_FOREACH_REVERSE(var, head, field)			\
	for ((var) = CIRCLEQ_LAST((head));				\
	    (var) != (void *)(head) || ((var) = NULL);			\
	    (var) = CIRCLEQ_PREV((var), field))

#define	CIRCLEQ_INIT(head) do {						\
	CIRCLEQ_FIRST((head)) = (void *)(head);				\
	CIRCLEQ_LAST((head)) = (void *)(head);				\
} while (0)

#define	CIRCLEQ_INSERT_AFTER(head, listelm, elm, field) do {		\
	CIRCLEQ_NEXT((elm), field) = CIRCLEQ_NEXT((listelm), field);	\
	CIRCLEQ_PREV((elm), field) = (listelm);				\
	if (CIRCLEQ_NEXT((listelm), field) == (void *)(head))		\
		CIRCLEQ_LAST((head)) = (elm);				\
	else								\
		CIRCLEQ_PREV(CIRCLEQ_NEXT((listelm), field), field) = (elm);\
	CIRCLEQ_NEXT((listelm), field) = (elm);				\
} while (0)

#define	CIRCLEQ_INSERT_BEFORE(head, listelm, elm, field) do {		\
	CIRCLEQ_NEXT((elm), field) = (listelm);				\
	CIRCLEQ_PREV((elm), field) = CIRCLEQ_PREV((listelm), field);	\
	if (CIRCLEQ_PREV((listelm), field) == (void *)(head))		\
		CIRCLEQ_FIRST((head)) = (elm);				\
	else								\
		CIRCLEQ_NEXT(CIRCLEQ_PREV((listelm), field), field) = (elm);\
	CIRCLEQ_PREV((listelm), field) = (elm);				\
} while (0)

#define	CIRCLEQ_INSERT_HEAD(head, elm, field) do {			\
	CIRCLEQ_NEXT((elm), field) = CIRCLEQ_FIRST((head));		\
	CIRCLEQ_PREV((elm), field) = (void *)(head);			\
	if (CIRCLEQ_LAST((head)) == (void *)(head))			\
		CIRCLEQ_LAST((head)) = (elm);				\
	else								\
		CIRCLEQ_PREV(CIRCLEQ_FIRST((head)), field) = (elm);	\
	CIRCLEQ_FIRST((head)) = (elm);					\
} while (0)

#define	CIRCLEQ_INSERT_TAIL(head, elm, field) do {			\
	CIRCLEQ_NEXT((elm), field) = (void *)(head);			\
	CIRCLEQ_PREV((elm), field) = CIRCLEQ_LAST((head));		\
	if (CIRCLEQ_FIRST((head)) == (void *)(head))			\
		CIRCLEQ_FIRST((head)) = (elm);				\
	else								\
		CIRCLEQ_NEXT(CIRCLEQ_LAST((head)), field) = (elm);	\
	CIRCLEQ_LAST((head)) = (elm);					\
} while (0)

#define	CIRCLEQ_LAST(head)	((head)->cqh_last)

#define	CIRCLEQ_NEXT(elm,field)	((elm)->field.cqe_next)

#define	CIRCLEQ_PREV(elm,field)	((elm)->field.cqe_prev)

#define	CIRCLEQ_REMOVE(head, elm, field) do {				\
	if (CIRCLEQ_NEXT((elm), field) == (void *)(head))		\
		CIRCLEQ_LAST((head)) = CIRCLEQ_PREV((elm), field);	\
	else								\
		CIRCLEQ_PREV(CIRCLEQ_NEXT((elm), field), field) =	\
		    CIRCLEQ_PREV((elm), field);				\
	if (CIRCLEQ_PREV((elm), field) == (void *)(head))		\
		CIRCLEQ_FIRST((head)) = CIRCLEQ_NEXT((elm), field);	\
	else								\
		CIRCLEQ_NEXT(CIRCLEQ_PREV((elm), field), field) =	\
		    CIRCLEQ_NEXT((elm), field);				\
} while (0)

例子

#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include "bsd_queue.h"  // 就是我上面贴的代码

struct entry {
    int data;
    CIRCLEQ_ENTRY(entry) entries;           /* Queue */
};

CIRCLEQ_HEAD(circlehead, entry);


int
main(void)
{
    struct entry *n1, *n2, *n3, *np;
    struct circlehead head;                 /* Queue head */
    int i;

    CIRCLEQ_INIT(&head);                    /* Initialize the queue */

    n1 = malloc(sizeof(struct entry));      /* Insert at the head */
    CIRCLEQ_INSERT_HEAD(&head, n1, entries);

    n1 = malloc(sizeof(struct entry));      /* Insert at the tail */
    CIRCLEQ_INSERT_TAIL(&head, n1, entries);

    n2 = malloc(sizeof(struct entry));      /* Insert after */
    CIRCLEQ_INSERT_AFTER(&head, n1, n2, entries);

    n3 = malloc(sizeof(struct entry));      /* Insert before */
    CIRCLEQ_INSERT_BEFORE(&head, n2, n3, entries);

    CIRCLEQ_REMOVE(&head, n2, entries);     /* Deletion */
    free(n2);
                                            /* Forward traversal */
    i = 0;
    CIRCLEQ_FOREACH(np, &head, entries)
        np->data = i++;
                                            /* Reverse traversal */
    CIRCLEQ_FOREACH_REVERSE(np, &head, entries)
        printf("%i\n", np->data);
                                            /* Queue deletion */
    n1 = CIRCLEQ_FIRST(&head);
    while (n1 != (void *)&head) {
        n2 = CIRCLEQ_NEXT(n1, entries);
        free(n1);
        n1 = n2;
    }
    CIRCLEQ_INIT(&head);

    exit(EXIT_SUCCESS);
}

代码分析

我们一点一点看上面的例子。

先来一张我自己绘制的示意图。红色表示我觉得不太“正常”的地方，指针的类型不匹配，需要强制转换。请添加图片描述

CIRCLEQ_ENTRY 和 CIRCLEQ_HEAD

struct entry {
    int data;
    CIRCLEQ_ENTRY(entry) entries;           /* Queue */
};

CIRCLEQ_HEAD(circlehead, entry);

宏展开是：

struct entry {
    int data;
    struct { 
        struct entry *cqe_next; 
        struct entry *cqe_prev; 
    } entries;
};
struct circlehead { 
    struct entry *cqh_first; 
    struct entry *cqh_last; 
};

和其他链表不同，这里没有用二级指针，cqe_prev 和 cqh_last 都是 struct entry * 类型。（为什么呢）

我前面写的文章都是研究宏展开后的代码，这次我们换一个思路，直接看宏的定义

CIRCLEQ_HEAD_INITIALIZER

#define	CIRCLEQ_HEAD_INITIALIZER(head)					\
	{ (void *)&(head), (void *)&(head) }

初始化一个链表后，表头的两个指针都指向自己。

CIRCLEQ_FIRST 和 CIRCLEQ_LAST

#define	CIRCLEQ_FIRST(head)	((head)->cqh_first)
#define	CIRCLEQ_LAST(head)	((head)->cqh_last)

这两个很好理解，不解释了。

CIRCLEQ_PREV 和 CIRCLEQ_NEXT

#define	CIRCLEQ_PREV(elm,field)	((elm)->field.cqe_prev)
#define	CIRCLEQ_NEXT(elm,field)	((elm)->field.cqe_next)

field 就是最开始定义的 entries

CIRCLEQ_INIT

#define	CIRCLEQ_INIT(head) do {						\
	CIRCLEQ_FIRST((head)) = (void *)(head);				\
	CIRCLEQ_LAST((head)) = (void *)(head);				\
} while (0)

初始化一个链表后，表头的两个指针都指向自己。如下图

请添加图片描述

CIRCLEQ_EMPTY

#define	CIRCLEQ_EMPTY(head)	((head)->cqh_first == (void *)(head))

CIRCLEQ_INSERT_TAIL

#define	CIRCLEQ_INSERT_TAIL(head, elm, field) do {			\
	CIRCLEQ_NEXT((elm), field) = (void *)(head);			\
	CIRCLEQ_PREV((elm), field) = CIRCLEQ_LAST((head));		\
	if (CIRCLEQ_FIRST((head)) == (void *)(head))			\
		CIRCLEQ_FIRST((head)) = (elm);				\
	else								\
		CIRCLEQ_NEXT(CIRCLEQ_LAST((head)), field) = (elm);	\
	CIRCLEQ_LAST((head)) = (elm);					\
} while (0)

把 elm 插入到链表的尾部，都需要改变哪些指针呢？

  1. elm 的 field.cqe_next，因为它是最后一个，所以它应该等于 (void *)(head)
  2. elm 的 field.cqe_prev
  3. 插入后，elm 前面的那个节点的 field.cqe_next（如果前面的节点是表头，那就修改CIRCLEQ_FIRST(head) ）
  4. 修改 (head)->cqh_last 指向 elm

代码第 2、3 行分别解决了 1、2

代码第 4、5 行解决了 3 的括号中的情况

第 7 行解决了 3，elm 前面的那个节点就是原来最后的节点，CIRCLEQ_LAST(head)，它的 cqe_next 就是 CIRCLEQ_NEXT(CIRCLEQ_LAST((head)), field)

第 8 行解决了 4

CIRCLEQ_INSERT_HEAD

#define	CIRCLEQ_INSERT_HEAD(head, elm, field) do {			\
	CIRCLEQ_NEXT((elm), field) = CIRCLEQ_FIRST((head));		\
	CIRCLEQ_PREV((elm), field) = (void *)(head);			\
	if (CIRCLEQ_LAST((head)) == (void *)(head))			\
		CIRCLEQ_LAST((head)) = (elm);				\
	else								\
		CIRCLEQ_PREV(CIRCLEQ_FIRST((head)), field) = (elm);	\
	CIRCLEQ_FIRST((head)) = (elm);					\
} while (0)

把 elm 插入到链表的头部，都需要改变哪些指针呢？

  1. elm 的 field.cqe_next
  2. elm 的 field.cqe_prev，它应该等于 (void *)(head)
  3. (head)->cqh_first
  4. 插入后，elm 后面的那个节点的 field.cqe_prev（如果插入 elm 前链表为空，那就修改CIRCLEQ_LAST(head) ）

第 2 行解决了 1

第 3 行解决了 2

第 4-5 行解决了 4 的括号中的情况

第 7 行解决了 4

第 8 行解决了 3

代码 4-7 行说明，因为没有用二级指针，所以头插的时候需要分情况考虑。但是不用二级指针也有好处，就是代码更好理解。

CIRCLEQ_INSERT_AFTER

#define	CIRCLEQ_INSERT_AFTER(head, listelm, elm, field) do {		\
	CIRCLEQ_NEXT((elm), field) = CIRCLEQ_NEXT((listelm), field);	\
	CIRCLEQ_PREV((elm), field) = (listelm);				\
	if (CIRCLEQ_NEXT((listelm), field) == (void *)(head))		\
		CIRCLEQ_LAST((head)) = (elm);				\
	else								\
		CIRCLEQ_PREV(CIRCLEQ_NEXT((listelm), field), field) = (elm);\
	CIRCLEQ_NEXT((listelm), field) = (elm);				\
} while (0)

要把 elm 插入到 listelm 元素的后面，要修改哪些指针呢？

  1. elm 的 field.cqe_next
  2. elm 的 field.cqe_prev
  3. listelm 的 field.cqe_next
  4. 插入之前，listelm 后面的那个节点的 field.cqe_prev（如果 listelm 后面没有节点了，就修改 CIRCLEQ_LAST(head)）

2-3 行分别解决了 1、2

4-5 行解决了 4 括号里的情况

第 7 行解决了 4

第 8 行解决了 3

CIRCLEQ_INSERT_BEFORE

#define	CIRCLEQ_INSERT_BEFORE(head, listelm, elm, field) do {		\
	CIRCLEQ_NEXT((elm), field) = (listelm);				\
	CIRCLEQ_PREV((elm), field) = CIRCLEQ_PREV((listelm), field);	\
	if (CIRCLEQ_PREV((listelm), field) == (void *)(head))		\
		CIRCLEQ_FIRST((head)) = (elm);				\
	else								\
		CIRCLEQ_NEXT(CIRCLEQ_PREV((listelm), field), field) = (elm);\
	CIRCLEQ_PREV((listelm), field) = (elm);				\
} while (0)

要把 elm 插入到 listelm 元素的前面，要修改哪些指针呢？

  1. elm 的 field.cqe_next
  2. elm 的 field.cqe_prev
  3. listelm 的 field.cqe_prev
  4. 插入之前，listelm 前面的那个节点的 field.cqe_next（如果 listelm 前面是表头，就修改 CIRCLEQ_FIRST(head)）

2-3 行分别解决了 1、2

4-5 行解决了 4 括号里的情况

第 7 行解决了 4

第 8 行解决了 3

CIRCLEQ_FOREACH

#define	CIRCLEQ_FOREACH(var, head, field)				\
	for ((var) = CIRCLEQ_FIRST((head));				\
	    (var) != (void *)(head) || ((var) = NULL);			\
	    (var) = CIRCLEQ_NEXT((var), field))

顺序遍历，只要 (var) != (void *)(head) 就会往下进行，如果等于 head，根据 || 运算符的求值规则，会执行 (var) = NULL，这个表达式的结果为 false，于是终止 for 循环

CIRCLEQ_FOREACH_REVERSE

#define	CIRCLEQ_FOREACH_REVERSE(var, head, field)			\
	for ((var) = CIRCLEQ_LAST((head));				\
	    (var) != (void *)(head) || ((var) = NULL);			\
	    (var) = CIRCLEQ_PREV((var), field))

逆序遍历，和顺序遍历类似，不解释了。

CIRCLEQ_REMOVE

#define	CIRCLEQ_REMOVE(head, elm, field) do {				\
	if (CIRCLEQ_NEXT((elm), field) == (void *)(head))		\
		CIRCLEQ_LAST((head)) = CIRCLEQ_PREV((elm), field);	\
	else								\
		CIRCLEQ_PREV(CIRCLEQ_NEXT((elm), field), field) =	\
		    CIRCLEQ_PREV((elm), field);				\
	if (CIRCLEQ_PREV((elm), field) == (void *)(head))		\
		CIRCLEQ_FIRST((head)) = CIRCLEQ_NEXT((elm), field);	\
	else								\
		CIRCLEQ_NEXT(CIRCLEQ_PREV((elm), field), field) =	\
		    CIRCLEQ_NEXT((elm), field);				\
} while (0)

移除节点 elm，需要修改那些指针呢？

  1. elm 前面那个节点的 field.cqe_next

  2. elm 后面那个节点的 field.cqe_prev

  3. 对于 1，如果 elm 前面的节点是 head，那就需要修改 CIRCLEQ_FIRST(head)

  4. 对于 2， 如果 elm 后面没有节点了，那就需要修改 CIRCLEQ_LAST(head)

代码 2-3 行解决了 4

5-6 行解决了 2

代码 7-8 行解决了 3

10-11 解决了 1

【end】

车子 chezi
关注
  • 3
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Libevent里的数据结构应用
09-16
对quque.h里的各种数据结构进行应用举例，便于理解libevent的编码方式。
Python数据结构之链表实现
最新发布
02-27
1.使用Python语言实现链表数据结构 2.基于类封装思想 3.实现链表增删改查功能 4.有测试数据
直击面试之链表
01-20
面试过程中经常会遇到链表相关面试，链表相较于数组区别是节点存储空间不连续，可持续扩展。下面是使用Go进行链表实现。 链表结构定义 //define the data struct type LinkList struct { pPrev *LinkList //Previous node pointer pNext *LinkList //Next node pointer Value interface{} //Store The Value of Node } 链表的插入获取值 //Create Node func NewLinkList(value interface{}) *
python数据结构之链表详解
09-21
主要为大家详细介绍了python数据结构之链表的相关资料，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
C语言之线性链表1
08-08
//返回data元素#endif3.0、线性链表之List.cList.h的实现#include <stdio.h>#include <malloc.h>#in
Linux下circleq队列使用实例
zhongcaogen的专栏
01-18 349
Linux下circleq使用例子
环形队列实现
cc44446666的博客
02-13 526
/* * Circular queue definitions. */#define CIRCLEQ_HEAD(name, type)     \struct name {        \ struct type *cqh_first;  /* first element */  \ struct type *cqh_last;  /* last element */  \}#define CI...
C语言循环队列的实现以及相关操作（初始化、清空队列、销毁队列、判空、求长度、取队头元素、入队、出队）
weixin_50854471的博客
03-21 2010
int head;//队头下标 int rear;//队尾下标 int maxsize;//最大容量 } SqQueue;1int head;//队头下标 int rear;//队尾下标 int maxsize;//最大容量 } SqQueue;1int head;//队头下标 int rear;//队尾下标 int maxsize;//最大容量 } SqQueue;0int head;//队头下标 int rear;//队尾下标 int maxsize;
理解linux内核数据结构尾队列（Tail queue）
回头太难
11-29 2146
Tail queue位于/usr/include/x86_64-linux-gnu/sys/queue.h queue.h包含以下几种数据结构： 双链表（List） 单链表（Singly-linked List） 单链尾队列（Singly-linked Tail queue） 简单队列（Simple queue） 双链尾队列（Tail queue） 循环队列（Circular queue） Tail queue几个参数含义 HEADNAME 链表头结点的名字，用TAILQ_HEAD(H
Linux应用层的定时器简单实现
zhongcaogen的专栏
01-13 1346
Linux应用层的定时器简单实现
双向链表之自己动手.py
12-25
python双向链表各种操作
关于SLIST，STAILQ，LIST，TAILQ，CIRCLEQ图示详解
u014028690的博客
03-23 1843
一，前述 由于接触蓝牙协议栈相关工作，涉及很多mbuf,mqueue的操作，其中不乏Berkeley queue的身影，故因此，深入了解一下链表以及队列相关操作，九几年的代码放在现在依旧经典，需要深入琢磨多次！该部分包含5个部分，单向链表，双向链表，队列，尾队列，环形队列。 （注：在此之后，将依赖此深入了解mbuf与mqueue） 文件索引地址：https://github.com/torvalds/linux/blob/master/drivers/scsi/aic7xxx/queue.h 二，Sing
Linux下使用C语言实现简单的聊天室程序
zhongcaogen的专栏
03-03 5292
通过TCP协议中的客户端/服务端模式，在Linux系统下使用C语言实现简单的局域网聊天室的功能，该功能的实现过程中可以让初学者熟悉Linux下socket编程以及不同设备之间以太网通信机制，为以后做其它的项目打下基础并积累一些经验。
Linux C语言使用＜sys/queue.h＞非递归遍历指定目录下的所有文件及目录
m0_60964043的博客
07-06 149
Linux C语言使用queue.h头文件中定义的结构体和接口来实现非递归目录的遍历，并对之前的版本进行一些优化。
Circular Queue
Cylan_Jia的专栏
07-22 3367
最近在项目中，用于缓存数据的时候使用到linux下的循环队列（circular queue），要缓存的数据单元是一个结构体，这种数据结构使用起来很方便，linux下有许多宏可以使用。下面就详细介绍下这种队列的使用，本文参考了http://cpp.ezbty.org/import_doc/linux_manpage/queue.3.html的内容，在此表示感谢。 1.Introduce  A ci
使用linux中标准的queue.h头文件插件链表，队列，循环队列
u010758403的专栏
09-07 4509
#include #include #include #include int test_list() {     LIST_HEAD(listhead, entry) head;     struct listhead *headp;                 /* List head. */     struct entry {         ch
Linux内嵌链表（sys/queue.h）详解
热门推荐
tissar的博客
02-11 1万+
Linux 内嵌链表（sys/queue.h）详解queue 简介SLISTSTAILQLISTTAILQCIRCLEQ例程 queue 简介 C语言不像C++语言可以使用STL，在编程中需要用到链表时，通常需要程序员重新设计链表的结构体。不统一的编程规范会增加代码的阅读难度，而且链表的正确性需要验证。 头文件queue.h为C语言中的链表提供了更加标准规范的编程接口。如今的版本多为伯克利加州大...
Libevent分解之数据结构Circlequeue
星火的专栏
09-13 995
#ifndef _TEST_STRUCT_C #define _TEST_STRUCT_C //结构体定义 struct Student {  //业务数据  const char name[32];  int id;  int classID;  //下面的字段纯粹是为了建立链表用  struct TstField  {   struct Student *sle
Linux循环链表队列,使用linux中标准的queue.h头文件插件链表，队列，循环队列
weixin_35856883的博客
05-14 296
#include#include #include int test_list(){LIST_HEAD(listhead, entry) head;struct listhead *headp; /* List head. */struct entry {char name[64];char sexy[8];int age;LIST_ENTRY(entry) ent...
c语言数据结构之链表
11-03
链表是一种常见的数据结构，它在计算机科学中有广泛的应用。在C语言中，链表常常用于实现动态内存分配、函数调用栈、多项式运算等问题。单向链表是一种基本的链表结构，它由一系列节点组成，每个节点包含一个数据...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值