链表之LIST

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

文章目录


上一篇博文 链表之SLIST_车子（chezi）-CSDN博客 说过，queue.h 里面有 5 种链表，分别是：

  1. SLIST
  2. LIST
  3. STAILQ
  4. TAILQ
  5. CIRCLEQ

这篇文章说 LIST

LIST 示意图

请添加图片描述

LIST 是双向无尾非循环链表。双向链表有前向的指针，因此可以执行一些前向操作。

仔细看图你会发现，le_next 这个指针指向后面的大结构体，这个不稀奇；稀奇的是，le_prev 这个指针，它指的不是前面的大结构体，而是前面的 le_next。为什么这样设计呢？卖个关子，答案在我以后的文章中。

接口和实现

注意：不同的版本，代码可能有差异。

/*
 * List declarations.
 */
#define	LIST_HEAD(name, type)						\
struct name {								\
	struct type *lh_first;	/* first element */			\
}

#define	LIST_HEAD_INITIALIZER(head)					\
	{ NULL }

#define	LIST_ENTRY(type)						\
struct {								\
	struct type *le_next;	/* next element */			\
	struct type **le_prev;	/* address of previous next element */	\
}

/*
 * List functions.
 */

#define	LIST_EMPTY(head)	((head)->lh_first == NULL)

#define	LIST_FIRST(head)	((head)->lh_first)

#define	LIST_FOREACH(var, head, field)					\
	for ((var) = LIST_FIRST((head));				\
	    (var);							\
	    (var) = LIST_NEXT((var), field))

#define	LIST_INIT(head) do {						\
	LIST_FIRST((head)) = NULL;					\
} while (0)

#define	LIST_INSERT_AFTER(listelm, elm, field) do {			\
	if ((LIST_NEXT((elm), field) = LIST_NEXT((listelm), field)) != NULL)\
		LIST_NEXT((listelm), field)->field.le_prev =		\
		    &LIST_NEXT((elm), field);				\
	LIST_NEXT((listelm), field) = (elm);				\
	(elm)->field.le_prev = &LIST_NEXT((listelm), field);		\
} while (0)

#define	LIST_INSERT_BEFORE(listelm, elm, field) do {			\
	(elm)->field.le_prev = (listelm)->field.le_prev;		\
	LIST_NEXT((elm), field) = (listelm);				\
	*(listelm)->field.le_prev = (elm);				\
	(listelm)->field.le_prev = &LIST_NEXT((elm), field);		\
} while (0)

#define	LIST_INSERT_HEAD(head, elm, field) do {				\
	if ((LIST_NEXT((elm), field) = LIST_FIRST((head))) != NULL)	\
		LIST_FIRST((head))->field.le_prev = &LIST_NEXT((elm), field);\
	LIST_FIRST((head)) = (elm);					\
	(elm)->field.le_prev = &LIST_FIRST((head));			\
} while (0)

#define	LIST_NEXT(elm, field)	((elm)->field.le_next)

#define	LIST_REMOVE(elm, field) do {					\
	if (LIST_NEXT((elm), field) != NULL)				\
		LIST_NEXT((elm), field)->field.le_prev = 		\
		    (elm)->field.le_prev;				\
	*(elm)->field.le_prev = LIST_NEXT((elm), field);		\
} while (0)

举例

我们举例说明，代码来自 https://manpages.courier-mta.org/htmlman3/list.3.html，我稍微改了一下。

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

struct entry {
    int data;
    LIST_ENTRY(entry) entries;              /* List */
};

LIST_HEAD(listhead, entry);

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

    LIST_INIT(&head);                       /* Initialize the list */

    n1 = malloc(sizeof(struct entry));      /* Insert at the head */
    n1->data = 1; //我加的
    LIST_INSERT_HEAD(&head, n1, entries);

    n2 = malloc(sizeof(struct entry));      /* Insert after */
    n2->data = 2; //我加的
    LIST_INSERT_AFTER(n1, n2, entries);

    n3 = malloc(sizeof(struct entry));      /* Insert before */
    n3->data = 3; //我加的
    LIST_INSERT_BEFORE(n2, n3, entries);

    /* Forward traversal */
    LIST_FOREACH(np, &head, entries)
        printf("%i\n", np->data);

    LIST_REMOVE(n2, entries);               /* Deletion */
    free(n2);
                                            /* Forward traversal */
    LIST_FOREACH(np, &head, entries)
        printf("%i\n", np->data);
                                            /* List deletion */
    n1 = LIST_FIRST(&head);
    while (n1 != NULL) {
        n2 = LIST_NEXT(n1, entries);
        free(n1);
        n1 = n2;
    }
    LIST_INIT(&head);

    exit(EXIT_SUCCESS);
}

代码分析

代码呢，就是这么个代码。咱们一点一点看。

LIST_ENTRY 和 LIST_HEAD

struct entry {
    int data;
    LIST_ENTRY(entry) entries;   /* List */
};

LIST_HEAD(listhead, entry);

宏展开就是：

struct entry {
    int data;
    struct {  // 没有标签的结构体
        struct entry *le_next; 
        struct entry **le_prev; 
    } entries; 
};
struct listhead { 
    struct entry *lh_first; 
};

和 slist 很相似，唯一的区别是 entries 里面有 2 个指针，因为是双向，当然有 2 个指针了。注意，le_prev 的类型是指向指针的指针，即二级指针，这是为什么呢？

LIST_INIT 和 LIST_INSERT_HEAD

    struct entry *n1, *n2, *n3, *np;
    struct listhead head;                   /* List head */
    int i;

    LIST_INIT(&head);                       /* Initialize the list */

    n1 = malloc(sizeof(struct entry));      /* Insert at the head */
    n1->data = 1; //我加的
    LIST_INSERT_HEAD(&head, n1, entries);

第 5 行就是 (&head)->lh_first = NULL; 初始化一个空的链表

第 9 行宏替换是：

        if (((n1)->entries.le_next = (&head)->lh_first) != ((void *)0)) 
            (&head)->lh_first->entries.le_prev = &(n1)->entries.le_next; 
        (&head)->lh_first = (n1); 
        (n1)->entries.le_prev = &(&head)->lh_first;

第 1 行的前半部分 ((n1)->entries.le_next = (&head)->lh_first) 和第 3 行完成头插

第一行的后半部分判断原先是不是空链表，如果是，if 条件不成立，否则会执行第 2 行。

第 4 行：让 n1 的 entries.le_prev 指向 (&head)->lh_first；lh_first 的类型是 struct entry *，而 le_prev 的类型是 struct entry **

第 2 行不好理解，让插入前的第一个节点的 entries.le_prev 指向 n1 的 entries.le_next。

所以，le_prev 被定义成 struct entry ** 就可以理解了，作者的意图是让它指向 struct entry * 类型，比如 lh_first 和 le_next

这时候再看本文开头的图，就理解了。

请添加图片描述

node 相当于是代码中的 struct entry

SLIST_INSERT_HEAD(&head, n1, entries) 的意思是：把 n1 节点插入到链表 head 的头部；第一个参数是表头的地址，第二参数是待插入的节点的地址，第三个参数是无标签结构体的成员名。

LIST_INSERT_AFTER

    n2 = malloc(sizeof(struct entry));      /* Insert after */
    n2->data = 2; //我加的
    LIST_INSERT_AFTER(n1, n2, entries);

LIST_INSERT_AFTER(n1, n2, entries) 表示把节点 n2 插入到 n1 的后面。

第 3 行，宏替换后是

    if (((n2)->entries.le_next = (n1)->entries.le_next) != ((void *)0)) 
        (n1)->entries.le_next->entries.le_prev = &(n2)->entries.le_next; 
    (n1)->entries.le_next = (n2); 
    (n2)->entries.le_prev = &(n1)->entries.le_next;

把节点 n2 插入到 n1 的后面，我们看看哪些指针要改变

  1. n1 的 entries.le_next
  2. n2 的 entries.le_next
  3. n2 的 entries.le_prev
  4. 插入之前 n1 后面的那个节点（就叫它 n0 吧）的 entries.le_prev；如果 n0 等于 NULL，就不需要考虑了

第 1 行的 (n2)->entries.le_next = (n1)->entries.le_next 解决的是 2

第 2 行代码解决的是 4

第 3 行代码解决了 1

第 4 行代码解决了 3

LIST_INSERT_BEFORE

    n3 = malloc(sizeof(struct entry));      /* Insert before */
    n3->data = 3; //我加的
    LIST_INSERT_BEFORE(n2, n3, entries);

LIST_INSERT_BEFORE(n2, n3, entries) 意思是把 n3 插入到 n2 的前面

第 3 行宏替换后是：

  (n3)->entries.le_prev = (n2)->entries.le_prev; 
  (n3)->entries.le_next = (n2); 
  *(n2)->entries.le_prev = (n3); 
  (n2)->entries.le_prev = &(n3)->entries.le_next;

把 n3 插入到 n2 的前面，我们看看哪些指针要改变

  1. n2 的 entries.le_prev
  2. n3 的 entries.le_next
  3. n3 的 entries.le_prev
  4. 在插入 n3 之前， n2 前面的那个节点（就叫它 n1 吧）的 entries.le_next；

第 1 行解决了 3

第 2 行解决了 2

第 3 行解决了 4，这个有点复杂。(n2)->entries.le_prev 指向 n1 的 entries.le_next，对 (n2)->entries.le_prev 解引用，得到的就是 n1 的 entries.le_next，插入后，因为 n1 的后面是 n3，所以 n1 的 entries.le_next = n3;

第 4 行解决了 1

LIST_FOREACH

    /* Forward traversal */
    LIST_FOREACH(np, &head, entries)
        printf("%i\n", np->data);

宏展开后是：

for ((np) = ((&head)->lh_first); (np); (np) = ((np)->entries.le_next))
    printf("%i\n", np->data);

遍历每个节点，这个比较好懂。

注意，这种遍历是不能删除的，因为如果把 np 指向的节点删除了，

(np) = ((np)->entries.le_next) 这句就不对了。

LIST_FOREACH(np, &head, entries) 用来遍历链表的每个节点。第一个参数是临时变量，指向当前的节点，第二个参数是表头的地址，第三个 entries 是无标签结构体的成员名。

LIST_REMOVE

LIST_REMOVE(n2, entries);               /* Deletion */

宏替换后是

  if ((n2)->entries.le_next != ((void *)0)) 
      (n2)->entries.le_next->entries.le_prev = (n2)->entries.le_prev; 
  *(n2)->entries.le_prev = (n2)->entries.le_next;

要删除 n2，我们看看哪些指针要改变

  1. n2 前面的那个节点（假设是 n1）的 entries.le_next
  2. n2 后面的那个节点（假设是 n3）的 entries.le_prev；如果 n3 是 NULL，那就不用了

第 3 行解决了 1

1-2 行解决了 2

LIST_FIRST 和 LIST_NEXT

    n1 = LIST_FIRST(&head);
    while (n1 != NULL) {
        n2 = LIST_NEXT(n1, entries);
        free(n1);
        n1 = n2;
    }

1：展开后是 n1 = ((&head)->lh_first);

LIST_FIRST(&head) 表示取链表的第一个节点

3：展开后是 n2 = ((n1)->entries.le_next);

LIST_NEXT(n1, entries) 表示取节点 n1 的下一个节点

参考资料

https://manpages.courier-mta.org/htmlman3/list.3.html

车子 chezi
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
libevent-双向链表
lingshengxiyou的博客
01-29 164
LinuxC/C++服务器开发/架构师 面试题、学习资料、教学视频和学习路线图（资料包括C/C++，Linux，Nginx，ZeroMQ，MySQL，Redis、MongoDB，ZK，流媒体，CDN，P2P，K8S，Docker，TCP/IP，协程，DPDK等），或点击这里加。我思考之后的答案是：哨兵节点只需要前驱后继指针，不需要是一个数据节点的类型，降低内存分配。通常是定义一个内置的成员类型，类型的成员就是前驱后继的指针信息，然后在数据节点中引入该类型，然后利用特定的指针操作定位数据节点的起始地址。
Libevent源码分析-----TAILQ_QUEUE队列
热门推荐
luotuo44的专栏
08-04 1万+
Libevent源码中有一个queue.h文件，位于compat/sys目录下。该文件里面定义了5个数据结构，其中TAILQ_QUEUE是使得最广泛的。本文就说一下这个数据结构。 TAILQ_QUEUE由下面两个结构体一起配合工作。
QT代码实现list链表结构
03-23
QT代码实现list链表结构，资源中包含单向链表和双向链表
danlianbiao.rar_Linked list_链表
09-23
利用c#语言实现对单链表的操作，包括单链表的反转、单链表的删除、单链表的插入等等。
Linux 链表示例 LIST_INIT LIST_INSERT_HEAD
最新发布
fareast_mzh的博客
09-23 698
LIST_EMPTY, LIST_ENTRY, LIST_FIRST, LIST_FOREACH, LIST_HEAD, LIST_HEAD_INITIALIZER, LIST_INIT, LIST_INSERT_AFTER, LIST_INSERT_BEFORE, LIST_INSERT_HEAD, LIST_NEXT, LIST_REMOVE - implementation of a doubly linked list
双链表（二）
jiangxt211的专栏
11-11 156
#ifndef _MY_HLIST_H #define _MY_HLIST_H typedef struct hlist_node { struct hlist_node *next; /* next element */ struct hlist_node **pprev; /* address of previous next element */ } HNODE; t...
单向列表(single-linked lists)、单向尾队列(single-linked tail queue)、列表(lists)、尾队列(tail queues)
why is this
10-14 3172
转载：https://www.freebsdchina.org/forum/viewtopic.php?t=37913 queue和list是freebsd内核中很基础的数据结构，在内核代码的很多地方都用到，下面是小弟的一点心得，不对的地方希望大家指教，谢~~.  queue和list的结构定义和操作都在'sys/queue.h'中完成，内容并不多，主要定义了下面四种数据结构：  单向列
libevent中的基本数据结构
多看多听多总结
05-05 1303
libevent中文件queue.c文件包含5种数据结构：单链表，双向链表，队列，尾队列，环形队列。在处理I/O和signal中的事件时，用的就是尾队列，下面就介绍这几种数据结构 1、单链表 链表头用宏SLIT_HEAD来定义 #define SLIST_HEAD(name, type) \ struct name { \ struct
链表之TAILQ
车子（chezi）
02-13 2162
文章目录TAILQ 介绍头文件举例代码分析TAILQ_ENTRY 和 TAILQ_HEADTAILQ_INITTAILQ_INSERT_HEADTAILQ_INSERT_TAILTAILQ_INSERT_AFTERTAILQ_INSERT_BEFORETAILQ_REMOVETAILQ_FOREACHTAILQ_FOREACH_REVERSE参考资料 TAILQ 介绍 TAILQ 队列是 FreeBSD 内核中的一种队列数据结构，在一些著名的开源库中(如 DPDK、libevent)有广泛的应用。 TAI
TAILQ 详解
u010386121的博客
05-17 2901
最近在看乐鑫ESP-ADF框架，发现该框架用到TAILQ 双向链表，于是我网上找了大量资料，总结这一篇东西。 定义： TAILQ 是链表结构，使用大量宏定义去代表链表结构处理，源码在#include <sys/queue.h> 常用API TAILQ_HEAD 定义队列头 TAILQ_ENTRY 队列实体定义 TAILQ_INIT 初始化队列 TAILQ_FOREACH 对队列进行遍历操作 TAILQ_INSERT_BEFORE ..
详解linux内核链表之list.h
12-14
深入内核，必备知识。
双向链表list.c
01-23
为《仿照linux内核的链表构造并遍历》一文写的测试源文件，文章链接https://blog.csdn.net/eidolon_foot/article/details/112998927。 文件里面有链表声明和初始化、判断...在linux下用gcc list.c编译，./a.out运行。
linux内核链表list.h
05-17
内核链表
List链表.ipynb
05-16
基于Python的list实现的链表结构。由于不必按顺序存储，链表在插入的时候可以达到O⑴的复杂度，比另一种线性表：顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n）的时间，而顺序表相应的时间复杂度...
stm32f103 双向链表
08-16
使用stm32f103 建立双向链表demo，适用所有链表情况，非常好用，链表部分采用了Linux list
Java链表（Linked List）基本原理与实现方法入门示例
08-19
主要介绍了Java链表（Linked List）基本原理与实现方法,结合实例形式分析了Java链表（Linked List）的功能、原理、实现方法与操作注意事项,需要的朋友可以参考下
C++实现双向链表（List）
08-19
主要为大家详细介绍了C++实现双向链表，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
C语言之线性链表1
08-08
//返回data元素#endif3.0、线性链表之List.cList.h的实现#include <stdio.h>#include <malloc.h>#in
StudentList.zip_链表
09-24
基于VS的一个简单的单向链表算法，可以添加、删除节点
c语言单向链表insertlist
09-20
单向链表是一种常见的数据结构，可以动态地存储一系列节点。每个节点包含数据和指向下一个节点的指针。 在C语言中，可以通过定义一个表示节点的结构体来实现单向链表： ```c struct Node { int data; struct Node* next; }; ``` 其中 `data` 用于存储节点的数据，`next` 指向下一个节点。链表的头节点可以通过一个指针来表示： ```c struct Node* head = NULL; ``` 现在，我们来实现插入节点的功能。 首先，需要创建一个新的节点，并为其分配内存空间： ```c struct Node* newNode = (struct Node*)malloc(sizeof(struct Node)); ``` 然后，可以给节点的 `data` 赋值： ```c newNode->data = newData; ``` 接下来，将新节点插入到链表中。 如果链表是空的，即头节点为 `NULL`，那么将新节点作为头节点： ```c if (head == NULL) { head = newNode; newNode->next = NULL; } ``` 否则，需要找到插入位置的前一个节点，将其 `next` 指向新节点，同时将新节点的 `next` 指向原来的后续节点： ```c else { struct Node* temp = head; while (temp->next != NULL) { temp = temp->next; } temp->next = newNode; newNode->next = NULL; } ``` 最后，记得要释放新节点的内存空间，以防止内存泄漏： ```c free(newNode); ``` 这样，就完成了单向链表的节点插入操作。 需要注意的是，在实际中，还需要考虑边界条件、异常情况的处理等，以确保代码的健壮性和可靠性。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值