各种链表队列的宏操作及应用

最新推荐文章于 2021-11-26 21:01:21 发布
最新推荐文章于 2021-11-26 21:01:21 发布
阅读量542 收藏 2
点赞数 2
分类专栏： C/C++ 文章标签： 链表 嵌入式 队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_22237829/article/details/73825731
版权

链表队列的宏操作参考自libevent，这种链表的宏操作非常容易移植，现在我将它记录下来。所有例子的代码请前往各种链表队列宏操作的应用例子免积分下载。

Singly-linked List


 
/*
 * Singly-linked List definitions.
 */
#define SLIST_HEAD(name, type)						\
struct name {								\
	struct type *slh_first;	/* first element */			\
}

#define	SLIST_HEAD_INITIALIZER(head)					\
	{ NULL }

#ifndef WIN32
#define SLIST_ENTRY(type)						\
struct {								\
	struct type *sle_next;	/* next element */			\
}
#endif

/*
 * Singly-linked List access methods.
 */
#define	SLIST_FIRST(head)	((head)->slh_first)
#define	SLIST_END(head)		NULL
#define	SLIST_EMPTY(head)	(SLIST_FIRST(head) == SLIST_END(head))
#define	SLIST_NEXT(elm, field)	((elm)->field.sle_next)

#define	SLIST_FOREACH(var, head, field)					\
	for((var) = SLIST_FIRST(head);					\
	    (var) != SLIST_END(head);					\
	    (var) = SLIST_NEXT(var, field))

/*
 * Singly-linked List functions.
 */
#define	SLIST_INIT(head) {						\
	SLIST_FIRST(head) = SLIST_END(head);				\
}

#define	SLIST_INSERT_AFTER(slistelm, elm, field) do {			\
	(elm)->field.sle_next = (slistelm)->field.sle_next;		\
	(slistelm)->field.sle_next = (elm);				\
} while (0)

#define	SLIST_INSERT_HEAD(head, elm, field) do {			\
	(elm)->field.sle_next = (head)->slh_first;			\
	(head)->slh_first = (elm);					\
} while (0)

#define	SLIST_REMOVE_HEAD(head, field) do {				\
	(head)->slh_first = (head)->slh_first->field.sle_next;		\
} while (0)

示意图如下，我用visio软件简单的画了下载。



写了一个简单的应用。 

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "queue.h"

#define SIZEOF(array)    (sizeof(array)/sizeof(array[0]))

struct student{
    SLIST_ENTRY(student) next;
    char name[16];
    int score;

};
static struct stu{
    char name[16];
    int score;
}stuArray[]={
        {"Yancy Lin",88},
        {"Tom Lee",89},
        {"Rose Li",100},
        {"Thomas Ye",58},
        {"Rick Huang",79},
        {"Nike Wong",65},
};

int main() {
    int i;
    SLIST_HEAD(headname,student) head;
    SLIST_INIT(&head);
  //  SLIST_HEAD(headname,student) head=SLIST_HEAD_INITIALIZER(head);
    /**
     * 或者使用下面声明初始化，一次性搞定
     * SLIST_HEAD(headname,student) head=SLIST_HEAD_INITIALIZER(head);
     */
    struct student * tmp;
    /* 往head链表里添加一node节点 */
    for(i=0;i<SIZEOF(stuArray);i++)
    {
        tmp = (struct student *)malloc(sizeof(struct student));
        memcpy(tmp->name,stuArray[i].name,strlen(stuArray[i].name));
        tmp->score = stuArray[i].score;

        SLIST_INSERT_HEAD(&head,tmp,next);//往链表头部添加节点node
    }

    printf("traversing Singly-linked List using SLIST_FOREACH:\n");
    /* 遍历链表 */
    SLIST_FOREACH(tmp,&head,next)
    {
        printf("%s:%d\n",tmp->name,tmp->score);
    }
    printf("\n");
    printf("freeing Singly-linked List using SLIST_REMOVE_HEAD:\n");
    /* 释放node */
    while ((tmp = SLIST_FIRST(&head))) {
        SLIST_REMOVE_HEAD(&head,next);
        printf("%s:%d\n",tmp->name,tmp->score);
        free(tmp);
    }

    return 0;
}



List

/*
 * List definitions.
 */
#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 access methods
 */
#define	LIST_FIRST(head)		((head)->lh_first)
#define	LIST_END(head)			NULL
#define	LIST_EMPTY(head)		(LIST_FIRST(head) == LIST_END(head))
#define	LIST_NEXT(elm, field)		((elm)->field.le_next)

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

/*
 * List functions.
 */
#define	LIST_INIT(head) do {						\
	LIST_FIRST(head) = LIST_END(head);				\
} while (0)

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

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

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

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

#define LIST_REPLACE(elm, elm2, field) do {				\
	if (((elm2)->field.le_next = (elm)->field.le_next) != NULL)	\
		(elm2)->field.le_next->field.le_prev =			\
		    &(elm2)->field.le_next;				\
	(elm2)->field.le_prev = (elm)->field.le_prev;			\
	*(elm2)->field.le_prev = (elm2);				\
} while (0)

示意图如下：



示例代码就不粘贴了，请在开头我所说的地址下载就行了。

Simple queue


 
/*
 * Simple queue definitions.
 */
#define SIMPLEQ_HEAD(name, type)					\
struct name {								\
	struct type *sqh_first;	/* first element */			\
	struct type **sqh_last;	/* addr of last next element */		\
}

#define SIMPLEQ_HEAD_INITIALIZER(head)					\
	{ NULL, &(head).sqh_first }

#define SIMPLEQ_ENTRY(type)						\
struct {								\
	struct type *sqe_next;	/* next element */			\
}

/*
 * Simple queue access methods.
 */
#define	SIMPLEQ_FIRST(head)	    ((head)->sqh_first)
#define	SIMPLEQ_END(head)	    NULL
#define	SIMPLEQ_EMPTY(head)	    (SIMPLEQ_FIRST(head) == SIMPLEQ_END(head))
#define	SIMPLEQ_NEXT(elm, field)    ((elm)->field.sqe_next)

#define SIMPLEQ_FOREACH(var, head, field)				\
	for((var) = SIMPLEQ_FIRST(head);				\
	    (var) != SIMPLEQ_END(head);					\
	    (var) = SIMPLEQ_NEXT(var, field))

/*
 * Simple queue functions.
 */
#define	SIMPLEQ_INIT(head) do {						\
	(head)->sqh_first = NULL;					\
	(head)->sqh_last = &(head)->sqh_first;				\
} while (0)

#define SIMPLEQ_INSERT_HEAD(head, elm, field) do {			\
	if (((elm)->field.sqe_next = (head)->sqh_first) == NULL)	\
		(head)->sqh_last = &(elm)->field.sqe_next;		\
	(head)->sqh_first = (elm);					\
} while (0)

#define SIMPLEQ_INSERT_TAIL(head, elm, field) do {			\
	(elm)->field.sqe_next = NULL;					\
	*(head)->sqh_last = (elm);					\
	(head)->sqh_last = &(elm)->field.sqe_next;			\
} while (0)

#define SIMPLEQ_INSERT_AFTER(head, listelm, elm, field) do {		\
	if (((elm)->field.sqe_next = (listelm)->field.sqe_next) == NULL)\
		(head)->sqh_last = &(elm)->field.sqe_next;		\
	(listelm)->field.sqe_next = (elm);				\
} while (0)

#define SIMPLEQ_REMOVE_HEAD(head, elm, field) do {			\
	if (((head)->sqh_first = (elm)->field.sqe_next) == NULL)	\
		(head)->sqh_last = &(head)->sqh_first;			\
} while (0)

示意图如下：



示例代码就不粘贴了，请在开头我所说的地址下载就行了。

Tail queue

/*
 * Tail queue definitions.
 */
#define TAILQ_HEAD(name, type)						\
struct name {								\
	struct type *tqh_first;	/* first element */			\
	struct type **tqh_last;	/* addr of last next element */		\
}

#define TAILQ_HEAD_INITIALIZER(head)					\
	{ NULL, &(head).tqh_first }

#define TAILQ_ENTRY(type)						\
struct {								\
	struct type *tqe_next;	/* next element */			\
	struct type **tqe_prev;	/* address of previous next element */	\
}

/*
 * tail queue access methods
 */
#define	TAILQ_FIRST(head)		((head)->tqh_first)
#define	TAILQ_END(head)			NULL
#define	TAILQ_NEXT(elm, field)		((elm)->field.tqe_next)
#define TAILQ_LAST(head, headname)					\
	(*(((struct headname *)((head)->tqh_last))->tqh_last))
/* XXX */
#define TAILQ_PREV(elm, headname, field)				\
	(*(((struct headname *)((elm)->field.tqe_prev))->tqh_last))
#define	TAILQ_EMPTY(head)						\
	(TAILQ_FIRST(head) == TAILQ_END(head))

#define TAILQ_FOREACH(var, head, field)					\
	for((var) = TAILQ_FIRST(head);					\
	    (var) != TAILQ_END(head);					\
	    (var) = TAILQ_NEXT(var, field))

#define TAILQ_FOREACH_REVERSE(var, head, headname, field)		\
	for((var) = TAILQ_LAST(head, headname);				\
	    (var) != TAILQ_END(head);					\
	    (var) = TAILQ_PREV(var, headname, field))

/*
 * Tail queue functions.
 */
#define	TAILQ_INIT(head) do {						\
	(head)->tqh_first = NULL;					\
	(head)->tqh_last = &(head)->tqh_first;				\
} while (0)

#define TAILQ_INSERT_HEAD(head, elm, field) do {			\
	if (((elm)->field.tqe_next = (head)->tqh_first) != NULL)	\
		(head)->tqh_first->field.tqe_prev =			\
		    &(elm)->field.tqe_next;				\
	else								\
		(head)->tqh_last = &(elm)->field.tqe_next;		\
	(head)->tqh_first = (elm);					\
	(elm)->field.tqe_prev = &(head)->tqh_first;			\
} while (0)

#define TAILQ_INSERT_TAIL(head, elm, field) do {			\
	(elm)->field.tqe_next = NULL;					\
	(elm)->field.tqe_prev = (head)->tqh_last;			\
	*(head)->tqh_last = (elm);					\
	(head)->tqh_last = &(elm)->field.tqe_next;			\
} while (0)

#define TAILQ_INSERT_AFTER(head, listelm, elm, field) do {		\
	if (((elm)->field.tqe_next = (listelm)->field.tqe_next) != NULL)\
		(elm)->field.tqe_next->field.tqe_prev =			\
		    &(elm)->field.tqe_next;				\
	else								\
		(head)->tqh_last = &(elm)->field.tqe_next;		\
	(listelm)->field.tqe_next = (elm);				\
	(elm)->field.tqe_prev = &(listelm)->field.tqe_next;		\
} while (0)

#define	TAILQ_INSERT_BEFORE(listelm, elm, field) do {			\
	(elm)->field.tqe_prev = (listelm)->field.tqe_prev;		\
	(elm)->field.tqe_next = (listelm);				\
	*(listelm)->field.tqe_prev = (elm);				\
	(listelm)->field.tqe_prev = &(elm)->field.tqe_next;		\
} while (0)

#define TAILQ_REMOVE(head, elm, field) do {				\
	if (((elm)->field.tqe_next) != NULL)				\
		(elm)->field.tqe_next->field.tqe_prev =			\
		    (elm)->field.tqe_prev;				\
	else								\
		(head)->tqh_last = (elm)->field.tqe_prev;		\
	*(elm)->field.tqe_prev = (elm)->field.tqe_next;			\
} while (0)

#define TAILQ_REPLACE(head, elm, elm2, field) do {			\
	if (((elm2)->field.tqe_next = (elm)->field.tqe_next) != NULL)	\
		(elm2)->field.tqe_next->field.tqe_prev =		\
		    &(elm2)->field.tqe_next;				\
	else								\
		(head)->tqh_last = &(elm2)->field.tqe_next;		\
	(elm2)->field.tqe_prev = (elm)->field.tqe_prev;			\
	*(elm2)->field.tqe_prev = (elm2);				\
} while (0)

示意图如下：


示例代码就不粘贴了，请在开头我所说的地址下载就行了。

Circular queue


 

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

#define CIRCLEQ_HEAD_INITIALIZER(head)					\
	{ CIRCLEQ_END(&head), CIRCLEQ_END(&head) }

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

/*
 * Circular queue access methods
 */
#define	CIRCLEQ_FIRST(head)		((head)->cqh_first)
#define	CIRCLEQ_LAST(head)		((head)->cqh_last)
#define	CIRCLEQ_END(head)		((void *)(head))
#define	CIRCLEQ_NEXT(elm, field)	((elm)->field.cqe_next)
#define	CIRCLEQ_PREV(elm, field)	((elm)->field.cqe_prev)
#define	CIRCLEQ_EMPTY(head)						\
	(CIRCLEQ_FIRST(head) == CIRCLEQ_END(head))

#define CIRCLEQ_FOREACH(var, head, field)				\
	for((var) = CIRCLEQ_FIRST(head);				\
	    (var) != CIRCLEQ_END(head);					\
	    (var) = CIRCLEQ_NEXT(var, field))

#define CIRCLEQ_FOREACH_REVERSE(var, head, field)			\
	for((var) = CIRCLEQ_LAST(head);					\
	    (var) != CIRCLEQ_END(head);					\
	    (var) = CIRCLEQ_PREV(var, field))

/*
 * Circular queue functions.
 */
#define	CIRCLEQ_INIT(head) do {						\
	(head)->cqh_first = CIRCLEQ_END(head);				\
	(head)->cqh_last = CIRCLEQ_END(head);				\
} while (0)

#define CIRCLEQ_INSERT_AFTER(head, listelm, elm, field) do {		\
	(elm)->field.cqe_next = (listelm)->field.cqe_next;		\
	(elm)->field.cqe_prev = (listelm);				\
	if ((listelm)->field.cqe_next == CIRCLEQ_END(head))		\
		(head)->cqh_last = (elm);				\
	else								\
		(listelm)->field.cqe_next->field.cqe_prev = (elm);	\
	(listelm)->field.cqe_next = (elm);				\
} while (0)

#define CIRCLEQ_INSERT_BEFORE(head, listelm, elm, field) do {		\
	(elm)->field.cqe_next = (listelm);				\
	(elm)->field.cqe_prev = (listelm)->field.cqe_prev;		\
	if ((listelm)->field.cqe_prev == CIRCLEQ_END(head))		\
		(head)->cqh_first = (elm);				\
	else								\
		(listelm)->field.cqe_prev->field.cqe_next = (elm);	\
	(listelm)->field.cqe_prev = (elm);				\
} while (0)

#define CIRCLEQ_INSERT_HEAD(head, elm, field) do {			\
	(elm)->field.cqe_next = (head)->cqh_first;			\
	(elm)->field.cqe_prev = CIRCLEQ_END(head);			\
	if ((head)->cqh_last == CIRCLEQ_END(head))			\
		(head)->cqh_last = (elm);				\
	else								\
		(head)->cqh_first->field.cqe_prev = (elm);		\
	(head)->cqh_first = (elm);					\
} while (0)

#define CIRCLEQ_INSERT_TAIL(head, elm, field) do {			\
	(elm)->field.cqe_next = CIRCLEQ_END(head);			\
	(elm)->field.cqe_prev = (head)->cqh_last;			\
	if ((head)->cqh_first == CIRCLEQ_END(head))			\
		(head)->cqh_first = (elm);				\
	else								\
		(head)->cqh_last->field.cqe_next = (elm);		\
	(head)->cqh_last = (elm);					\
} while (0)

#define	CIRCLEQ_REMOVE(head, elm, field) do {				\
	if ((elm)->field.cqe_next == CIRCLEQ_END(head))			\
		(head)->cqh_last = (elm)->field.cqe_prev;		\
	else								\
		(elm)->field.cqe_next->field.cqe_prev =			\
		    (elm)->field.cqe_prev;				\
	if ((elm)->field.cqe_prev == CIRCLEQ_END(head))			\
		(head)->cqh_first = (elm)->field.cqe_next;		\
	else								\
		(elm)->field.cqe_prev->field.cqe_next =			\
		    (elm)->field.cqe_next;				\
} while (0)

#define CIRCLEQ_REPLACE(head, elm, elm2, field) do {			\
	if (((elm2)->field.cqe_next = (elm)->field.cqe_next) ==		\
	    CIRCLEQ_END(head))						\
		(head).cqh_last = (elm2);				\
	else								\
		(elm2)->field.cqe_next->field.cqe_prev = (elm2);	\
	if (((elm2)->field.cqe_prev = (elm)->field.cqe_prev) ==		\
	    CIRCLEQ_END(head))						\
		(head).cqh_first = (elm2);				\
	else								\
		(elm2)->field.cqe_prev->field.cqe_next = (elm2);	\
} while (0)


示意图如下：



示例代码就不粘贴了，请在开头我所说的地址下载就行了。


林英想
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
设计之美-链表与队列
双林子木
08-03 2181
数据结构概述随着计算机科学的发展，人们在计算机的各个领域创造了许多前所唯有的东西，在软件领域，在追求算法效率的同时与其紧密相连的就是数据结构。好的数据结构不仅可以有效的管理计算机中的所有数据，同时还能为为算法的设计上提供了许多意想不到的好处，因此许多高效的算法都是依赖其特定的数据结构对所操纵的数据进行组织的。即使现如今计算机硬件仍然遵循摩尔定律在高速发展着，但人类的需求总是大于硬件发展所能提供的性能
各种链表队列宏操作的应用例子
06-28
各种链表队列宏操作的应用例子，如Singly-linked List，list，simple queue，tail queue，circular queue
队列基本操作（链表）
lly17792230965的博客
07-31 210
#define _CRT_SECURE_NO_WARNINGS 1 #pragma once #include&lt;stdio.h&gt; typedef int QDataType; typedef struct QNode { QDataType data; struct QNode *pNext; } QNode; typedef struct Queue { ...
基本数据结构——队列
张军林(jun12345)的专栏
07-19 2191
引子模块中用到队列，先自己实现了一个：//队列所要包含的元素类型(简化)typedef struct packet_s{    int data;    struct packet *next;  //链表方式链接各个元素结点} packet_t;//队列类型typedef st
ns2中宏定义实现的链表LIST
ceci zhou
02-26 1407
-----------------------------------------------------------链表的定义----------------------------------------------------------- List的定义： #define LIST_HEAD(name, type) \ struct name { \ ty
Linux内核应用链表：kernel-list.zip
04-01
3. **链表操作宏**： - `list_add`: 将新节点插入到链表尾部。 - `list_add_tail`: 同上，但`list_add`是在头部插入。 - `list_del`: 删除指定节点，将其从链表中移除。 - `list_for_each_entry`: 遍历链表，...
栈和队列的基本操作实验报告.doc
10-21
在数据结构中，栈和队列是两种基本的数据结构，它们在实际应用中非常重要。本实验报告的目的是让学生掌握栈和队列的顺序存储结构和链式存储结构，并了解它们的特点和基本运算。 一、栈的基本操作 栈是一种后进先出...
c语言尾队列tailq使用示例分享
09-04
接下来，我们使用`TAILQ_FOREACH`宏遍历队列，并输出队列中的元素值。然后，我们添加一个新的元素到队列中，并输出队列中的元素值。 在删除元素时，我们使用`TAILQ_REMOVE`宏来删除队列中的元素，并释放不需要的...
FIFO.rar_c fifo_fifo_队列fifo
09-24
`FIFO.c`和`FIFO.h`提供的实现可能包括了线程安全的FIFO队列操作，如入队、出队，并且在队列满时不会覆盖数据，这在某些应用中是非常关键的。为了更好地理解这个实现，需要详细查看这两个文件的具体代码。
EXCEL的宏应用的实例
08-16
编一个EXCEL的宏 做一个查数量宏： 指定文件夹A里有N个EXCEL文档，指定文件夹B里有一个库存状况.xls的文档（见附件） 通过宏将指定文件夹A中所有的文档合并到同一个EXCEL文档，并把每个文档的标题填写到A列，通过B列编号在 库存状况.xls中查询数量,并更新到EXCEL合并文档中. 下次执行的时候,新生成的合并文档,作为N个文档中的其中一个。（但要注意，合并文档下次执行的时候A列内容不能在复制合并文档的标题了）
JS异步之宏队列与微队列
sandy_star
11-26 671
说明： JS是单线程的，所以会将每个函数都顺序压入栈中，但是并不会立即执行。 JS中用来存储执行回调函数的队列包含2个不同特定的队列 宏队列：用来保存待执行的宏任务（回调），比如：定时器回调/DOM事件回调/ajax回调 微队列：用来保存待执行的微任务（回调），比如：promise的回调/MutationsObserver的回调 JS执行时会区别这2个队列 JS引擎首先必须先执行所有的初始化同步任务代码 每次准备取出第一个宏任务执行前，都要将所有的微任务一个一个取出来执行 同步 》 微任务.
需要list_for_each_safe的原因
nomadcircle的专栏
12-22 2633
<br />#define list_for_each(pos, head) /<br />for (pos = (head)->next; prefetch(pos->next), pos != (head); /<br />pos = pos->next)<br />由定义可知，list_del(pos)(将pos的前后指针指向undefined state)panic，list_del_init(pos)(将pos前后指针指向自身)导致死循环。<br /><br />#define list_for_
list 的 foreach 遍历
qq_40279151的博客
03-28 3236
https://www.cnblogs.com/billyu/p/6118008.html
list 的forEach 方法 使用lambda 和“”::”关键字
茄子的博客
01-15 2760
public class MyTest { public static void printValur(String str){ System.out.println("print value : "+str); } public static void main(String[] args) { List<String>...
List.forEach()使用方法
jiangbin2jly的博客
04-07 3319
前言 不想写,直接看代码吧 正文 List<GridTeamTemplate> gridTeamTemplates = gridTeamTemplateMapper.selectTeam(s); List<GridTeamTemplateVO> gridTeamTemplateVOList = new ArrayList<>(); //这里...
List中ForEach探究
vincent的博客
05-02 6064
一边遍历list 可以用for 或者foreach去操作，后来发现list本身就有迭代的方法，ForEach 查看MSDN的介绍：ForEach 本身要传一个Action的委托 items.ForEach(o => { item.ChildItems.Add(o); GetInboxTree(o); ...
双链表（二）
jiangxt211的专栏
11-11 164
#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...
c语言实现 双链表的操作——头插法、尾插法、查找、插入、删除
BLOG of iJX
05-03 2617
双链表的插入操作： #include <stdio.h> #include<malloc.h> typedef struct DNode { int data; struct DNode* prior, * next; }DNode, * DLinkList; //-------头插法--------- DLinkList insert_head(DLinkLis...
InsertHeadList和CONTAINING_RECORD
※一路风尘※
03-29 551
LIST_ENTRY定义一个双向链表的数据结构： typedef struct _LIST_ENTRY { struct _LIST_ENTRY *Flink; struct _LIST_ENTRY *Blink; } LIST_ENTRY, *PLIST_ENTRY;  由函数InitializeListHead (BUEList)进行初始化。 假设需要插入某个数据...
Linux内核分析与应用课件第1章（三）Linux内源码中的双链表.pdf
最新发布
01-01
"Linux内核分析与应用课件第1章（三）Linux内源码中的双链表.pdf" 在Linux内核中，双链表是一种基础的数据结构，用于实现各种内核数据结构和功能。双链表允许从两个方向遍历，即向前和向后，这使得插入、删除和遍历...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值