0
0

一篇解双链表（0基础看）（C语言）《数据结构与算法》

谁都不能阻挡你成为更优秀的人。

序言

首先本文是和上一篇单链表有关联哈，上篇文章已经详细说明了链表的概念和分类，这里就不过多赘述了，就简单说明一下哈，链接在下面。一篇解单链表（0基础看）（C语言）《数据结构与算法》_原来45的博客-CSDN博客

上文我们讲到了链表最重要的两个分类，一个是单向不带头不循环，本篇文章就讲另一个重要的带头双向循环链表哈，废话不多说，直接看代码。

对了，这里附上作者的qq：2777137742。要是有什么问题可以在qq上面问我哈，或者文章有错误的地方，期待和大家共同讨论，因为csdn的消息有可能会遗漏哈，最后感谢你的支持。

带头双向循环链表

1. 概念

带头双向循环链表：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都

是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带

来很多优势，实现反而简单了，后面我们代码实现了就知道了。

这里我们来慢慢揭晓上文说到的实现更简单，以及单链表的缺点。缺点就直接说了，我们可以很直观得发现单链表的两个很大的缺点，一个是尾插尾删等都是需要遍历也就是说时间复杂度是O（N），但是双链表对应的都是O（1），效率之高。另一个缺点就是单链表不能找到自己的上一个节点，这都是很大的缺陷。然后我们接着看双链表实现的优势。

2. 效果展示图

3. 接口实现

还是老话，对于接口的实现我们首先是要知道要实现什么，本文是对于双链表的基本使用，所以就只实现顺序表的增删查改，还有特定位置前插入和删除特定位置值等当然代码也不一定要作者这么写，这里只是提供一种思路，废话不多说，看代码。

3.01. 本文章要实现的接口

3.02. 双链表的实现

这是命名是ListNode是与c++对应的，大家也可以和单链表SListNode对应取名DListnode，但是作者为了养成一个好的习惯就取名为了ListNode哈。

3.03. 双链表的初始化

注意这里初始化是自己指向自己，因为是循环，然后本篇文章不用二级指针（不用传地址），这里就用了一个返回值。

3.04. 打印链表

3.05. 动态申请一个节点

3.06. 头插

3.07. 尾插

3.08. 头删

3.09. 尾删

3.10. 查某个值，返回地址

3.11. 某个位置前插入数据

3.12. 删除某个位置数据

3.13. 改某个值

3.14. 销毁

总结

我们可以发现对于带头双向循环链表的实现不需要像单链表那样要去判断没有或者有一个节点的情况，结构非常之完美，可以利用头结点进行各种变化，实现也非常简单，而且也不用传地址。

这里要再解释一下为什么可以不传地址，因为我们的头没有改变，不需要改变头，这个改变指的是我们一开始传的参数plist，他是一直指向我们的头的，是指向没有变，内容可以改变，也就是说plist的前驱prev和后继next的指向和date是可以变的，这个理解很重要！

4. 源代码

test.c

  1. #include"List.h"
  3. int main()
  4. {
  5.     printf("初始化\n");
  6.     ListNode* plist = ListInit();
  7.     printf("头插 1 2 3 并打印\n");
  8.     ListPushFront(plist, 1);
  9.     ListPushFront(plist, 2);
  10.     ListPushFront(plist, 3);
  11.     ListPrint(plist);
  12.     printf("尾插4 5 6 并打印\n");
  13.     ListPushBack(plist, 4);
  14.     ListPushBack(plist, 5);
  15.     ListPushBack(plist, 6);
  16.     ListPrint(plist);
  17.     printf("头删并打印\n");
  18.     ListPopFront(plist);
  19.     ListPrint(plist);
  20.     printf("尾删并打印\n");
  21.     ListPopBack(plist);
  22.     ListPrint(plist);
  23.     printf("1前插入3并打印\n");
  24.     ListNode* pos = ListFind(plist, 1);
  25.     ListInsert(plist, pos, 3);
  26.     ListPrint(plist);
  27.     printf("2前插入8并打印\n");
  28.     pos = ListFind(plist, 2);
  29.     ListInsert(plist, pos, 8);
  30.     ListPrint(plist);
  31.     printf("删除4并打印\n");
  32.     pos = ListFind(plist, 4);
  33.     ListErase(plist, pos);
  34.     ListPrint(plist);
  35.     printf("把1改成9并打印\n");
  36.     ListChange(plist, 1, 9);
  37.     ListPrint(plist);
  38.     printf("销毁链表\n");
  39.     ListDestory(plist);
  40.     return 0;
  41. }

List.h

  1. #define _CRT_SECURE_NO_WARNINGS 1
  3. #include<stdio.h>
  4. #include<malloc.h>
  5. #include<assert.h>
  7. typedef int ListDateType;
  9. typedef struct ListNode
  10. {
  11.     struct ListNode* prev;
  12.     struct ListNode* next;
  13.     ListDateType date;
  14. }ListNode;
  16. //增删查改
  18. //初始化
  19. ListNode* ListInit();
  20. //销毁
  21. void ListDestory(ListNode* phead);
  22. //得到一个节点
  23. ListNode* BuyListNode(ListDateType x);
  24. //打印
  25. void ListPrint(ListNode* phead);
  27. //头插
  28. void ListPushFront(ListNode* phead, ListDateType x);
  29. //尾插
  30. void ListPushBack(ListNode* phead, ListDateType x);
  31. //头删
  32. void ListPopFront(ListNode* phead);
  33. //尾删
  34. void ListPopBack(ListNode* phead);
  36. //查某个值，返回地址
  37. ListNode* ListFind(ListNode* phead, ListDateType x);
  38. //改某个值
  39. void ListChange(ListNode* phead, ListDateType source, ListDateType destination);
  41. //某个位置前插入数据
  42. void ListInsert(ListNode* phead, ListNode* pos, ListDateType x);
  43. //删除某个位置数据
  44. void ListErase(ListNode* phead, ListNode* pos);

List.c

  1. #include"List.h"
  3. //初始化
  4. ListNode* ListInit()
  5. {
  6.     ListNode* phead = BuyListNode(0);
  7.     phead->prev = phead;
  8.     phead->next = phead;
  9.     phead->date = 0;
  10.     return phead;
  11. }
  13. //得到一个节点
  14. ListNode* BuyListNode(ListDateType x)
  15. {
  16.     ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));
  17.     newnode->prev = NULL;
  18.     newnode->next = NULL;
  19.     newnode->date = x;
  20.     return newnode;
  21. }
  23. //头插
  24. void ListPushFront(ListNode* phead, ListDateType x)
  25. {
  26.     assert(phead);
  27.     ListNode* newnode = BuyListNode(x);
  28.     ListNode* first = phead->next;
  30.     phead->next = newnode;
  31.     newnode->prev = phead;
  32.     newnode->next = first;
  33.     first->prev = newnode;
  34. }
  36. //尾插
  37. void ListPushBack(ListNode* phead, ListDateType x)
  38. {
  39.     assert(phead);
  40.     ListNode* tail = phead->prev;
  41.     ListNode* newnode = BuyListNode(x);
  43.     phead->prev = newnode;
  44.     newnode->next=phead;
  45.     tail->next = newnode;
  46.     newnode->prev = tail;
  47. }
  49. //打印
  50. void ListPrint(ListNode* phead)
  51. {
  52.     ListNode* cur = phead->next;
  53.     while (cur != phead)
  54.     {
  55.         printf("%d ", cur->date);
  56.         cur = cur->next;
  57.     }
  58.     printf("\n");
  59. }
  61. //头删
  62. void ListPopFront(ListNode* phead)
  63. {
  64.     assert(phead);
  65.     //别把头删了
  66.     assert(phead->next != phead);
  67.     ListNode* first = phead->next;
  68.     phead->next = first->next;
  69.     first->next->prev = phead;
  71.     free(first);
  72.     first = NULL;
  73. }
  75. //尾删
  76. void ListPopBack(ListNode* phead)
  77. {
  78.     assert(phead);
  79.     //别把头删了
  80.     assert(phead->next != phead);
  81.     ListNode* tail = phead->prev;
  82.     ListNode* prev = tail->prev;
  84.     prev->next = phead;
  85.     phead->prev = prev;
  86.     free(tail);
  87.     tail = NULL;
  88. }
  90. //查某个值，返回地址
  91. ListNode* ListFind(ListNode* phead, ListDateType x) 
  92. {
  93.     assert(phead);
  94.     ListNode* cur = phead->next;
  95.     while (cur != phead)
  96.     {
  97.         if (cur->date == x)
  98.         {
  99.             return cur;
  100.         }
  101.         else
  102.         {
  103.             cur = cur->next;
  104.         }
  105.     }
  106.     return NULL;
  107. }
  109. //某个位置前插入数据   
  110. void ListInsert(ListNode* phead, ListNode* pos, ListDateType x)
  111. {
  112.     assert(phead);
  113.     ListNode* newnode = BuyListNode(x);
  114.     ListNode* prev = pos->prev;
  115.     
  116.     prev->next = newnode;
  117.     newnode->prev = prev;
  118.     newnode->next = pos;
  119.     pos->prev = newnode;
  120. }
  122. //删除某个位置数据
  123. void ListErase(ListNode* phead, ListNode* pos)
  124. {
  125.     assert(phead);
  126.     //别把头删了
  127.     assert(phead->next != phead);
  128.     ListNode* prev = pos->prev;
  129.     ListNode* next = pos->next;
  131.     prev->next = next;
  132.     next->prev = prev;
  133.     free(pos);
  134.     pos = NULL;
  135. }
  137. //改某个值
  138. void ListChange(ListNode* phead, ListDateType source, ListDateType destination)
  139. {
  140.     assert(phead);
  141.     ListNode* pos = ListFind(phead, source);
  142.     pos->date = destination;
  143. }
  145. //销毁
  146. void ListDestory(ListNode* phead)
  147. {
  148.     assert(phead);
  149.     ListNode* cur = phead->next;
  150.     ListNode* tail = cur->next;
  151.     while (tail != phead)
  152.     {
  153.         free(cur);
  154.         cur = NULL;
  155.         cur = tail;
  156.         tail = tail->next;
  157.     }
  158.     free(cur);
  159.     cur = NULL;
  160.     if (cur != tail)
  161.     {
  162.         free(tail);
  163.         tail = NULL;
  164.     }
  165. }

今天的内容就到这里了哈！！！

要是认为作者有一点帮助你的话！

就来一个点赞加关注吧！！！当然订阅是更是求之不得！

赠人玫瑰，手有余香=。=！

最后的最后感谢大家的观看！！！

你们的支持是作者写作的最大动力！！！

下期见哈！！！

标签： 数据结构 c语言 算法
本文转载自: https://blog.csdn.net/weixin_62700590/article/details/122491868
版权归原作者 原来45 所有， 如有侵权，请联系我们删除。
登录后发布评论

“一篇解双链表（0基础看）（C语言）《数据结构与算法》”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？