devbox
繁依Fanyi0
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

作业/数据结构/2024/7/8

作者：繁依Fanyi0 | 2024-07-13 22:17:23

赞

踩

作业/数据结构/2024/7/8

链表的相关操作作业：

1】 按值修改

2】按值查找，返回当前节点的地址 （先不考虑重复，如果有重复，返回第一个）

3】 逆置(反转)

4】释放链表

main.c

  1. #include "head.h"
  2.  
  3. int main(int argc, const char *argv[])
  4. {
  5.     //创建链表,头结点
  6.     linklist_ptr p=create();
  7.     //判断链表是否为空
  8.     empty(p);
  9.     //头插
  10.     insert_head(p,10);
  11.     insert_head(p,11);
  12.     insert_head(p,12);
  13.     //输出
  14.     output(p);
  15.     //尾插
  16.     insert_tail(p,1);
  17.     insert_tail(p,2);
  18.     insert_tail(p,3);
  19.     output(p);
  20.     //任意位置插入
  21.     insert_index(p,2,99);
  22.     output(p);
  23.     //头删
  24.     del_head(p);
  25.     output(p);
  26.     //尾删除                             
  27.     del_tail(p);
  28.     output(p);
  29.     //任意位置删除
  30.     del_index(p,2);
  31.     output(p);
  32.     //按照所给位数修改值
  33.     change_element(p,1,99);
  34.     output(p);
  35.     //按照所给的值查找
  36.     find_element(p,1);
  37.  
  38.     output(p);
  39.     //反转
  40.     reversal(p);
  41.     output(p);
  42.     return 0;
  43. }

head.h

  1. #include <stdio.h>                                       
  2. #include <stdlib.h>                                      
  3. //定义节点数据的类型                                     
  4. typedef int datatype;                                    
  5. //定义链表结构体                                         
  6. typedef struct node                                      
  7. {                                                        
  8.     union                                                
  9.     {                                                    
  10.         //表示节点的个数                                 
  11.         int len;                                         
  12.         //节点的数据                                     
  13.         datatype data;                                   
  14.     };                                                   
  15.     //指针域                                             
  16.     struct node *next;                                   
  17. }linklist,*linklist_ptr;                                 
  18.                                                          
  19.                                                          
  20. //1.链表的创建                                           
  21. linklist_ptr create();                                   
  22. //2.判断链表是否为空                                     
  23. int  empty(linklist_ptr p);                              
  24. //3.申请节点封装数据                                     
  25. linklist_ptr node_create(datatype e);                    
  26. //4.头插                                                 
  27. int insert_head(linklist_ptr p,datatype e);              
  28. //5.输出                                                 
  29. void output(linklist_ptr p);                             
  30. //6.尾插                                                 
  31. int insert_tail(linklist_ptr p,datatype e);              
  32. //7.任意位置插入                                         
  33. int insert_index(linklist_ptr p,int index,datatype e);   
  34. //8.头删                                                 
  35. int del_head(linklist_ptr p);                            
  36. //9.尾删除                                               
  37. int del_tail(linklist_ptr p);                            
  38. //10.任意位置删除                                        
  39. int del_index(linklist_ptr p,int index);                 
  40. //11.按照所给的值修改                                    
  41. int change_element(linklist_ptr p,int index,datatype e); 
  42. //12.按照所给的值查找                                    
  43. linklist_ptr find_element(linklist_ptr p,datatype e);    
  44. //13.反转                                                
  45. int  reversal(linklist_ptr p);                           
  46. #endif

fun.c

  1.     {                                                                         
  2.         q=q->next;                                                            
  3.     }                                                                         
  4.     q->next=p1;                                                               
  5.     p->len++;                                                                 
  6.     return 1;                                                                 
  7. }                                                                             
  8.                                                                               
  9.                                                                               
  10. //7.任意位置插入                                                              
  11. int insert_index(linklist_ptr p,int index,datatype e)                         
  12. {                                                                             
  13.     if(NULL==p || index<1 || index>p->len+1)                                  
  14.     {                                                                         
  15.         printf("尾插失败\n");                                                 
  16.         return -1;                                                            
  17.     }                                                                         
  18.     //申请节点                                                                
  19.     linklist_ptr p1=node_create(e);                                           
  20.     linklist_ptr q=p;                                                         
  21.     for(int i=0;i<index;i++)                                                  
  22.     {                                                                         
  23.         q=q->next;                                                            
  24.     }                                                                         
  25.     p1->next=q->next;                                                         
  26.     q->next=p1;                                                               
  27.     p->len++;                                                                 
  28.     return 1;                                                                 
  29. }                                                                             
  30.                                                                               
  31.                                                                               
  32. //8.头删                                                                      
  33. int del_head(linklist_ptr p)                                                  
  34. {                                                                             
  35.     if(NULL==p || empty(p))                                                   
  36.     {                                                                         
  37.         printf("头删失败\n");                                                 
  38.     }                                                                         
  39.     //定义一个指针指向头指针指向的节点                                        
  40.     linklist_ptr p1=p->next;                                                  
  41.     p->next=p1->next;                                                         
  42.     free(p1);                                                                 
  43.     p1=NULL;                                                                  
  44.                                                                               
  45.     p->len--;                                                                 
  46.     return 1;                                                                 
  47.                                                                               
  48. }                                                                             
  49.                                                                               
  50.                                                                               
  51. //9.尾删除                                                                    
  52. int del_tail(linklist_ptr p)                                                  
  53. {                                                                             
  54.     if(NULL==p || empty(p))                                                   
  55.     {                                                                         
  56.         printf("尾删失败\n");                                                 
  57.         return 0;                                                             
  58.     }                                                                         
  59.     //定义一个指针指向头结点并让其循环到最后一个节点的前一个节点              
  60.     linklist_ptr p1=p;                                                        
  61.     for(int i=0;i<p->len-1;i++)                                               
  62.     {                                                                         
  63.         p1=p1->next;                                                          
  64.     }                                                                         
  65.     //指向需要删除最后一个节点                                                
  66.     linklist_ptr p2=p1->next;                                                 
  67.     p1->next=p1->next;                                                        
  68.     //释放                                                                    
  69.     free(p2);                                                                 
  70.     p2=NULL;                                                                  
  71.     p->len--;                                                                 
  72.     return 1;                                                                 
  73. }                                                                             
  74.                                                                               
  75. //10.任意位置删除                                                             
  76. int del_index(linklist_ptr p,int index)                                       
  77. {                                                                             
  78.     if(NULL==p || empty(p) || index>p->len ||index<0)                         
  79.     {                                                                         
  80.         printf("任意位置删除失败\n");                                         
  81.         return 0;                                                             
  82.     }                                                                         
  83.     //定义一个指针指向头结点用于循环到所需要                                  
  84.     //的位置的上一个节点                                                      
  85.     linklist_ptr p1=p;                                                        
  86.     for(int i=0;i<index-1;i++)                                                
  87.     {                                                                         
  88.         p1=p1->next;                                                          
  89.     }                                                                         
  90.     //定义一个指针指向需要被删除的节点                                        
  91.     linklist_ptr p2=p1->next;                                                 
  92.     p1->next=p2->next;                                                        
  93.     //释放                                                                    
  94.     free(p2);                                                                 
  95.     p2=NULL;                                                                  
  96.     p->len--;                                                                 
  97.     return 1;                                                                 
  98. }                                                                             
  99.                                                                               
  100.                                                                               
  101. //11.按照所给的值修改                                                         
  102. int change_element(linklist_ptr p,int index,datatype e)                       
  103. {                                                                             
  104.     if(NULL==p || empty(p) || index>p->len || index<0)                        
  105.     {                                                                         
  106.         printf("任意位置修改失败\n");                                         
  107.         return 0;                                                             
  108.     }                                                                         
  109.     //定义一个指针找到所需要的修改的节点                                      
  110.     linklist_ptr p1=p;                                                        
  111.     for(int i=0;i<index;i++)                                                  
  112.     {                                                                         
  113.         p1=p1->next;                                                          
  114.     }                                                                         
  115.     //修改其中的值                                                            
  116.     p1->data=e;                                                               
  117.                                                                               
  118. }                                                                             
  119.                                                                               
  120.                                                                               
  121. //12.按照所给的值查找                                                         
  122. linklist_ptr find_element(linklist_ptr p,datatype e)                          
  123. {                                                                             
  124.     if(NULL==p || empty(p))                                                   
  125.     {                                                                         
  126.         printf("查找值失败\n");                                               
  127.         return NULL;                                                          
  128.     }                                                                         
  129.     //记录相同的次数                                                          
  130.     int flag=0;                                                               
  131.     //循环查找                                                                
  132.     linklist_ptr p1=p;                                                        
  133.     for(int i=0;i<p->len;i++)                                                 
  134.     {                                                                         
  135.         p1=p1->next;                                                          
  136.         if(p1->data==e)                                                       
  137.         {                                                                     
  138.             printf("第%d个元素的值相等\n",i+1);                               
  139.             flag++;                                                           
  140.         }                                                                     
  141.         if(flag==1)                                                           
  142.         {                                                                     
  143.             return p1;                                                        
  144.         }                                                                     
  145.                                                                               
  146.     }                                                                         
  147.          if(flag==0)                                                          
  148.         {                                                                     
  149.             printf("未查找到相应的值\n");                                     
  150.         }                                                                     
  151.     return p;                                                                 
  152. }                                                                             
  153.                                                                               
  154.                                                                               
  155. //13.反转                                                                     
  156. int  reversal(linklist_ptr p)                                                 
  157. {                                                                             
  158.     if(NULL == p || empty(p))                                                 
  159.     {                                                                         
  160.         printf("反转失败\n");                                                 
  161.         return 0;                                                             
  162.     }                                                                         
  163.                                                                               
  164.     linklist_ptr p1 = p->next; // 保存第1个节点的地址                         
  165.     p->next = NULL; // 断开原头结点的连接（使其成为反转后的链表的尾节点）     
  166.     linklist_ptr p2;                                                          
  167.     while(p1->next!=NULL)                                                     
  168.     {                                                                         
  169.         p2 = p1; // 将当前节点保存到p2，以便将其插入到头部                    
  170.         p1 = p1->next; // 移动到下一个节点                                    
  171.         p2->next = p->next; // 将p2插入到p之前（使p2成为新的头结点）          
  172.         p->next = p2; // 更新p为新插入的节点（更新头结点）                    
  173.     }                                                                         
  174.                                                                               
  175.     return 1; // 返回反转后链表的新头结点                                     
  176. }

 

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/繁依Fanyi0/article/detail/821802
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号