通用双向链表的C语言实现

最新推荐文章于 2024-05-25 16:12:13 发布
最新推荐文章于 2024-05-25 16:12:13 发布
阅读量2.9k 收藏 4
点赞数
文章标签： 语言 c 数据结构 null 扩展 windows
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/EricLogic/article/details/3747590
版权

双向链表是一种基本的数据结构，在许多场合都会使用到。最近正在编写一个基于Linux的GUI系统，里边许多地方都要使用到双向链表，于是写了一个通用的双向链表。代码如下：

  1. #ifndef __STDLIST_H__
  2. #define __STDLIST_H__
  4. typedef struct tagSTDNODE       STDNODE, *LPSTDNODE;
  5. typedef struct tagSTDLIST       STDLIST, *LPSTDLIST;
  7. // 链表数据结构
  8. struct tagSTDNODE {
  9.     LPSTDNODE           lpPrev;
  10.     LPSTDNODE           lpNext;
  11. };
  13. // 链表节点结构
  14. struct tagSTDLIST {
  15.     LPSTDNODE           lpHead;
  16.     LPSTDNODE           lpTail;
  17. };
  19. // 用于链表扩展的宏
  20. #define NODE_INITIALIZER    ((STDNODE){ .lpPrev = NULL, .lpNext = NULL, })
  21. #define LIST_INITIALIZER    ((STDLIST){ .lpHead = NULL, .lpTail = NULL, })
  22. #define DECLARELISTNODE()　　STDNODE __snStdNode
  23. #define INIT_LISTNODE()     __snStdNode = NODE_INITIALIZER
  25. // 初始化链表
  26. STATIC INLINE
  27. LPSTDLIST       TWINAPI     StdListInit(
  28.                             LPSTDLIST lpList
  29.                             ) {
  30.     lpList->lpHead  = NULL;
  31.     lpList->lpTail  = NULL;
  32.     return lpList;
  33. }
  35. // 获取链表头部节点
  36. STATIC INLINE
  37. LPSTDNODE       TWINAPI     StdListGetHeadNode(
  38.                             LPSTDLIST lpList
  39.                             ) {
  40.     return lpList->lpHead;
  41. }
  43. // 获取链表尾部节点
  44. STATIC INLINE
  45. LPSTDNODE       TWINAPI     StdListGetTailNode(
  46.                             LPSTDLIST lpList
  47.                             ) {
  48.     return lpList->lpTail;
  49. }
  51. // 获取给定节点的下一个节点
  52. STATIC INLINE
  53. LPSTDNODE       TWINAPI     StdListGetNextNode(
  54.                             LPSTDNODE lpNode
  55.                             ) {
  56.     return lpNode->lpNext;
  57. }
  59. // 获取给定节点的上一个节点
  60. STATIC INLINE
  61. LPSTDNODE       TWINAPI     StdListGetPrevNode(
  62.                             LPSTDNODE lpNode
  63.                             ) {
  64.     return lpNode->lpPrev;
  65. }
  67. // 在链表头部插入一个节点
  68. STATIC INLINE
  69. VOID            TWINAPI     StdListPushFront(
  70.                             LPSTDLIST lpList,
  71.                             LPSTDNODE lpNode
  72.                             ) {
  73.     lpNode->lpPrev  = NULL;
  74.     lpNode->lpNext  = lpList->lpHead;
  75.     if(lpList->lpHead)
  76.         lpList->lpHead->lpPrev  = lpNode;
  77.     else
  78.         lpList->lpTail  = lpNode;
  79.     lpList->lpHead  = lpNode;
  80. }
  82. // 在链表尾部插入一个节点
  83. STATIC INLINE
  84. VOID            TWINAPI     StdListPushBack(
  85.                             LPSTDLIST lpList,
  86.                             LPSTDNODE lpNode
  87.                             ) {
  88.     lpNode->lpNext  = NULL;
  89.     lpNode->lpPrev  = lpList->lpTail;
  90.     if(lpList->lpTail)
  91.         lpList->lpTail->lpNext  = lpNode;
  92.     else
  93.         lpList->lpHead  = lpNode;
  94.     lpList->lpTail  = lpNode;
  95. }
  97. // 在指定节点后插入一个节点
  98. STATIC INLINE
  99. VOID            TWINAPI     StdListInsert(
  100.                             LPSTDLIST lpList,
  101.                             LPSTDNODE lpAfter,
  102.                             LPSTDNODE lpNode
  103.                             ) {
  104.     if(lpAfter) {
  105.         if(lpAfter->lpNext)
  106.             lpAfter->lpNext->lpPrev = lpNode;
  107.         else
  108.             lpList->lpTail  = lpNode;
  109.         lpNode->lpPrev  = lpAfter;
  110.         lpNode->lpNext  = lpAfter->lpNext;
  111.         lpAfter->lpNext = lpNode;
  112.     } else {
  113.         StdListPushFront(lpList, lpNode);
  114.     }
  115. }
  117. // 从链表头部弹出一个节点
  118. STATIC INLINE
  119. LPSTDNODE       TWINAPI     StdListPopFront(
  120.                             LPSTDLIST lpList
  121.                             ) {
  122.     if(lpList->lpHead) {
  123.         LPSTDNODE lpNode    = lpList->lpHead;
  124.         if(lpList->lpHead->lpNext)
  125.             lpList->lpHead->lpNext->lpPrev  = NULL;
  126.         else
  127.             lpList->lpTail  = NULL;
  128.         lpList->lpHead  = lpList->lpHead->lpNext;
  129.         lpNode->lpPrev  = lpNode->lpNext    = NULL;
  130.         return lpNode;
  131.     } else {
  132.         return NULL;
  133.     }
  134. }
  136. // 从链表尾部弹出一个节点
  137. STATIC INLINE
  138. LPSTDNODE       TWINAPI     StdListPopBack(
  139.                             LPSTDLIST lpList
  140.                             ) {
  141.     if(lpList->lpTail) {
  142.         LPSTDNODE lpNode    = lpList->lpTail;
  143.         if(lpList->lpTail->lpPrev)
  144.             lpList->lpTail->lpPrev->lpNext  = NULL;
  145.         else
  146.             lpList->lpHead  = NULL;
  147.         lpList->lpTail  = lpList->lpTail->lpPrev;
  148.         lpNode->lpPrev  = lpNode->lpNext    = NULL;
  149.         return lpNode;
  150.     } else {
  151.         return NULL;
  152.     }
  153. }
  155. // 从链表中删除给定节点
  156. STATIC INLINE
  157. LPSTDNODE       TWINAPI     StdListRemove(
  158.                             LPSTDLIST lpList,
  159.                             LPSTDNODE lpNode
  160.                             ) {
  161.     if(lpNode->lpPrev)
  162.         lpNode->lpPrev->lpNext  = lpNode->lpNext;
  163.     else
  164.         lpList->lpHead  = lpNode->lpNext;
  165.     if(lpNode->lpNext)
  166.         lpNode->lpNext->lpPrev  = lpNode->lpPrev;
  167.     else
  168.         lpList->lpTail  = lpNode->lpPrev;
  169.     return lpNode;
  170. }
  172. // 检查链表是否为空
  173. STATIC INLINE
  174. BOOL            TWINAPI     StdListIsEmpty(
  175.                             LPSTDLIST lpList
  176.                             ) {
  177.     if(lpList->lpHead || lpList->lpTail)
  178.         return FALSE;
  179.     else
  180.         return TRUE;
  181. }
  183. // 获取链表中的节点数
  184. STATIC INLINE
  185. LONG            TWINAPI     StdListGetSize(
  186.                             LPSTDLIST lpList
  187.                             ) {
  188.     LONG lnSize = 0;
  189.     LPSTDNODE lpNode    = StdListGetHeadNode(lpList);
  190.     while(lpNode) {
  191.         ++ lnSize;
  192.         lpNode  = StdListGetNextNode(lpNode);
  193.     }
  194.     return lnSize;
  195. }
  197. // 合并两个链表
  198. STATIC INLINE
  199. LPSTDLIST       TWINAPI     StdListCombine(
  200.                             LPSTDLIST lpList1,
  201.                             LPSTDLIST lpList2
  202.                             ) {
  203.     if(!StdListIsEmpty(lpList2)) {
  204.         if(!StdListIsEmpty(lpList1)) {
  205.             lpList1->lpTail->lpNext = lpList2->lpHead;
  206.             lpList2->lpHead->lpPrev = lpList1->lpTail;
  207.             lpList1->lpTail = lpList2->lpTail;
  208.         } else {
  209.             lpList1->lpHead = lpList2->lpHead;
  210.             lpList1->lpTail = lpList2->lpTail;
  211.         }
  212.         lpList2->lpHead = lpList2->lpTail   = NULL;
  213.     }
  214.     return lpList1;
  215. }
  217. #endif//__STDLIST_H__

算法本身没有什么特别的地方，为什么说这是一个通用双向链表呢？奥妙就在那四个用于扩展的宏。利用这几个宏你可以将这个双向链表扩展到任意结构。

例如，我们要实现一个消息队列，那么我们可以这样定义消息节点：

  1. typedef struct tagMSGNODE {
  2.     DECLARELISTNODE();
  3.     HWND        hWnd;
  4.     UINT        uMsg;
  5.     WPARAM      wParam;
  6.     LPARAM      lParam;
  7. } MSGNODE, *LPMSGNODE;

而消息队列则可以直接用LISTNODE结构来表示：

  1. STDLIST     lstMsgQueue;

这样我们就可以用刚刚定义的函数来对这个消息队列进行操作了：

  1. // 向消息队列插入一个消息
  2. LPMSGNODE lpMsgNode = MemAlloc(SIZEOF(MSGNODE));
  3. lpMsgNode->INIT_LISTNODE();
  4. lpMsgNode->hWnd     = hWnd;
  5. lpMsgNode->uMsg     = WM_PAINT;
  6. lpMsgNode->wParam   = NULL;
  7. lpMsgNode->lParam   = NULL;
  8. StdListPushBack(&lstMsgQueue, (LPSTDNODE)lpMsgNode);
  10. // 从消息队列取出一个消息
  11. LPMSGNODE lpMsgNode = (LPMSGNODE)StdListPopFront(&lstMsgQueue);
  13. // 删除所有属于hWnd的消息
  14. LPMSGNODE lpTemp    = (LPMSGNODE)StdListGetHeadNode(&lstMsgQueue);
  15. while(lpTemp) {
  16.     LPMSGNODE lpNext    = (LPMSGNODE)StdListGetNextNode(&lstMsgQueue, (LPSTDNODE)lpTemp);
  17.     if(lpTemp->hWnd == hWnd) {
  18.         StdListRemove(&lstMsgQueue, (LPSTDNODE)lpTemp);
  19.                 MemFree(lpTemp);
  20.         }
  21.     lpTemp  = lpNext;
  22. }

是不是很方便呢^_^。

 

备注：

由于正在编写的GUI是参考Windows的体系结构，所以代码风格采用了微软的风格。

代码中的MemAlloc,MemFree函数以及各种数据结构均在其他地方定义。

 

 

EricLogic
关注
利用通用双向链表实现队列
Orange_pa的博客
08-16 348
C语言是没有封装好的通用队列的，所以我们要用队列，必须自己实现。本篇笔记利用的是面向对象的编程方法，把函数体结果放在C_queueOperation的结构体中，调用指针，封装对象和操作，实现通用链表下的队列。...
数据结构 | 通用数据类型双向链表（C语言）
一砚梨花雨
11-22 1187
目录前言设计思路代码展示测试环节 前言 熟悉C++的STL(标准模板库)的人都知道list底层是一个双向链表，支持通用类型数据的存储，使用起来非常方便，但对于C语言开发者来说，并没有这么方便的工具，所以在这里记录一下自己实现的通用数据类型双向链表，提供了一些常见的API，并分享一些常见的代码规范。 设计思路 这里我们不便过多地讨论双向链表的实现过程，我们重点看如何解决下面几个问题 1. 如何解决通用类型的数据存储 2. 如何保证代码的严谨性，健壮性 3. 如何实现数据结构的高复用，低耦合 1.通过
c语言实现的双向链表
07-31
用心去写的，codeblocks下经过很多测试，程序不会崩，visual studio下经过少量修改即可运行
C语言实现通用链表初步(四)----双向链表
weixin_30242907的博客
05-19 167
在前面的文章中，我们讨论了如何实现通用类型的链表，方法是用void *类型的指针，指向数据。那么还有其他的方法吗（不考虑内核链表）？ 答案是肯定的。用零长数组也可以实现。 struct node_info { struct node_info *next; struct node_info *prev; char data[0]; }; 这里的最后一个元素，是元素个...
C语言实现通用双向链表
Orange_pa的博客
08-08 576
双向链表的通用实现和测试用例
C语言通用双向循环链表操作函数集
weixin_33884611的博客
06-20 465
  说明      相比Linux内核链表宿主结构可有多个链表结构的优点，本函数集侧重封装性和易用性，而灵活性和效率有所降低。     可基于该函数集方便地构造栈或队列集。     本函数集暂未考虑并发保护。   一  概念      链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序通过链表中的指针链接次序实现。链表由一系列存储结点组成，结点可在运行时动态生成。每个结...
双向链表---C语言实现
最新发布
2302_80106957的博客
05-25 1142
双向链表的结点由三个部分组成，一个部分用来保存当前节点存储的数据，一个部分用来保存下一个结点的地址，即next指针，还有一个部分用来保存前一个节点的地址，即prev指针。有了next指针和prev指针，我们才能实现双向和循环。//当前节点存储的数据//指向前一个节点的指针//指向下一个节点的指针}LTNode;
C语言实现通用双向链表标准版.rar
08-12
本资源“C语言实现通用双向链表标准版.rar”提供了一个使用C语言实现的通用双向链表实例，这对于理解和掌握数据结构，尤其是链表操作具有重要意义。 双向链表是一种线性数据结构，与单向链表不同，它允许节点在两个...
C语言标准通用双向链表实现与代码解析
资源摘要信息: "该压缩包包含的文件是关于用C语言实现通用双向链表的培训资料，适合在Linux操作系统环境下学习和应用。文件中详细地介绍了双向链表的原理和C语言的实现方法。双向链表是一种链表数据结构，在每个节点...
Linux操作系统中通用双向循环链表的实现分析.pdf
09-06
Linux操作系统中通用双向循环链表的实现分析 Linux操作系统是一个支持多用户、多任务、多线程和多CPU的开源操作系统，其内核功能强大、性能稳定并具有丰富的应用软件支持。Linux内核源代码主要由C语言和少量的汇编...
通用双向链表
05-12
通用双向链表，数据类型通用化。更高级的做法是节点话，链表节点中剥离数据，这也是软件工程中常用方法。
双向链表C语言实现
12-13
通过双向链表实现按照ID序列插入，可以排序实现插入、删除、更新、修改；
C语言实现双向链表
Yz529的博客
05-31 352
双向链表与单链表基本上类似，只是在删除和插入时有所不同因为其一个节点中多了一个指向其前驱的头指针，注意在插入和删除一个元素时，通用的插入和删除操作对最后一个元素不起作用，即不能在最后一个元素的后面继续插入元素（能通过尾插法插入），不能删除最后一个元素（能通过查找到最后一个元素，直接将其释放），在双向链表的创建时，若用头插法，需要注意第一个节点元素的插入与后续的节点插入的方法不一样，因为第一个节点元素在插入时并没有后继元素。 #include <stdio.h> #include <stdl
C语言通用双向链表的实现--设计的艺术
ecorefeng的专栏
08-13 5569
专用链表在这里是指该链表的实现和调用耦合在一起，只能被一个调用者使用，而不能单独在其他地方被重用。通用链表则相反，它具有通用性，可以在多处被重复使用。尽管通用链表相对专用链表来说有很多优越之处，不过草率地断定通用链表比专用链表好也是不公正的，因为它们都有自己的优点和适用范围。     专用链表的优点 　　性能更高。专用链表的实现和调用在一起，可以直接访问数据成员，省去了包装函数带来的性能开销，可以提高时间性能。专用链表无需实现完整的接口，只要满足自己的需要就行了，生成的代码更小，因此可以提高空间性能。
实现通用的双向链表（c语言实现）
echo_bright_的博客
10-16 8334
国庆8天在家阅读李先静大神的书籍，抽空把一些笔记记录下来。从实现一个通用的双向链表开始。 1. 构建链表节点   链表节点存值还是存值的地址(指针)？对于通用链表首先要做到能够存放任何数据类型的数据，首先可能会想到的是union，但是数据类型无穷无尽，不可能在union中全部表示。那么可行的办法有两种：   (1) 存值 typedef struct _DListNode DLis
c语言 链表_keil实现C语言的通用双向链表
weixin_39831104的博客
11-29 571
1、前言链表是数据结构中非常重要的一个知识点，比较经典的就是C语言的链表，在学校也有这门课程，非计算机专业的朋友可能没学到这一章就毕业了(呵呵)，在这里可以和我一起学习。因为个人偏好对链表的知识也没有面面俱到，全面的链表知识请多方查证学习。这篇文章主要介绍一个通用双向链表，之所以叫通用因为链表本身不包含特定应用层的设计，只是将多个节点连接起来组成一条链的结构，每个节点挂载的"内容"是应用层的设计。...
一个通用的双向链表
m0_37896011的博客
09-11 1105
是在看《系统程序员成长计划》.(李先静).[PDF》第一章  编写一个通用的双向链表之后，觉得很有意义  便把自己的思路以及部分代码写成这篇博客 先说说要求： 所谓通用 ， 链表能够保存所有类型的值  不仅仅是 整型 char 型 字符串类型 还有结构体类型  ， 1.0 版本想法是  typedef  ,重命名的方法很方便  但不是真正意义上的通用 2.0 版本想法是 void*
C语言中如何使用通用双向链表
hzy_76的专栏
07-04 1068
通用双向链表，指的是通过一个通用的数据结构，然后添加特定数据形成有具体用途的链表。这主要涉及到代码复用，在C++中实现非常方便，只需要定义一个双向链表的类，每一个具体业务只需要继承它，然后添加自己的数据成员即可。但有时候我们需要用C语言而不是C++，那么该如何实现这种层次关系呢？首先我们来看两个宏。 第一个是offsetof(可参考Linux内核代码include/linux/Stddef.h)：
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值