链表之CIRCLEQ

最新推荐文章于 2023-03-21 00:27:24 发布
最新推荐文章于 2023-03-21 00:27:24 发布
阅读量1.5k 收藏 2
点赞数 3
分类专栏： 数据结构与算法 文章标签： 链表 数据结构 CIRCLEQ
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/longintchar/article/details/122907773
版权
本文详细解读了C++中Apache Mynewt Core项目的环形队列（Circular Queue）结构，包括CIRCLEQ_ENTRY、CIRCLEQ_HEAD、初始化、插入和删除等关键操作，以及相应的宏定义和示例代码分析。
摘要由CSDN通过智能技术生成

文章目录

头文件

头文件来自我最近看的项目：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
关注
专栏目录
环形队列实现
cc44446666的博客
02-13 562
/* * Circular queue definitions. */#define CIRCLEQ_HEAD(name, type)     \struct name {        \ struct type *cqh_first;  /* first element */  \ struct type *cqh_last;  /* last element */  \}#define CI...
Circular Queue
Cylan_Jia的专栏
07-22 3424
最近在项目中，用于缓存数据的时候使用到linux下的循环队列（circular queue），要缓存的数据单元是一个结构体，这种数据结构使用起来很方便，linux下有许多宏可以使用。下面就详细介绍下这种队列的使用，本文参考了http://cpp.ezbty.org/import_doc/linux_manpage/queue.3.html的内容，在此表示感谢。 1.Introduce  A ci
Q_FOREACH
chumoteng6705的博客
03-29 753
取自5.4.1的实现 // Explanation of the control word: // - it's initialized to 1 // - that means both the inner and outer loops start //...
Linux下circleq队列使用实例
zhongcaogen的专栏
01-18 403
Linux下circleq使用例子
C语言循环队列的实现以及相关操作（初始化、清空队列、销毁队列、判空、求长度、取队头元素、入队、出队）
weixin_50854471的博客
03-21 2243
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;
C语言数据结构之双向循环链表的实例
08-30
C语言数据结构之双向循环链表的实例 在计算机科学中，链表是一种常用的数据结构，它可以动态地分配内存来存储数据，且可以随机访问和插入、删除数据。双向循环链表是一种特殊的链表，它可以同时在链表的头部和尾部...
C语言之单向链表详解及实例代码
12-31
单向链表（单链表）是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始；链表是使用指针进行构造的列表；又称为结点列表，因为链表是由一个个结点组装起来的；其中每个结点都有...
Python实现的数据结构与算法之链表详解
12-24
本文实例讲述了Python实现的数据结构与算法之链表。分享给大家供大家参考。具体分析如下： 一、概述 链表（linked list）是一组数据项的集合，其中每个数据项都是一个节点的一部分，每个节点还包含指向下一个节点的...
c语言链表的基本操作之合并两个有序链表.zip
最新发布
03-28
在C语言中，链表是一种非常重要的数据结构，它与数组相比有着动态扩展和高效插入删除的优势。本主题聚焦于链表的一个特定操作——合并两个已排序的链表。这是一项常见的编程任务，尤其在数据结构和算法的学习中。...
Libevent里的数据结构应用
09-16
对quque.h里的各种数据结构进行应用举例，便于理解libevent的编码方式。
理解linux内核数据结构尾队列（Tail queue）
回头太难
11-29 2429
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 1428
Linux应用层的定时器简单实现
关于SLIST，STAILQ，LIST，TAILQ，CIRCLEQ图示详解
u014028690的博客
03-23 2036
一，前述 由于接触蓝牙协议栈相关工作，涉及很多mbuf,mqueue的操作，其中不乏Berkeley queue的身影，故因此，深入了解一下链表以及队列相关操作，九几年的代码放在现在依旧经典，需要深入琢磨多次！该部分包含5个部分，单向链表，双向链表，队列，尾队列，环形队列。 （注：在此之后，将依赖此深入了解mbuf与mqueue） 文件索引地址：https://github.com/torvalds/linux/blob/master/drivers/scsi/aic7xxx/queue.h 二，Sing
使用linux中标准的queue.h头文件插件链表，队列，循环队列
u010758403的专栏
09-07 4569
#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 1017
#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 348
#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...
Linux 上的内置链表
草原骑士的专栏
09-11 256
Linux 上的内置链表1 简介2 特征tail queuecircular queue 1 简介 在 Linux 的 <sys/queue.h>中定义一系列操作不同链表的宏函数。如： LIST_ENTRY(TYPE); LIST_HEAD(HEADNAME, TYPE); LIST_INIT(LIST_HEAD *head); LIST_INSERT_AFTER(LIST_ENTRY *listelm, TYPE *elm, LIST_E
链表基础与单向链表解析
"链表是一种动态数据结构，与数组相比，它允许在程序运行时根据需要增加或减少元素，克服了数组预设长度和插入删除效率低的问题。...学习和理解链表的概念及其操作是计算机科学和软件开发中的基本技能之一。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值