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

打印 上一主题 下一主题

主题 933|帖子 933|积分 2799

链表的相关操纵作业:
1】 按值修改
2】按值查找,返回当前节点的地址 (先不考虑重复,假如有重复,返回第一个)
3】 逆置(反转)
4】释放链表
main.c
  1. #include "head.h"
  2. int main(int argc, const char *argv[])
  3. {
  4.     //创建链表,头结点
  5.     linklist_ptr p=create();
  6.     //判断链表是否为空
  7.     empty(p);
  8.     //头插
  9.     insert_head(p,10);
  10.     insert_head(p,11);
  11.     insert_head(p,12);
  12.     //输出
  13.     output(p);
  14.     //尾插
  15.     insert_tail(p,1);
  16.     insert_tail(p,2);
  17.     insert_tail(p,3);
  18.     output(p);
  19.     //任意位置插入
  20.     insert_index(p,2,99);
  21.     output(p);
  22.     //头删
  23.     del_head(p);
  24.     output(p);
  25.     //尾删除                             
  26.     del_tail(p);
  27.     output(p);
  28.     //任意位置删除
  29.     del_index(p,2);
  30.     output(p);
  31.     //按照所给位数修改值
  32.     change_element(p,1,99);
  33.     output(p);
  34.     //按照所给的值查找
  35.     find_element(p,1);
  36.     output(p);
  37.     //反转
  38.     reversal(p);
  39.     output(p);
  40.     return 0;
  41. }
复制代码
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. }                                                                             
复制代码
 

 


免责声明:如果侵犯了您的权益,请联系站长,我们会及时删除侵权内容,谢谢合作!更多信息从访问主页:qidao123.com:ToB企服之家,中国第一个企服评测及商务社交产业平台。
回复

使用道具 举报

0 个回复

倒序浏览

快速回复

您需要登录后才可以回帖 登录 or 立即注册

本版积分规则

温锦文欧普厨电及净水器总代理

金牌会员
这个人很懒什么都没写!
快速回复 返回顶部 返回列表