C语言实现双向链表

最新推荐文章于 2021-05-18 23:17:11 发布
最新推荐文章于 2021-05-18 23:17:11 发布
阅读量719 收藏 1
点赞数
分类专栏： 算法设计

首先编写头文件，头文件里做相关的定义和声明，DList.h内容如下：

[cpp] view plain copy
  1. #ifndef DList_H  
  2. #define DList_H  
  3. typedef  int Item;  
  4. typedef struct Node * PNode;  
  5. typedef PNode Position;  
  6. /*定义节点类型*/  
  7. typedef struct Node  
  8. {  
  9.     Item data;      /*数据域*/  
  10.     PNode previous; /*指向前驱*/  
  11.     PNode next;     /*指向后继*/  
  12. }Node;  
  13. /*定义链表类型*/  
  14. typedef struct  
  15. {  
  16.     PNode head;     /*指向头节点*/  
  17.     PNode tail;     /*指向尾节点*/  
  18.     int size;  
  19. }DList;  
  20.   
  21. /*分配值为i的节点，并返回节点地址*/  
  22. Position MakeNode(Item i);  
  23.   
  24. /*释放p所指的节点*/  
  25. void FreeNode(PNode p);  
  26.   
  27. /*构造一个空的双向链表*/  
  28. DList* InitList();  
  29.   
  30. /*摧毁一个双向链表*/  
  31. void DestroyList(DList *plist);  
  32.   
  33. /*将一个链表置为空表，释放原链表节点空间*/  
  34. void ClearList(DList *plist);  
  35.   
  36. /*返回头节点地址*/  
  37. Position GetHead(DList *plist);  
  38.   
  39. /*返回尾节点地址*/  
  40. Position GetTail(DList *plist);  
  41.   
  42. /*返回链表大小*/  
  43. int GetSize(DList *plist);  
  44.   
  45. /*返回p的直接后继位置*/  
  46. Position GetNext(Position p);  
  47.   
  48. /*返回p的直接前驱位置*/  
  49. Position GetPrevious(Position p);  
  50.   
  51. /*将pnode所指节点插入第一个节点之前*/  
  52. PNode InsFirst(DList *plist,PNode pnode);  
  53.   
  54. /*将链表第一个节点删除并返回其地址*/  
  55. PNode DelFirst(DList *plist);  
  56.   
  57. /*获得节点的数据项*/  
  58. Item GetItem(Position p);  
  59.   
  60. /*设置节点的数据项*/  
  61. void SetItem(Position p,Item i);  
  62.   
  63. /*删除链表中的尾节点并返回其地址，改变链表的尾指针指向新的尾节点*/  
  64. PNode Remove(DList *plist);  
  65.   
  66. /*在链表中p位置之前插入新节点S*/  
  67. PNode InsBefore(DList *plist,Position p,PNode s);  
  68.   
  69. /*在链表中p位置之后插入新节点s*/  
  70. PNode InsAfter(DList *plist,Position p,PNode s);  
  71.   
  72. /*返回在链表中第i个节点的位置*/  
  73. PNode LocatePos(DList *plist,int i);  
  74.   
  75. /*依次对链表中每个元素调用函数visit()*/  
  76. void ListTraverse(DList *plist,void (*visit)());  
  77. #endif  


接下来逐个实现其功能，DList.c内容如下：

[cpp] view plain copy
  1. #include"DList.h"  
  2. #include<malloc.h>  
  3. #include<stdlib.h>  
  4. /*分配值为i的节点，并返回节点地址*/  
  5. Position MakeNode(Item i)  
  6. {  
  7.     PNode p = NULL;   
  8.     p = (PNode)malloc(sizeof(Node));  
  9.     if(p!=NULL)  
  10.     {  
  11.         p->data = i;  
  12.         p->previous = NULL;  
  13.         p->next = NULL;  
  14.     }     
  15.     return p;  
  16. }  
  17. /*释放p所指的节点*/  
  18. void FreeNode(PNode p)  
  19. {  
  20.      free(p);  
  21. }  
  22. /*构造一个空的双向链表*/  
  23. DList * InitList()  
  24. {  
  25.     DList *plist = (DList *)malloc(sizeof(DList));  
  26.     PNode head = MakeNode(0);   
  27.     if(plist!=NULL)  
  28.     {  
  29.         if(head!=NULL)  
  30.         {  
  31.             plist->head = head;  
  32.             plist->tail = head;  
  33.             plist->size = 0;  
  34.         }  
  35.         else  
  36.             return NULL;  
  37.     }  
  38.     return plist;  
  39. }  
  40.   
  41. /*摧毁一个双向链表*/  
  42. void DestroyList(DList *plist)  
  43. {  
  44.     ClearList(plist);  
  45.     free(GetHead(plist));  
  46.     free(plist);  
  47. }  
  48.   
  49. /*判断链表是否为空表*/  
  50. int IsEmpty(DList *plist)  
  51. {  
  52.     if(GetSize(plist)==0&&GetTail(plist)==GetHead(plist))  
  53.         return 1;  
  54.     else  
  55.         return 0;  
  56. }  
  57. /*将一个链表置为空表，释放原链表节点空间*/  
  58. void ClearList(DList *plist)  
  59. {  
  60.     PNode temp,p;  
  61.     p = GetTail(plist);  
  62.     while(!IsEmpty(plist))  
  63.     {     
  64.         temp = GetPrevious(p);  
  65.         FreeNode(p);  
  66.         p = temp;  
  67.         plist->tail = temp;  
  68.         plist->size--;  
  69.     }  
  70. }  
  71.   
  72. /*返回头节点地址*/  
  73. Position GetHead(DList *plist)  
  74. {  
  75.     return plist->head;  
  76. }  
  77.   
  78. /*返回尾节点地址*/  
  79. Position GetTail(DList *plist)  
  80. {  
  81.     return plist->tail;  
  82. }  
  83.   
  84. /*返回链表大小*/  
  85. int GetSize(DList *plist)  
  86. {  
  87.     return plist->size;  
  88. }  
  89.   
  90. /*返回p的直接后继位置*/  
  91. Position GetNext(Position p)  
  92. {  
  93.     return p->next;  
  94. }  
  95.   
  96. /*返回p的直接前驱位置*/  
  97. Position GetPrevious(Position p)  
  98. {  
  99.     return p->previous;  
  100. }  
  101.   
  102. /*将pnode所指节点插入第一个节点之前*/  
  103. PNode InsFirst(DList *plist,PNode pnode)  
  104. {  
  105.     Position head = GetHead(plist);  
  106.   
  107.     if(IsEmpty(plist))  
  108.         plist->tail = pnode;  
  109.     plist->size++;  
  110.   
  111.     pnode->next = head->next;  
  112.     pnode->previous = head;  
  113.   
  114.     if(head->next!=NULL)  
  115.         head->next->previous = pnode;  
  116.     head->next = pnode;  
  117.       
  118.     return pnode;   
  119. }  
  120.   
  121. /*将链表第一个节点删除,返回该节点的地址*/  
  122. PNode DelFirst(DList *plist)  
  123. {  
  124.     Position head = GetHead(plist);  
  125.     Position p=head->next;  
  126.     if(p!=NULL)  
  127.     {  
  128.         if(p==GetTail(plist))  
  129.             plist->tail = p->previous;  
  130.         head->next = p->next;  
  131.         head->next->previous = head;  
  132.         plist->size--;  
  133.           
  134.     }     
  135.     return p;  
  136. }  
  137.   
  138. /*获得节点的数据项*/  
  139. Item GetItem(Position p)  
  140. {  
  141.     return p->data;  
  142. }  
  143.   
  144. /*设置节点的数据项*/  
  145. void SetItem(Position p,Item i)  
  146. {  
  147.     p->data = i;  
  148. }  
  149.   
  150. /*删除链表中的尾节点并返回地址，改变链表的尾指针指向新的尾节点*/  
  151. PNode Remove(DList *plist)  
  152. {  
  153.     Position p=NULL;  
  154.     if(IsEmpty(plist))  
  155.         return NULL;  
  156.     else  
  157.     {  
  158.         p = GetTail(plist);  
  159.         p->previous->next = p->next;  
  160.         plist->tail = p->previous;  
  161.         plist->size--;  
  162.         return p;  
  163.     }  
  164. }  
  165. /*在链表中p位置之前插入新节点s*/  
  166. PNode InsBefore(DList *plist,Position p,PNode s)  
  167. {  
  168.     s->previous = p->previous;  
  169.     s->next = p;  
  170.     p->previous->next = s;      
  171.     p->previous = s;  
  172.   
  173.     plist->size++;  
  174.     return s;  
  175. }  
  176. /*在链表中p位置之后插入新节点s*/  
  177. PNode InsAfter(DList *plist,Position p,PNode s)  
  178. {  
  179.     s->next = p->next;  
  180.     s->previous = p;  
  181.       
  182.     if(p->next != NULL)  
  183.         p->next->previous = s;  
  184.     p->next = s;  
  185.       
  186.     if(p = GetTail(plist))  
  187.         plist->tail = s;  
  188.       
  189.     plist->size++;  
  190.     return s;  
  191. }  
  192.   
  193. /*返回在链表中第i个节点的位置*/  
  194. PNode LocatePos(DList *plist,int i)  
  195. {  
  196.     int cnt = 0;  
  197.     Position p = GetHead(plist);  
  198.     if(i>GetSize(plist)||i<1)  
  199.         return NULL;  
  200.   
  201.     while(++cnt<=i)  
  202.     {  
  203.         p=p->next;  
  204.     }  
  205.   
  206.     return p;  
  207. }  
  208.   
  209. /*依次对链表中每个元素调用函数visit()*/  
  210. void ListTraverse(DList *plist,void (*visit)())  
  211. {  
  212.     Position p = GetHead(plist);  
  213.     if(IsEmpty(plist))  
  214.         exit(0);  
  215.     else  
  216.     {  
  217.           
  218.         while(p->next!=NULL)  
  219.         {  
  220.             p = p->next;  
  221.             visit(p->data);            
  222.         }         
  223.     }  
  224. }  


接下来进行测试，Test.h内容如下：

[cpp] view plain copy
  1. #include"DList.h"  
  2. #include<stdio.h>  
  3. void print(Item i)  
  4. {  
  5.     printf("数据项为%d \n",i);  
  6. }  
  7. main()  
  8. {  
  9.     DList *plist = NULL;  
  10.     PNode p = NULL;  
  11.       
  12.     plist = InitList();  
  13.     p = InsFirst(plist,MakeNode(1));  
  14.     InsBefore(plist,p,MakeNode(2));  
  15.     InsAfter(plist,p,MakeNode(3));  
  16.   
  17.     printf("p前驱位置的值为%d\n",GetItem(GetPrevious(p)));  
  18.     printf("p位置的值为%d\n",GetItem(p));  
  19.     printf("p后继位置的值为%d\n",GetItem(GetNext(p)));  
  20.       
  21.       
  22.     printf("遍历输出各节点数据项:\n");  
  23.     ListTraverse(plist,print);  
  24.     printf("除了头节点该链表共有%d个节点\n",GetSize(plist));  
  25.     FreeNode(DelFirst(plist));  
  26.     printf("删除第一个节点后重新遍历输出为:\n");  
  27.     ListTraverse(plist,print);  
  28.     printf("除了头节点该链表共有%d个节点\n",GetSize(plist));  
  29.     DestroyList(plist);  
  30.     printf("链表已被销毁\n");  
  31. } 
eastlhu
关注
专栏目录
c语言双向链表的实现
qq_40741513的博客
07-12 1146
实现了头插法建立双向链表，尾插法建立双向链表，节点的增删改查，链表的顺序遍历，逆序遍历等 代码如下 #include <stdio.h> #include <stdlib.h> #define TRUE 1; #define FALSE 0; typedef struct DuLNode{ int data; struct DuLNode *prior, *next; }DuLNode, *DuLinklist; //尾插法创建双向链表 void Cre
c 语言中双向链表逆转编程题,C语言实现双向链表的反转
weixin_39631261的博客
05-18 1317
(a)原始链表(b) 反转后的双向链表 下面是一个用于反转双向链表的简单方法。所需要做的事情就是交换每个节点的前向指针和后向指针，然后调整链表的头指针和尾指针。#include struct Node{int data;Node *next; // 指向下一个节点Node *prev; // 指向前一个节点};//对链表进行反转void reverse(Node **head){Node *tem...
一个简单双向链表C实现
02-20
构建了双向链表，实现了 1.int getlistlen(node *head); 根据表头计算链表长度。 2.int displist(node *head) 根据表头从头显示所有元素。 3.int displistfromtail(node *tail) 根据表尾倒序显示所有元素。 4.int insertnote(node **head,int at,node *p) 根据表头，和位置，插入一个元素。 5.int sortlist(node *head,int BigHeadflg) 根据表头,和大小头的标记，排序。 6.int deletelist(node *head) 从头删除所有元素。 开发环境VC6.0下通过。
C语言一个双向链表的实现
04-25 103
-- DList.c #include"DList.h" #include<malloc.h> #include<stdlib.h> /*分配值为i的节点，并返回节点地址*/ Position MakeNode(Item i) { PNode p = NULL; p = (PNode)malloc...
c语言实现双向链表
wu1217的博客
09-05 4472
/** 双链表操作 开发环境codeblocks12.11 xxwu */ #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &lt;stdbool.h&gt; typedef int ElemType; typedef struct DNode{     ElemType data;     struct DNode ...
c语言：双向链表的实现
在路上
03-25 686
#include #include #include #define LEN sizeof(struct DNodelist) using namespace std; typedef struct DNodelist //定义结构体 { int data; //结点数据域 struct DNodelist *prior;//结点前向指针 struct DN
C语言实现双向链表DuLiST.c
03-24
总的来说，"C语言实现双向链表DuLiST.c"项目提供了一个基础但实用的双向链表实现，它展示了如何用C语言有效地管理内存和操作链表结构。对于学习数据结构、C语言编程或者需要使用链表功能的开发者来说，这是一个很好...
C语言实现双向链表基础操作详解
资源摘要信息:"本压缩包包含了用C语言实现的双向链表的源代码文件，提供了双向链表的基本操作功能，如插入、删除和查找。双向链表是一种数据结构，它允许在任意位置进行高效的数据插入和删除操作。链表由一系列节点...
c双向链表的实现
eeekkk的专栏
10-28 591
// DBList.cpp : Defines the entry point for the console application. // #include "stdafx.h" //双向链表的实现 //双向链表每个节点都带一个前驱指针和后续指针，分别为LLink,RLink; typedef int DataType; //双向链表数据结构 typedef struct Node {
C语言 数据结构双向链表简单实例
01-01
双向链表的基本操作     １．利用尾插法建立一个双向链表。     ２．遍历双向链表。     ３．实现双向链表中删除一个指定元素。     ４．在非递减有序双向链表中实现插入元素e仍有序算法。     ５．判断双向链表中元素是否对称若对称返回1否则返回0。     ６．设元素为正整型,实现算法把所有奇数排列在偶数之前。     ７．在主函数中设计一个简单的菜单调试上述算法。 实例代码： //排序的时候因为没有说明奇数和偶数需不需要各自再排序，我就没有排序，只是将奇数放在偶数后面。 //创建链表的时候，因为这个实验没有要求输出链表的长度，所以我就输入了一个长度为n的链表。 #include
C语言实现的单向链表和双向链表
01-16
slist.h为单向链表，blist为双向链表
Lua语言 链表操作实现
07-16
Lua语言 链表操作实现。 如果对代码有疑问，欢迎随时联系我！
c语言双向链表的标准实现,c语言双向链表的实现
weixin_26712065的博客
05-18 149
#include #define TRUE 1;#define FALSE 0;typedef struct DuLNode{int data;struct DuLNode *prior, *next;}DuLNode, *DuLinklist;//尾插法创建双向链表void CreateTailList(DuLinklist *L, int n){//创建大小长度为n的链表DuLinklist ...
数据结构——动手实战双向链表
TechFlow的博客
03-05 294
本文始发于个人公众号：TechFlow，原创不易，求个关注 在之前介绍SkipList的文章当中，有一些同学反馈说由于对链表缺少认知以及了解，所以直接啃算法有些过于困难。加上之前的文章当中介绍过了栈，所以这次继续线性表这个话题，我们来一起讨论一下链表。 链表是很多数据结构的基础，它的最大特点是支持快速的删除和插入，因此在很多数据频繁变动的场景下使用广泛。而且链表的可拓展性较强，所以它的应用非常广...
Lua 实现双向列表
m0_37981386的博客
03-10 958
--list --node={prev=nil,next=nil,value=nil} --DoubleList={header=node,tail=node} --生成一个table local function buildInitNode(value) node = {value=value} node.prev=node node.next=node return node en...
Lua 双向队列的实现
2月7号遇见你
06-11 628
local Queue ={} function Queue:new() local t = {firstId = -1, lastId = 0} setmetatable(t, self) self.__index = self return t end function Queue:pushFirst(data) local newFirstId = self.first
写一个简单的双向链表
fj_xiang的博客
05-12 505
先写一个实体类 class Data2{ private int id; private String name; private Data2 pre; private Data2 next; public Data2(int id, String name) { super(); this.id = id; this.name = name; } public int getId() { return id; } public void setId(int id) {
c语言实现带头结点和尾节点的双向链表
perry0528的博客
08-23 1524
c语言实现带头结点和尾节点的双向链表 接口参考严蔚敏老师的数据结构 编译环境：linux 数据结构 ： typedef struct LNode { Item data; struct LNode *prior; struct LNode *next; }Link; typedef struct { Link *head, *tail; in...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值