C语言数据结构----双向链表

特此说明：

转载自http://blog.csdn.net/cheyuxuan/article/details/10220313

转载原因：作者写的很详细，便于学习和理解



一、基本概念

1.有了单链表以后我们可以把内存中小块的空间联系在一起，并且把每一个小块都存储上我们想要存储的数值。但是单链表只有一个next，我们每一次都要从头开始遍历整个链表，这样的话如果我们对单链表进行逆序访问那么将是一项很耗时的操作。

2.双向链表解决了上面的问题，我们不单对每一个数据节点都设置一个next，同时还有一个pre指针，这样我们可以完成对链表的双向查找。

3.双向链表的结构示意图如下所示：

二、把单链表更改成为双向链表

 1.首先更改链表中的header,链表中的header对应的是一个结构体，如下所示：

[cpp]  view plain copy
  1. struct _tag_DLinkListNode  
  2. {  
  3.     DLinkListNode* next;  
  4.     DLinkListNode* pre;  
  5. };  

在这里相对于单链表增加了一个pre指针，作前驱。

2.在create函数中初始化将header.pre以及clear函数中的header.next都设置为NULL。

[cpp]  view plain copy
  1. ret->header.pre = NULL;  


3.其他地方的操作还要注意在插入一个节点和删除一个节点函数中的改变。

三、双向链表的具体操作

1.双向链表的创建

[cpp]  view plain copy
  1. DLinkList* DLinkList_Create()  
  2. {  
  3.     TDLinkList* ret = (TDLinkList*)malloc(sizeof (TDLinkList));  
  4.     if (ret != NULL)  
  5.     {  
  6.         ret->length = 0;  
  7.         ret->slider = NULL;  
  8.         ret->header.next = NULL;  
  9.         ret->header.pre = NULL;  
  10.     }  
  11.       
  12.     return ret;  
  13. }  

这里的TDLinkList* ret = (TDLinkList*)malloc(sizeof (TDLinkList));是为链表头获取空间，链表中其他数据节点的空间是在主函数中定义的，也就是插入链表时候由 结构体进行定义。

2.双向链表的清除、销毁、以及获取长度

这一部分要注意返回值的定义和返回值的类型。

3.双向链表的插入操作

 在链表插入函数中，一共有四点需要注意。

（1）普通的插入方式，不是头插法也不是尾插法，只是单纯的把一个数据节点插入到链表中。基本操作示意图如下：

这样我们基本上使用四步操作就可以解决：

[cpp]  view plain copy
  1. current->next = node;  
  2. node->pre = current;  
  3. next->pre = node;  
  4. node->pre = current;  

（2）如果插入的节点是采用头插法，而且链表中已经存在其他元素，那么我们要进行判定，因为这个时候不可以再单纯的令current = node->pre，这个时候的node是第一个元素，所以它的pre应该指向NULL。

 

代码实现：

[cpp]  view plain copy
  1. if (current == (DLinkListNode*)slist)  
  2.         {  
  3.             node->pre = NULL;  
  4.         }  

（3）当我们插入的节点是链表中的第0个位置，并且链表中没有其他元素，也就是链表的长度为0的时候，这个时候我们插入的元素的node->pre指向的current是头结点，显然不应该这样，也应该令node->pre = NULL,虽然老唐的判定是slist->length = 0但是我自己的判定current == (DLinkListNode*)slist已经包含了老唐的情况。



 这种情况的代码实现：

[cpp]  view plain copy
  1. if (current == (DLinkListNode*)slist)  
  2.         {  
  3.             node->pre = NULL;  
  4.         }  

（4）插入节点的第三种特殊情况：当我们从链表的尾部插入元素，这个时候current是倒数第一个节点，next是NULL,我们要插入的节点node在插入完成以后，node->next应该指向空。

这种情况下的代码实现：

[cpp]  view plain copy
  1. if (next != NULL)  
  2.         {  
  3.         //  node->next = next;  
  4.             next->pre = node;              
  5.         }   
  6.           

（5）对然第二种情况已经实现了slist->length == 0的情况，但是假如我们的slist->length == 0的时候，我们的游标并没有指向当前插入的元素，为了解决这个问题，代码实现如下：

[cpp]  view plain copy
  1. if (slist->length == 0)  
  2.         {  
  3.             slist->slider = node;  
  4.         }   
  5.       

插入函数的整体实现如下所示：

[cpp]  view plain copy
  1. int DLinkList_Insert(DLinkList* list, DLinkListNode* node, int pos)  
  2. {  
  3.     TDLinkList *slist = (TDLinkList*)list;  
  4.     int ret = (slist != NULL);  
  5.     ret = ret && (pos >= 0);  
  6.     ret = ret && (node != NULL);  
  7.     int i = 0;  
  8.     if (ret)  
  9.     {  
  10.         DLinkListNode*current = (DLinkListNode*)slist;  
  11.         DLinkListNode*next = NULL;  
  12.         for (i = 0; (i < pos) && (current->next != NULL); i++)  
  13.         {  
  14.             current = current->next;  
  15.         }  
  16.         next = current->next;  
  17.           
  18.         current->next = node;  
  19.           
  20.         node->next = next;  
  21.         if (next != NULL)  
  22.         {  
  23.         //  node->next = next;  
  24.             next->pre = node;              
  25.         }   
  26.           
  27.         node->pre = current;  
  28.         if (current == (DLinkListNode*)slist)  
  29.         {  
  30.             node->pre = NULL;  
  31.         }  
  32.           
  33.         if (slist->length == 0)  
  34.         {  
  35.             slist->slider = node;  
  36.         }   
  37.       
  38.         slist->length++;  
  39.     }  
  40.     return ret;  
  41. }  

4.双向链表的删除元素操作

删除操作除了常规的操作以外也存在一些特殊的情况。

（1）常规的删除链表中的一个元素，也就是在这个双向链表中的不是第一个元素，也不是最后元素，而且这个时候的双向链表已经有了一定的长度。如下图所示：



具体的代码实现如下：

[cpp]  view plain copy
  1. current->next = next;  
  2. next->node = current;  

（2）删除链表中的元素的第二种情况，我们要删除链表中的第0个元素，这个时候我们头结点的next被赋值为next(第1个节点)，但是这个时候第一个节点应该变为第0个节点，而第0个节点指向的为header，所以这个时候next->pre = NULL。


代码实现：

[cpp]  view plain copy
  1. current->next = next;  
  2. next->pre= NULL;  

同时这种情况下要对next节点是否是为NULL 进行判定。

（3）删除了第0个元素以后，链表中不再有其他元素，也就是我们删除的元素是链表中的唯一节点，这个时候我们只需要将current->next = next,而并不需要进行next->pre =current,因为这个时候根本就不存在next->pre的情况了。

这里不再需要next->pre = current,具体的代码实现如下：

[cpp]  view plain copy
  1. if (next != NULL)  

我们这种情况下next = = NULL，所以我们不再指向if下面的代码。

（4）如果删除的链表中的最后一个节点，如果这个节点为空，那么只执行current->next = next,这个判定if (next != NULL)已经完成，不再执行有关next->pre的操作。

具体代码实现如下：

[cpp]  view plain copy
  1. if (next != NULL)  

删除函数的具体实现如下：

（5）如果我们要删除的节点恰好是游标现在所指向的元素，那么我们需要将游标指向next。

具体代码实现如下：

[cpp]  view plain copy
  1. if (slist->slider == ret)  
  2.      {  
  3.     slist->slider = next;  
  4.      }   

删除函数的具体实现代码如下：

[cpp]  view plain copy
  1. DLinkListNode* DLinkList_Delete(DLinkList* list, int pos)  
  2. {  
  3.     TDLinkList* slist = (TDLinkList*)list;  
  4.     DLinkListNode * ret = NULL;  
  5.     int i = 0;  
  6.       
  7.     if ((slist != NULL) && (pos >=0) && (pos < slist->length))   
  8.     {  
  9.         DLinkListNode* current = (DLinkListNode*)(slist);  
  10.         DLinkListNode*next = NULL;  
  11.         for (i = 0; i < pos; i++)  
  12.         {  
  13.             current = current->next;  
  14.         }  
  15.         ret = current->next;  
  16.           
  17.         next->pre = current;*/   
  18.         next = ret->next;  
  19.         current->next = next;  
  20.           
  21.         if (next != NULL)  
  22.         {  
  23.             next->pre = current;  
  24.             if (current == (DLinkListNode*)slist)  
  25.             {  
  26.                 current->next = NULL;  
  27.                 next->pre = NULL;  
  28.             }  
  29.               
  30.         }  
  31.           
  32.            
  33.         if (slist->slider == ret)  
  34.         {  
  35.             slist->slider = next;  
  36.         }   
  37.           
  38.         slist->length--;  
  39.               
  40.     }  
  41.     return ret;  
  42. }  

四、测试程序以及游标

1.测试程序

（1）我们的插入方式如下：

[cpp]  view plain copy
  1. DLinkList_Insert(list, (DLinkListNode*)&v1, DLinkList_Length(list));  
  2. DLinkList_Insert(list, (DLinkListNode*)&v2, DLinkList_Length(list));  
  3. DLinkList_Insert(list, (DLinkListNode*)&v3, DLinkList_Length(list));  
  4. DLinkList_Insert(list, (DLinkListNode*)&v4, DLinkList_Length(list));  
  5. DLinkList_Insert(list, (DLinkListNode*)&v5, DLinkList_Length(list));  

我们采用的尾插法，就是每一次插入一个元素都是从链表的尾部插入。

（2）我们在操作游标之前，不必要对游标进行复位，如果不对游标进行复位，那么我们采用尾插法将会把元素的游标挤到第一个位置，那么我们就可以正常操作游标了。

（3）如果我们采用头插法插入元素，插入方式如下：

[cpp]  view plain copy
  1. DLinkList_Insert(list, (DLinkListNode*)&v1, 0);  
  2. DLinkList_Insert(list, (DLinkListNode*)&v2, 0);  
  3. DLinkList_Insert(list, (DLinkListNode*)&v3, 0);  
  4. DLinkList_Insert(list, (DLinkListNode*)&v4, 0);  
  5. DLinkList_Insert(list, (DLinkListNode*)&v5, 0);  

（4）在我们进行游标操作之前，我们要对游标进行复位，因为头插法将会把游标顺序的挤到最后一个位置，这个时候如果我们朦胧的将游标再向后移动一个将会导致程序的崩溃，但是这个时候向前移动并不会出错。

五、源代码

1.双向链表实现.c文件

[cpp]  view plain copy
  1. #include <stdio.h>  
  2. #include <stdlib.h>  
  3. #include "1.h"  
  4.   
  5. /************************************************************************ 
  6. *这个结构体里定义的是链表头的信息，我们的链表操作和链表遍历都离不开链表头  
  7. ************************************************************************/  
  8. typedef struct student  
  9. {  
  10.     DLinkListNode header;  
  11.     DLinkListNode *slider; //游标   
  12.     int length;  
  13. }TDLinkList;  
  14.   
  15. /*********************************************************************************************** 
  16. *函数名： DLinkList_Create 
  17. *参数：void 
  18. *返回值：DLinkList*类型，是一个void*类型，然后再由接收函数进行强制类型转换  
  19. *功能：创建链表，并返回链表头  
  20. ***********************************************************************************************/   
  21. DLinkList* DLinkList_Create()  
  22. {  
  23.     /* 
  24.         为链表头获得空间，链表中其他数据节点的空间是在主函数中定义的，也就是插入链表时候由 
  25.         结构体进行定义。  
  26.     */  
  27.     TDLinkList* ret = (TDLinkList*)malloc(sizeof (TDLinkList));  
  28.     if (ret != NULL)  
  29.     {  
  30.         ret->length = 0;  
  31.         ret->slider = NULL;  
  32.         ret->header.next = NULL;  
  33.         ret->header.pre = NULL;  
  34.     }  
  35.       
  36.     return ret;  
  37. }  
  38. /*********************************************************************************************** 
  39. *函数名： DLinkList_Destroy 
  40. *参数：DLinkList* list 传进来的是链表头  
  41. *返回值：void  
  42. *功能：销毁链表头  
  43. ***********************************************************************************************/   
  44. void DLinkList_Destroy(DLinkList* list)  
  45. {  
  46.     free(list);  
  47. }  
  48. /*********************************************************************************************** 
  49. *函数名： DLinkList_Clear 
  50. *参数：DLinkList* list 传进来的是链表头  
  51. *返回值：void  
  52. *功能：清空链表，并把链表头信息清空  
  53. ***********************************************************************************************/   
  54. void DLinkList_Clear(DLinkList* list)  
  55. {  
  56.     TDLinkList *slist = (TDLinkList*)list;  
  57.     if (slist != NULL)  
  58.     {  
  59.         slist->length = 0;  
  60.         slist->header.next = NULL;  
  61.         slist->header.pre = NULL;  
  62.         slist->slider = NULL;  
  63.     }  
  64. }  
  65. /*********************************************************************************************** 
  66. *函数名： DLinkList_Length 
  67. *参数：DLinkList* list 传进来的是链表头  
  68. *返回值：int类型的整数  
  69. *功能：获得链表长度，并将链表的长度返回  
  70. ***********************************************************************************************/   
  71. int DLinkList_Length(DLinkList* list)  
  72. {  
  73.     /*首先给返回值赋初值，如果函数的返回值为-1，则证明链表并不存在*/   
  74.     int ret = -1;  
  75.     TDLinkList *slist = (TDLinkList*)list;  
  76.     if (slist != NULL)  
  77.     {  
  78.         ret = slist->length;  
  79.     }  
  80.     return ret;  
  81. }  
  82. /*********************************************************************************************** 
  83. *函数名： DLinkList_Insert 
  84. *参数：DLinkList* list 传进来的是链表头  DLinkListNode* node 要插入的数据节点，其实是我们 
  85. *实际要插入的数据节点的指针 int pos 要插入链表中的位置（注意这个是从0开始算起的）  
  86. *返回值：int类型的整数  
  87. *功能：如果插入元素成功返回1，否则返回其他。  
  88. ***********************************************************************************************/   
  89. int DLinkList_Insert(DLinkList* list, DLinkListNode* node, int pos)  
  90. {  
  91.     TDLinkList *slist = (TDLinkList*)list;  
  92.     int ret = (slist != NULL);  
  93.     ret = ret && (pos >= 0);  
  94.     ret = ret && (node != NULL);  
  95.     int i = 0;  
  96.     if (ret)  
  97.     {  
  98.         DLinkListNode*current = (DLinkListNode*)slist;  
  99.         DLinkListNode*next = NULL;  
  100.         for (i = 0; (i < pos) && (current->next != NULL); i++)  
  101.         {  
  102.             current = current->next;  
  103.         }  
  104.         next = current->next;  
  105.           
  106.         current->next = node;  
  107.           
  108.         node->next = next;  
  109.         if (next != NULL)  
  110.         {  
  111.         //  node->next = next;  
  112.             next->pre = node;              
  113.         }   
  114.           
  115.         node->pre = current;  
  116.         if (current == (DLinkListNode*)slist)  
  117.         {  
  118.             node->pre = NULL;  
  119.         }  
  120.           
  121.         if (slist->length == 0)  
  122.         {  
  123.             slist->slider = node;  
  124.         }   
  125.       
  126.         slist->length++;  
  127.     }  
  128.     return ret;  
  129. }  
  130.   
  131. /*********************************************************************************************** 
  132. *函数名： DLinkList_Get 
  133. *参数：DLinkList* list 传进来的是链表头  int pos 要插入链表中的位置（注意这个是从0开始算起的）  
  134. *返回值：DLinkListNode*类型 也就是返回的是一个链表的节点结构体指针  
  135. *功能：通过传进来的链表指针和位置，可以获得这个位置上的数据节点信息。  
  136. ***********************************************************************************************/  
  137. DLinkListNode* DLinkList_Get(DLinkList* list, int pos)  
  138. {  
  139.     TDLinkList* slist = (TDLinkList*)list;  
  140.     DLinkListNode* ret = NULL;  
  141.     int i = 0;  
  142.     if ((slist != NULL)&& (pos >= 0) && (pos < slist->length))  
  143.     {  
  144.         DLinkListNode*current = (DLinkListNode*)slist;  
  145.         //DLinkListNode*next = NULL;  
  146.         for (i = 0; i < pos; i++)  
  147.         {  
  148.             current = current->next;   
  149.         }  
  150.         /*current永远都是我们要找的节点的前一个节点*/   
  151.         ret = current->next;  
  152.     }  
  153.     return ret;  
  154. }  
  155. /*********************************************************************************************** 
  156. *函数名： DLinkList_Delete 
  157. *参数：DLinkList* list 传进来的是链表头  int pos 要插入链表中的位置（注意这个是从0开始算起的）  
  158. *返回值：DLinkListNode*类型 也就是返回的是一个链表的节点结构体指针  
  159. *功能：通过传进来的链表指针和位置，可以获取删除指定位置上的元素，并对指定位置上的元素进行删除。  
  160. ***********************************************************************************************/  
  161. DLinkListNode* DLinkList_Delete(DLinkList* list, int pos)  
  162. {  
  163.     TDLinkList* slist = (TDLinkList*)list;  
  164.     DLinkListNode * ret = NULL;  
  165.     int i = 0;  
  166.       
  167.     if ((slist != NULL) && (pos >=0) && (pos < slist->length))   
  168.     {  
  169.         DLinkListNode* current = (DLinkListNode*)(slist);  
  170.         DLinkListNode*next = NULL;  
  171.         for (i = 0; i < pos; i++)  
  172.         {  
  173.             current = current->next;  
  174.         }  
  175.         ret = current->next;  
  176.   
  177.         next->pre = current;*/   
  178.         next = ret->next;  
  179.         current->next = next;  
  180.           
  181.         if (next != NULL)  
  182.         {  
  183.             next->pre = current;  
  184.             if (current == (DLinkListNode*)slist)  
  185.             {  
  186.                 current->next = NULL;  
  187.                 next->pre = NULL;  
  188.             }  
  189.               
  190.         }  
  191.           
  192.         if (slist->slider == ret)  
  193.         {  
  194.             slist->slider = next;  
  195.         }   
  196.           
  197.         slist->length--;  
  198.               
  199.     }  
  200.     return ret;  
  201. }  
  202. /*********************************************************************************************** 
  203. *函数名： DLinkList_DeleteNode 
  204. *参数：DLinkList* list 传进来的是链表头  int pos 要插入链表中的位置（注意这个是从0开始算起的）  
  205. *返回值：DLinkListNode*类型 也就是返回的是一个链表的节点结构体指针  
  206. *功能：通过传进来的链表指针和位置，通过游标指向我们要删除的元素，然后调用DLinkList_Delete函数 
  207. 进行删除。  
  208. ***********************************************************************************************/  
  209. DLinkListNode* DLinkList_DeleteNode(DLinkList* list, DLinkListNode* node)  
  210. {  
  211.     TDLinkList* slist = (TDLinkList*)list;  
  212.     DLinkListNode * ret = NULL;  
  213.     int i = 0;  
  214.     if (slist != NULL)  
  215.     {  
  216.         DLinkListNode* current = (DLinkListNode*)(slist);  
  217.         for (i = 0; i < slist->length; i++)  
  218.         {  
  219.             if (current->next == node)  
  220.             {  
  221.                 ret = current->next;  
  222.                 break;  
  223.             }  
  224.             current = current->next;  
  225.         }  
  226.           
  227.         if (current != NULL)  
  228.         {  
  229.             DLinkList_Delete (list, i);  
  230.         }  
  231.     }  
  232.     return ret;  
  233. }  
  234.   
  235. /*********************************************************************************************** 
  236. *函数名： DLinkList_Reset 
  237. *参数：DLinkList* list 传进来的是链表头    
  238. *返回值：DLinkListNode*类型 也就是返回的是一个链表的节点结构体指针  
  239. *功能：通过传进来的链表指针将游标重新指向头结点所指向的下一个元素的位置，也就是所谓的游标复位。  
  240. 进行删除。  
  241. ***********************************************************************************************/  
  242. DLinkListNode* DLinkList_Reset(DLinkList* list)  
  243. {  
  244.     TDLinkList* slist = (TDLinkList*)list;  
  245.     DLinkListNode* ret = NULL;  
  246.     if (slist != NULL)  
  247.     {  
  248.         slist->slider = slist->header.next;  
  249.         ret = slist->slider;   
  250.     }   
  251.     return ret;  
  252. }  
  253. /*********************************************************************************************** 
  254. *函数名： DLinkList_Current 
  255. *参数：DLinkList* list 传进来的是链表头    
  256. *返回值：DLinkListNode*类型 也就是返回的是一个链表的节点结构体指针  
  257. *功能：通过传进来的指针，找到游标当前指向的元素，并将这个当前元素返回。  
  258. ***********************************************************************************************/  
  259. DLinkListNode* DLinkList_Current(DLinkList* list)  
  260. {  
  261.     TDLinkList* slist = (TDLinkList*)list;  
  262.     DLinkListNode* ret = NULL;  
  263.     if (slist != NULL)  
  264.     {  
  265.         ret = slist->slider;  
  266.     }   
  267.     return ret;  
  268. }  
  269.   
  270. /*********************************************************************************************** 
  271. *函数名： DLinkList_Next 
  272. *参数：DLinkList* list 传进来的是链表头    
  273. *返回值：DLinkListNode*类型 也就是返回的是一个链表的节点结构体指针  
  274. *功能：通过传进来的指针，找到游标指向前一个元素，并将这个前一个元素返回。  
  275. ***********************************************************************************************/  
  276. DLinkListNode* DLinkList_Next(DLinkList* list)  
  277. {  
  278.     TDLinkList* slist = (TDLinkList*)list;  
  279.     DLinkListNode* ret = NULL;  
  280.       
  281.     if( (slist != NULL) && (slist->slider != NULL) )  
  282.     {  
  283.         ret = slist->slider;  
  284.         slist->slider = ret->next;  
  285.     }  
  286.       
  287.     return ret;  
  288. }  
  289. /*********************************************************************************************** 
  290. *函数名： DLinkList_Pre 
  291. *参数：DLinkList* list 传进来的是链表头    
  292. *返回值：DLinkListNode*类型 也就是返回的是一个链表的节点结构体指针  
  293. *功能：通过传进来的指针，找到游标指向前一个元素，并将这个前一个元素返回。  
  294. ***********************************************************************************************/  
  295. DLinkListNode* DLinkList_Pre(DLinkList* list)  
  296. {  
  297.     TDLinkList* slist = (TDLinkList*)list;  
  298.     DLinkListNode* ret = NULL;  
  299.     if (slist != NULL && slist->slider != NULL)  
  300.     {  
  301.         slist->slider = slist->slider->pre;   
  302.         ret = slist->slider;  
  303.     }   
  304.     return ret;  
  305. }  

2.双向链表的头文件

[cpp]  view plain copy
  1. #ifndef _1_H_  
  2. #define _1_H_  
  3.   
  4. typedef void DLinkList;  
  5. typedef struct _tag_DLinkListNode DLinkListNode;  
  6. /*这个结构体是聊表头的一个成员*/   
  7. struct _tag_DLinkListNode  
  8. {  
  9.     DLinkListNode* next;  
  10.     DLinkListNode* pre;  
  11. };  
  12.   
  13. DLinkList* DLinkList_Create();  
  14.   
  15. void DLinkList_Destroy(DLinkList* list);  
  16.   
  17. void DLinkList_Clear(DLinkList* list);  
  18.   
  19. int DLinkList_Length(DLinkList* list);  
  20.   
  21. int DLinkList_Insert(DLinkList* list, DLinkListNode* node, int pos);  
  22.   
  23. DLinkListNode* DLinkList_Get(DLinkList* list, int pos);  
  24.   
  25. DLinkListNode* DLinkList_Delete(DLinkList* list, int pos);  
  26.   
  27. DLinkListNode* DLinkList_DeleteNode(DLinkList* list, DLinkListNode* node);  
  28.   
  29. DLinkListNode* DLinkList_Reset(DLinkList* list);  
  30.   
  31. DLinkListNode* DLinkList_Current(DLinkList* list);  
  32.   
  33. DLinkListNode* DLinkList_Next(DLinkList* list);  
  34.   
  35. DLinkListNode* DLinkList_Pre(DLinkList* list);  
  36.   
  37. #endif  

3.测试程序

[cpp]  view plain copy
  1. #include <stdio.h>  
  2. #include <stdlib.h>  
  3. #include "1.h"  
  4. /* run this program using the console pauser or add your own getch, system("pause") or input loop */  
  5.   
  6. struct Value  
  7. {  
  8.     DLinkListNode header;  
  9.     int v;  
  10. };  
  11.   
  12. int main(int argc, char *argv[])  
  13. {  
  14.     int i = 0;  
  15.     DLinkList* list = DLinkList_Create();  
  16.     struct Value* pv = NULL;  
  17.     struct Value v1;  
  18.     struct Value v2;  
  19.     struct Value v3;  
  20.     struct Value v4;  
  21.     struct Value v5;  
  22.       
  23.     v1.v = 1;  
  24.     v2.v = 2;  
  25.     v3.v = 3;  
  26.     v4.v = 4;  
  27.     v5.v = 5;  
  28.       
  29.     DLinkList_Insert(list, (DLinkListNode*)&v1, DLinkList_Length(list));  
  30.     DLinkList_Insert(list, (DLinkListNode*)&v2, DLinkList_Length(list));  
  31.     DLinkList_Insert(list, (DLinkListNode*)&v3, DLinkList_Length(list));  
  32.     DLinkList_Insert(list, (DLinkListNode*)&v4, DLinkList_Length(list));  
  33.     DLinkList_Insert(list, (DLinkListNode*)&v5, DLinkList_Length(list));  
  34.       
  35.     DLinkList_Insert(list, (DLinkListNode*)&v1, 0);  
  36.     DLinkList_Insert(list, (DLinkListNode*)&v2, 0);  
  37.     DLinkList_Insert(list, (DLinkListNode*)&v3, 0);  
  38.     DLinkList_Insert(list, (DLinkListNode*)&v4, 0);  
  39.     DLinkList_Insert(list, (DLinkListNode*)&v5, 0);  
  40.       
  41.     for(i=0; i<DLinkList_Length(list); i++)  
  42.     {  
  43.         pv = (struct Value*)DLinkList_Get(list, i);  
  44.           
  45.         printf("插入的元素为：%d\n", pv->v);  
  46.     }  
  47.       
  48.     printf("\n");  
  49.       
  50.   
  51.     //DLinkList_Delete(list, 0);  
  52.     //DLinkList_Delete (list)*/  
  53.     for(i=0; i<DLinkList_Length(list); i++)  
  54.     {  
  55.         pv = (struct Value*)DLinkList_Next(list);  
  56.         printf("%d\n", pv->v);  
  57.     }  
  58.       
  59.     printf("\n");  
  60.    
  61.     DLinkList_Reset(list);  
  62.     DLinkList_Next(list);  
  63.       
  64.     pv = (struct Value*)DLinkList_Current(list);  
  65.       
  66.     printf("%d\n", pv->v);  
  67.       
  68.     DLinkList_DeleteNode(list, (DLinkListNode*)pv);  
  69.       
  70.     pv = (struct Value*)DLinkList_Current(list);  
  71.       
  72.     printf("%d\n", pv->v);  
  73.       
  74.     DLinkList_Pre(list);  
  75.       
  76.     pv = (struct Value*)DLinkList_Current(list);  
  77.       
  78.     printf("%d\n", pv->v);  
  79.       
  80.     printf("Length: %d\n", DLinkList_Length(list));  
  81.       
  82.     DLinkList_Destroy(list);  
  83.       
  84.     return 0;  
  85. }  
# 数据结构 # 链表
Logo
AtomGit 开源协作平台测评赛

瓜分20万奖金 获得内推名额 丰厚实物奖励 易参与易上手

更多推荐

cover

C#联合Halcon深度学习源代码分享1 预处理图像2图像识别测试3误差分析（含导入步骤文档，含中文注释） （附源码链接）

avatar 开放原子开发者工作坊

Git基础命令学习

git基础命令学习笔记git init 命令目录变成 Git 可以管理的仓库git add 把文件添加到仓库(可多次add不同的文件)git commit 把文件提交到仓库git satus 命令查看状态，可以让我们时刻掌握仓库当前的状态git diff可以看到指定文件的修改内容

avatar 开放原子开发者工作坊
cover

SpringBoot01:Hello,World

avatar 开放原子开发者工作坊