21ic电子技术开发论坛 › 单片机与嵌入式系统 › 新唐MCU › 一步一步教你从零开始写C语言链表
12下一页
返回列表 发新帖我要提问

[牛人杂谈] 一步一步教你从零开始写C语言链表

[复制链接]
2058|20
 楼主| 小灵通2018 发表于 2019-4-25 18:04 | 显示全部楼层 |阅读模式
C语言, 移动, 数据类型, C++, AC
为什么要学习链表？

链表主要有以下几大特性：

1、解决数组无法存储多种数据类型的问题。

2、解决数组中，元素个数无法改变的限制(C99的变长数组，C++也有变长数组可以实现)。

3、数组移动元素的过程中，要对元素进行大范围的移动，很耗时间，效率也不高。

先来感性的认识一下链表,我们先来认识下简单的链表:
为什么要学习链表？

链表主要有以下几大特性：

1、解决数组无法存储多种数据类型的问题。

2、解决数组中，元素个数无法改变的限制(C99的变长数组，C++也有变长数组可以实现)。

3、数组移动元素的过程中，要对元素进行大范围的移动，很耗时间，效率也不高。

先来感性的认识一下链表,我们先来认识下简单的链表:

152005cc1863480a02.png
回复

收藏 举报

相关帖子
 楼主| 小灵通2018 发表于 2019-4-25 18:05 | 显示全部楼层
从这幅图我们得出以下信息:

这个简单链表的构成：

头指针(Header)，若干个节点(节点包括了数据域和指针域)，最后一个节点要指向空。

实现原理：头指针指向链表的第一个节点，然后第一个节点中的指针指向下一个节点，然后依次指到最后一个节点，这样就构成了一条链表。

接下来看看链表的数据结构:
复制

  1. 

  2. struct  list_node
    

  3. {
    

  4.         int data ; //数据域，用于存储数据
    

  5.         struct list_node *next ; //指针，可以用来访问节点数据，也可以遍历，指向下一个节点
    

  6. };
那么如何来创建一个链表的一个节点呢？

回复

收藏 举报

 楼主| 小灵通2018 发表于 2019-4-25 18:06 | 显示全部楼层
我们写个程序演示一下:

复制
  1. #include <stdio.h>
    

  2. #include <stdlib.h>
    

  3. #include <string.h>
    

  4. struct  list_node
    

  5. {
    

  6.         int data ; 
    

  7.         struct list_node *next ;
    

  8. };
    

  9.  
    

  10. typedef struct list_node list_single ;         
    

  11.  
    

  12. int main(void)
    

  13. {
    

  14.         list_single *node = NULL ;          //1、首先，当然是定义一个头指针
    

  15.         node = (list_single *)malloc(sizeof(list_single)); //2、然后分配内存空间
    

  16.         if(node == NULL){
    

  17.                 printf("malloc fair!\n");
    

  18.         }
    

  19.         memset(node,0,sizeof(list_single)); //3、清一下
    

  20.         node->data = 100 ;                                    //4、给链表节点的数据赋值
    

  21.         node->next = NULL ;                 //5、将链表的指针域指向空
    

  22.         printf("%d\n",node->data);
    

  23.         free(node);
    

  24.         return 0 ;
    

  25. }
回复

收藏 举报

 楼主| 小灵通2018 发表于 2019-4-25 18:06 | 显示全部楼层
那么，这仅仅只是创建一个链表中的一个节点，为了好看，我们把创建节点封装成函数，以后想创建多少个节点，我们就可以反复调用一个函数来创建，会很方便:

复制
  1. list_single *create_list_node(int data)
    

  2. {
    

  3.         list_single *node = NULL ;
    

  4.         node = (list_single *)malloc(sizeof(list_single));
    

  5.         if(node == NULL){
    

  6.                 printf("malloc fair!\n");
    

  7.         }
    

  8.         memset(node,0,sizeof(list_single));
    

  9.         node->data = 100 ;
    

  10.         node->next = NULL ;
    

  11.         return node ;
    

  12. }

回复

收藏 举报

 楼主| 小灵通2018 发表于 2019-4-25 18:07 | 显示全部楼层
接下来在程序上完成的程序:
复制
  1. #include <stdio.h>
    

  2. #include <stdlib.h>
    

  3. #include <string.h>
    

  4. struct  list_node
    

  5. {
    

  6.         int data ; 
    

  7.         struct list_node *next ;
    

  8. };
    

  9.  
    

  10. typedef struct list_node list_single ;         
    

  11. list_single *create_list_node(int data)
    

  12. {
    

  13.         list_single *node = NULL ;
    

  14.         node = (list_single *)malloc(sizeof(list_single));
    

  15.         if(node == NULL){
    

  16.                 printf("malloc fair!\n");
    

  17.         }
    

  18.         memset(node,0,sizeof(list_single));
    

  19.         node->data = data;
    

  20.         node->next = NULL ;
    

  21.         return node ;
    

  22. }
    

  23. int main(void)
    

  24. {
    

  25.         int data = 100 ;
    

  26.         list_single *node_ptr = create_list_node(data); //创建一个节点
    

  27.         printf("node_ptr->data=%d\n",node_ptr->data);   //打印节点里的数据
    

  28.         printf("node_ptr->next=%d\n",node_ptr->next);  
    

  29.         free(node_ptr);
    

  30.         return 0 ;
    

  31. }


执行结果 ：
718055cc186f79c2d2.png
回复

收藏 举报

 楼主| 小灵通2018 发表于 2019-4-25 18:08 | 显示全部楼层
这样我们就完成一个链表节点的创建了，那么它现在的样子如下图：

链表的结构里，数据存储了100，因为这个链表只有一个节点，所以它的指针域指向了NULL。
788875cc1870fb7d92.png
上面只是建立一个单链表的基本雏形，接下来咱们再来增加一点难度。如果创建多个单链表节点，实现单链表的增删改查？把单链表应用起来。
回复

收藏 举报

 楼主| 小灵通2018 发表于 2019-4-25 18:09 | 显示全部楼层
1、首先定义一个单链表的数据结构
194275cc1873834f44.png
创建节点函数原型可定义如下：
struct list *create_node(int data) ;
如何创建单链表的节点，主要分以下步骤:
(1)给当前的每个节点的数据结构配置定量的空间大小
   ep : struct list *node = malloc(sizeof(struct list));
(2)清节点数据(由于结构体变量在未初始化的时候，数据是脏的)
   ep : memset(node,0,sizeof(struct list));
(3)给节点初始化数据
   ep : node->id = data ; 
(4)将该节点的指针域设置为NULL
   ep : node->next = NULL ;
回复

收藏 举报

 楼主| 小灵通2018 发表于 2019-4-25 18:09 | 显示全部楼层
2、单链表的尾插：
尾插节点函数原型可定义如下：
847365cc18758c8d9b.png

如何将当前链表和新的节点相连接？只要实现：
header->next = new 
尾插流程如下：

(1)获取当前节点的位置，也就是访问头节点
   ep : struct list *p = header ;
(2)判断是否为最后一个节点，如果不是，移动到下一个节点，如果是，将数据插入尾部。
   ep : while(NULL != p->next) p = p->next ;
        p->next = new ;
回复

收藏 举报

 楼主| 小灵通2018 发表于 2019-4-25 18:10 | 显示全部楼层
3、单链表的头插
995595cc187765a9ae.png
很好理解，头插就是把新的节点插在原来的节点和原来节点的下一个节点之间的一个节点。如图，新的节点插在头节点和节点1。
所以可以推出头插流程如下：
(1)获取当前节点的位置，也就是访问头节点
    ep : struct list *p = header ;
(2)新的节点的下一个节点设置为原来头节点的下一个节点(第一个节点)
    ep : new->next = p->next ;
(3)原来的头节点的下一个节点设置为现在新插入的头节点
    ep : p->next = new ;
回复

收藏 举报

 楼主| 小灵通2018 发表于 2019-4-25 18:11 | 显示全部楼层
4、单链表的遍历
255195cc187a49b4cb.png
如图为一条单向链表的模型，看图知道该链表由头节点和若干个节点组成，最后一个节点(尾节点)为NULL 。
从图中可以得出信息，如果我们要打印出各个节点的数据，要考虑以下问题：
(1)需要打印头节点吗？(头节点肯定是不用打印的，因为这是我们为了操作方便而设置的一个节点)。
(2)这条链表有多少个节点我们怎么知道？(通过判断该链表是否已经到达了尾节点，标志就是NULL)
那么可以得到流程如下：
(1)获取当前节点的位置，也就是访问头节点
    ep : struct list *p = header ;
(2)由于头节点我们不需要去打印它，这时候，初始化打印的节点需要从第一个节点开始。
    ep : p = p->next ;  
(3)判断是否为最后一个节点，如果不是，先打印第一个节点的数据(1)，然后移动到下一个节点(2),重复这两个步骤。
   如果是最后一个节点，直接打印数据即可。
    while(NULL != p->next){ printf("node:%d\n",p->data) ; p = p->next ;}
    printf("node:%d\n",p->data);
    当然还可以一句代码解决，这样就达到了先偏移，后取数据。
    while(NULL != p->next){ p = p->next ; printf("node:%d\n",p->data) ; }
回复

收藏 举报

 楼主| 小灵通2018 发表于 2019-4-25 18:11 | 显示全部楼层
5、单链表的删除
删除节点的函数原型可定义如下：
int detele_list_node(struct list *pH , int data);
单向链表的删除要考虑两种情况，一种的普通节点的删除(当然，头节点不能算)
还有一种是尾节点的前一个节点的删除情况，注意，删除完节点还需要释放对应节点的内存空间。
976605cc187ca36cc5.png
763045cc187d0ce561.png
删除节点的设计流程：
(1)先定义两个指针，一个表示当前的节点，另一个表示当前节点的上一个节点。
    ep : struct list *p = header ;  //当前节点
         struct list *prev = NULL ; //当前节点的上一个节点
(2)遍历整个链表，同时保存当前节点的前一个节点
    ep : while(NULL != p->next)
        { 
          //保存了当前的节点的前一个节点
          prev = p ;  
          //保存当前偏移的节点
          p = p->next ; 
          return 0 ;
        }
(3)在遍历的过程中查找要删除的数据
    ep : while(NULL != p->next)
        { 
          //保存了当前的节点的前一个节点
          prev = p ;  
          //保存当前偏移的节点
          p = p->next ; 
          //查找到了数据
          if(p->id == data)
          {
          
          }
          return 0 ;
        }
(4)查找到了数据后，分两种情况删除
    ep : 普通节点的删除
        if(p->id == data)
        {
            prev->next = p->next ;
            free(p);
        }
    ep : 考虑尾节点的下一个节点为NULL的节点删除
        if(p->id == data)
        {
            if(p->next == NULL)
            {
                prev->next = NULL ;
                free(p);
            }
        }
回复

收藏 举报

 楼主| 小灵通2018 发表于 2019-4-25 18:12 | 显示全部楼层
6、单链表的逆序
601475cc187f2a8c8b.png
逆序步骤：
285335cc18804124ed.png

回复

收藏 举报

 楼主| 小灵通2018 发表于 2019-4-25 18:13 | 显示全部楼层
单链表的基本操作流程咱们基本搞懂了，下面写一个程序，这将会变得非常非常的简单。
复制
  1. #include <stdio.h>
    

  2. #include <stdlib.h>
    

  3. #include <string.h>
    

  4. typedef struct slist
    

  5. {
    

  6.         int id ;
    

  7.         struct slist *next ;                        
    

  8. }L;
    

  9.  
    

  10. //创建一个节点 
    

  11. L *create_node(int data)
    

  12. {
    

  13.         //给每个节点分配结构体一样的空间大小 
    

  14.         L *p = malloc(sizeof(L));
    

  15.         if(NULL == p)
    

  16.         {
    

  17.                 printf("malloc error!\n");
    

  18.                 return NULL ;
    

  19.         }
    

  20.         //由于结构体在未初始化的时候一样是脏数据，所以要清 
    

  21.         memset(p,0,sizeof(L));
    

  22.         //初始化第一个节点 
    

  23.         p->id = data ; 
    

  24.         //将节点的后继指针设置为NULL 
    

  25.         p->next = NULL ;
    

  26. }
    

  27.  
    

  28. //链表的尾插 
    

  29. void tail_insert(L *pH , L *new)
    

  30. {
    

  31.         //获取当前的位置 
    

  32.         L *p = pH ; 
    

  33.         //如果当前位置的下一个节点不为空 
    

  34.         while(NULL != p->next)
    

  35.         {
    

  36.                 //移动到下一个节点 
    

  37.                 p = p->next ;
    

  38.         }
    

  39.         //如果跳出以上循环，所以已经到了NULL的这个位置
    

  40.         //此时直接把新插入的节点赋值给NULL这个位置 
    

  41.         p->next = new ;
    

  42. }
    

  43.  
    

  44. //链表的头插 
    

  45. void top_insert(L *pH , L *new)
    

  46. {
    

  47.         L *p = pH ;
    

  48.         new->next = p->next ;
    

  49.         p->next = new ;
    

  50. }
    

  51.  
    

  52. //链表的遍历 
    

  53. void Print_node(L *pH)
    

  54. {
    

  55.         //获取当前的位置 
    

  56.         L *p = pH ;
    

  57.         //获取第一个节点的位置 
    

  58.         p = p->next ;
    

  59.         //如果当前位置的下一个节点不为空 
    

  60.         while(NULL != p->next)
    

  61.         {
    

  62.                 //(1)打印节点的数据 
    

  63.                 printf("id:%d\n",p->id);
    

  64.                 //(2)移动到下一个节点,如果条件仍为真，则重复(1)，再(2) 
    

  65.                 p = p->next ;
    

  66.         }
    

  67.         //如果当前位置的下一个节点为空，则打印数据
    

  68.         //说明只有一个节点 
    

  69.         printf("id:%d\n",p->id);
    

  70. }
    

  71.  
    

  72. //删除链表中的节点 
    

  73. int detele_list_node(L * pH , int data)
    

  74. {
    

  75.         //获取当前头节点的位置 
    

  76.         L *p = pH ;
    

  77.         L *prev = NULL;
    

  78.         while(NULL != p->next)
    

  79.         {
    

  80.                 //保存当前节点的前一个节点的指针 
    

  81.                 prev = p ;
    

  82.                 //然后让当前的指针继续往后移动 
    

  83.                 p = p->next ;         
    

  84.                 //判断，找到了要删除的数据  
    

  85.                 if(p->id == data)
    

  86.                 {
    

  87.                         //两种情况，一种是普通节点，还有一种是尾节点
    

  88.                         if(p->next != NULL)  //普通节点的情况 
    

  89.                         {
    

  90.                                 prev->next = p->next ;
    

  91.                                 free(p);
    

  92.                         }
    

  93.                         else //尾节点的情况 
    

  94.                         {
    

  95.                                 prev->next = NULL ; //将这个尾节点的上一个节点的指针域指向空 
    

  96.                                 free(p); 
    

  97.                         }
    

  98.                         return 0  ;
    

  99.                 }
    

  100.         }
    

  101.         printf("没有要删除的节点\n");
    

  102.         return -1 ;
    

  103. }
    

  104.  
    

  105. void trave_list(L * pH)
    

  106. {
    

  107.         //保存第一个节点的位置 
    

  108.         L *p = pH->next;
    

  109.         L *pBack;
    

  110.         int i = 0 ;
    

  111.         if(p->next == NULL || p == NULL)
    

  112.                 return ;
    

  113.                 
    

  114.         while(NULL != p->next) //遍历链表 
    

  115.         {
    

  116.                 //保存第一个节点的下一个节点 
    

  117.                 pBack = p->next ; 
    

  118.                 //找到第一个有效节点,其实就是头指针的下一个节点 
    

  119.                 if(p == pH->next) 
    

  120.                 {
    

  121.                         //第一个有效节点就是最后一个节点，所以要指向NULL 
    

  122.                         p->next = NULL ; 
    

  123.                 } 
    

  124.                 else
    

  125.                 {
    

  126.                         /*
    

  127.                         new->next = p->next ;
    

  128.                         p->next = new ;
    

  129.                         */
    

  130.                         p->next = pH->next ; //尾部连接 
    

  131.                 }
    

  132.                 pH->next = p ; //头部连接 
    

  133.                 p = pBack ; //走下一个节点 
    

  134.         }
    

  135.         top_insert(pH,p); //插入最后一个节点 
    

  136. }
    

  137.  
    

  138. int main(int argc , char **argv) 
    

  139. {
    

  140.         //创建第一个节点 
    

  141.         int i ;
    

  142.         L *header = create_node(0); 
    

  143.         for(i = 1 ; i < 10 ; i++)
    

  144.         {
    

  145.                 tail_insert(header,create_node(i));
    

  146.         }
    

  147.         Print_node(header);
    

  148.         detele_list_node(header,5);
    

  149.         putchar('\n');
    

  150.         Print_node(header);
    

  151.         putchar('\n');
    

  152.         trave_list(header);
    

  153.         Print_node(header);
    

  154.         return 0 ;
    

  155. }
151875cc1884e2c604.png
回复

收藏 举报

 楼主| 小灵通2018 发表于 2019-4-25 18:14 | 显示全部楼层
当然，单链表存在一定的弊端，就是查找数据和删除数据的时候比较麻烦，而双链表的出现就是为了解决它的弊端：

双链表的引入是为了解决单链表的不足：
(1)双链表可以往前遍历，也可以往后遍历，具有两个方向
双链表的节点 = 有效数据 + 两个指针(分别指向前一个节点和后一个节点)
双向链表的图形结构描述:
67495cc188783deda.png
复制
  1. struct double_list                                   struct double_list
    

  2. {                                                            {
    

  3.     数据域;                  ep :------->                   int data ;
    

  4.     指针域(前向指针) ;                                   struct double_list *prev ;
    

  5.     指针域(后向指针) ;                                   struct double_list *next ;
    

  6. };                                                             };
1、双向链表的创建
struct list *create_node(int data) ;
创建步骤(与单链表类似，就是多了一个指针):
(1)给节点申请空间：
   ep : struct double_list *p = malloc(sizeof(struct double_list));
(2)初始化数据域
   ep : p->data = data ;
(3)初始化指针域
   ep : p->prev = NULL ;
        p->next = NULL ;

2、双向链表的尾插
双向链表尾插节点的函数可以定义如下：
void double_list_tail_insert(struct double_list *header , struct double_list *new) ;
尾插图示操作：

尾插的步骤：


(1)找到链表的尾节点
   ep : 和单链表差不多
        DL *p = header ;
        while(NULL != p->next)
            p = p->next ;
(2)将新的节点连接到尾节点的后面成为新的节点
   1.原来的next指针指向新节点的首地址。            p->next = new ;
   2.新节点的prev指针指向原来的尾节点的首地址。 new->prev = p;

回复

收藏 举报

 楼主| 小灵通2018 发表于 2019-4-25 18:15 | 显示全部楼层
3、双向链表的头插
双向链表头插节点的函数可以定义如下：
void double_list_top_insert(struct double_list *header , struct double_list *new) ;
526025cc188b94fc4d.png
319785cc188c954f09.png
4、双向链表的遍历

4.1 正向遍历
    void double_list_for_each(DL *header)
    步骤：和单链表完全一致，没什么好写的。
    
    
4.2 反向遍历
    void double_list_for_each_nx(DL *header)
    步骤：(1)和单链表一样，先循环找到最后一个节点的地址
          (2)再依靠prev指针循环往前移动
             2.1 先打印最后一个数据  ep : printf("%d ",p->data);
             2.2 向前循环遍历         ep : p = p->prev ;
             
             判断条件：header->prev != p->prev,
             header保存的是头节点的地址,
             header->prev保存的是头节点的prev的地址,
             header->next保存的是头节点的next的地址,
             头节点在创建的时候:
             header->prev = NULL ;
             header->next = NULL ;
             所以这个条件这样写header->prev = NULL也是对的。
回复

收藏 举报

 楼主| 小灵通2018 发表于 2019-4-25 18:16 | 显示全部楼层
5、双向链表节点的删除

假设需要删除节点1：    
    首先:
    (1)获取当前节点的地址： 
        ep : p = header;
    (2)遍历所有的节点，找到要删除的节点：
        ep : 
        while(NULL != p->next)
        {
            p = p->next ;
            if(p->data == data)
            {
            
            }
        }
    (3)找到要删除的数据以后，需要做判断，判断两种情况，这和单链表差不多
    3.1 如果找到当前节点的下一个节点不为空
    3.1.1    
        那就把当前节点的prev节点指向要删除的这个节点的prev
        因为当前的prev节点保存的是要删除的上一个节点的指针 
        p->next->prev = p->prev ;
    3.1.2    
        然后将当前节点的prev指针(也就是上一个节点的指针)指向当前节点(要删除的)的下一个节点:
        p->prev->next = p->next ;
    3.1.3    
        最后释放删除指针的空间：
        free(p);
        
    3.2 如果找到当前节点的下一个节点为空
    3.2.1   
    直接把当前指针(要删除的节点)的prev指针(保存着当前指针的上一个节点的地址)的下一个next指针设置为空。
    p->prev->next = NULL ;
    3.2.2
    将删除的指针的空间释放:
    free(p);
    看来，双链表学起来比单链表容易多了！确实啊，多了一个方向，操作起来就更加容易了，但是多了一个方向，一维多了一个指针，相比增加了一定的复杂度，但是，只要牢记prev指针和next指针的指向，那么，手画一图，代码即可写出！
下面给一个案例实现一下双向链表：
复制
  1. #include <stdio.h>
    

  2. #include <stdlib.h>
    

  3. #include <string.h>
    

  4. //创建一个双链表的数据结构
    

  5. typedef struct __double_list
    

  6. {
    

  7.         int data ;
    

  8.         struct __double_list *prev ;
    

  9.         struct __double_list *next ;
    

  10. }DL ; 
    

  11.  
    

  12. //创建双向链表并插入一个节点 
    

  13. DL *create_dl_node(int data)
    

  14. {
    

  15.         DL *p = malloc(sizeof(DL));
    

  16.         if(NULL == p)
    

  17.         {
    

  18.                 printf("create dl node fair!\n");
    

  19.                 return NULL ;
    

  20.         }
    

  21.         //初始化数据 
    

  22.         p->data = data ;
    

  23.         //初始化指针 
    

  24.         p->next = NULL ;
    

  25.         p->prev = NULL ;
    

  26. }
    

  27.  
    

  28. //双向链表的尾插 
    

  29. void double_list_tail_insert(DL *header , DL *new)
    

  30. {
    

  31.         //取得当前节点的地址 
    

  32.         DL *p = header ;
    

  33.         //找到链表的尾节点 
    

  34.         while(NULL != p->next)
    

  35.         {
    

  36.                 //找不到接着找 
    

  37.                 p = p->next ;
    

  38.         }
    

  39.         //找到了尾节点，指向新节点的首地址 
    

  40.         p->next = new ;
    

  41.         //新节点的prev指针指向原来的尾节点的首地址。
    

  42.         new->prev = p;
    

  43. }
    

  44.  
    

  45. //双向链表的头插(也就是插在两个节点之间的插入方式)
    

  46. void double_list_top_insert(DL *header , DL *new)
    

  47. {
    

  48.         //新节点的next指针指向原来的节点一的地址
    

  49.         new->next = header->next ; 
    

  50.         //判断当前节点的下一个节点的地址是否为空
    

  51.         if(NULL != header->next) 
    

  52.                 header->next->prev = new ; //节点1的prev指针指向新节点的地址 
    

  53.         header->next = new ;
    

  54.         new->prev = header ;
    

  55. }
    

  56.  
    

  57. //双向链表的正向遍历 
    

  58. void double_list_for_each(DL *header)
    

  59. {
    

  60.         DL *p = header ;
    

  61.         while(NULL != p->next)
    

  62.         {
    

  63.                 p = p->next ;
    

  64.                 printf("%d ",p->data);
    

  65.         }
    

  66. }
    

  67.  
    

  68. //双向链表的反向遍历 
    

  69. void double_list_for_each_nx(DL *header)
    

  70. {
    

  71.         DL *p = header ;
    

  72.         //先找到尾节点
    

  73.         while(NULL != p->next)
    

  74.         {
    

  75.                 p = p->next ;        
    

  76.         } 
    

  77.         //已经找到了尾节点，向前遍历，注意，遍历到头节点之前
    

  78.         //限制条件: != 头结点 
    

  79.         while(NULL != p->prev)
    

  80.         {
    

  81.                 printf("%d ",p->data);
    

  82.                 p = p->prev ;
    

  83.         }
    

  84. }
    

  85.  
    

  86. //双向链表节点的删除
    

  87. int double_list_delete_node(DL *header , int data)
    

  88. {
    

  89.         //取得当前节点 
    

  90.         DL *p = header;
    

  91.         //遍历所有的节点 
    

  92.         while(NULL != p->next)
    

  93.         {
    

  94.                 p = p->next ;
    

  95.                 //找到了对应要删除的数据了 
    

  96.                 if(p->data == data)
    

  97.                 {
    

  98.                         //一样存在两种情况
    

  99.                         //(1)当前节点的下一个节点不为空
    

  100.                         if(p->next != NULL)
    

  101.                         {
    

  102.                                 //那就把当前节点的prev节点指向要删除的这个节点的prev
    

  103.                                 //因为当前的prev节点保存的是要删除的上一个节点的指针 
    

  104.                                 p->next->prev = p->prev ;
    

  105.                                 //还要指定它的next节点 
    

  106.                                 p->prev->next = p->next ;
    

  107.                                 free(p);
    

  108.                         }
    

  109.                         //(2)当前节点的下一个节点为空 
    

  110.                         else
    

  111.                         {
    

  112.                                 //把 
    

  113.                                 p->prev->next = NULL ;
    

  114.                                 free(p); 
    

  115.                         }
    

  116.                         return 0 ;
    

  117.                 }
    

  118.         }
    

  119.         printf("\n没有找到对应要删除的节点，或者节点已经被删除！\n");
    

  120.         return -1 ;        
    

  121. } 
    

  122.  
    

  123. int main(void)
    

  124. {
    

  125.         int i ;
    

  126.         DL *header = create_dl_node(0);
    

  127.         for(i = 0 ; i < 10 ; i++)
    

  128.         {
    

  129.                 //双向链表的尾插 
    

  130.                 //double_list_tail_insert(header,create_dl_node(i));
    

  131.                 //双向链表的头插 
    

  132.                 double_list_top_insert(header,create_dl_node(i));
    

  133.         }
    

  134.         //双向链表的正向遍历 
    

  135.         printf("双向链表的正向遍历:");
    

  136.         double_list_delete_node(header,5);
    

  137.         double_list_for_each(header);
    

  138. //        double_list_delete_node(header,9);
    

  139.         double_list_delete_node(header,5);
    

  140.         putchar('\n');
    

  141.         printf("双向链表的反向遍历:");
    

  142.         double_list_for_each_nx(header);
    

  143.         return 0 ;
    

  144. }
回复

收藏 举报

 楼主| 小灵通2018 发表于 2019-4-25 18:17 | 显示全部楼层
运行结果：
9085cc1892867320.png
回复

收藏 举报

643757107 发表于 2019-4-25 20:24 | 显示全部楼层
好多人说不会链表
回复

收藏 举报

643757107 发表于 2019-4-25 20:24 | 显示全部楼层
我也不会
回复

收藏 举报

xinpian101 发表于 2019-4-25 21:43 | 显示全部楼层
指针的精髓。
回复

收藏 举报

下一页 »
12下一页
返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

小灵通2018

158

主题

1732

帖子

4

粉丝
快速回复 在线客服 返回列表 返回顶部