8-1链表

  1 #include <stdio.h>                                                                                                                             
  2 #include <stdlib.h>                                                                                                                            
  3 #include "./02_linklistFunc.h"                                                                                                                 
  4 //创建一个单链表                                                                                                                               
  5 Linklist* create_linklist(void)                                                                                                                
  6 {                                                                                                                                              
  7     //在堆空间中申请头部空间,讲头部空间的首地址传入head中                                                                                     
  8     Linklist *head=(Linklist*)malloc(sizeof(Linklist));                                                                                        
  9     if(head == NULL)//判断头部空间是否申请成功                                                                                                 
 10     {                                                                                                                                          
 11         printf("申请头部空间失败");                                                                                                            
 12         return NULL;                                                                                                                           
 13     }                                                                                                                                          
 14     head->text.len=0;//初始化头部的len                                                                                                         
 15     head->next=NULL;//将头部空间中的指针域赋为NULL                                                                                             
 16     return head;                                                                                                                               
 17 }                                                                                                                                              
 18 //头插法                                                                                                                                       
 19 void insert_linklist_head(Linklist *head,datatype num)                                                                                         
 20 {                                                                                                                                              
 21     //创建新的节点temp                                                                                                                         
 22     Linklist *temp=(Linklist*)malloc(sizeof(Linklist));                                                                                        
 23     if(NULL == temp)                                                                                                                           
 24     {                                                                                                                                          
 25         printf("创建节点失败");                                                                                                                
 26         return;                                                                                                                                
 27     }                                                                                                                                          
 28     temp->text.data=num;   //数据域赋值                                                                                                        
 29     temp->next=NULL; //指针域赋值                                                                                                              
 30                                                                                                                                                
 31 //-------------------------------                                                                                                              
 32     temp->next=head->next;                                                                                                                     
 33     head->next=temp;                                                                                                                           
 34 //更新头结点链表中的len长度                                                                                                                    
 35     head->text.len++;                                                                                                                          
 36 }                                                                                                                                              
 37 //头删                                                                                                                                         
 38 void headshan_linklist(Linklist *head)                                                                                                         
 39 {                                                                                                                                              
 40     //将头部指针另存为p                                                                                                                        
 41     Linklist *p=head;                                                                                                                          
 42     //判断链表是否为空                                                                                                                         
 43     if(p->next==NULL)                                                                                                                          
 44     {                                                                                                                                          
 45         printf("单链表为空,无法删除");                                                                                                        
 46         return;                                                                                                                                
 47     }                                                                                                                                          
 48     //创建一个新的temp指针接收需要删除的节点                                                                                                   
 49     Linklist *temp=p->next;                                                                                                                    
 50     p->next=temp->next; //将头部节点的next置为第二个节点的地址                                                                                 
 51     free(temp);//释放被删除的节点防止内存泄漏                                                                                                  
 52     temp->next=NULL;                                                                                                                           
 53     //头部定义了len长度需要做--                                                                                                                
 54     head->text.len--;                                                                                                                          
 55 }                                                                                                                                              
 56 //尾插                                                                                                                                         
 57 void tail_linklist(Linklist *head,datatype num)                                                                                                
 58 {                                                                                                                                              
 59     Linklist *p=head;                                                                                                                          
 60     //创建新的节点,将首地址赋值给temp                                                                                                         
 61     Linklist *temp=(Linklist*)malloc(sizeof(Linklist));                                                                                        
 62     if(NULL == temp)                                                                                                                           
 63     {                                                                                                                                          
 64         printf("创建节点失败");                                                                                                                
 65         return;                                                                                                                                
 66     }                                                                                                                                          
 67     temp->text.data=num;                                                                                                                       
 68     temp->next=NULL;                                                                                                                           
 69     while(p->next!=NULL)//循环判断p->next是否为NULL                                                                                            
 70     {                                                                                                                                          
 71         p=p->next;                                                                                                                             
 72     }                                                                                                                                          
 73     //                                                                                                                                         
 74     //temp->next=NULL;                                                                                                                         
 75         p->next=temp;//尾部插入数据                                                                                                            
 76 //更新头结点中的链表长度                                                                                                                       
 77     head->text.len++;                                                                                                                          
 78 }                                                                                                                                              
 79 //尾删                                                                                                                                         
 80 void tail_shan_linklist(Linklist *head)                                                                                                        
 81 {                                                                                                                                              
 82     //将传进来的头部节点地址另存为p                                                                                                            
 83     Linklist *p = head;                                                                                                                        
 84     //判断链表是否为空                                                                                                                         
 85     if(p->next==NULL)                                                                                                                          
 86     {                                                                                                                                          
 87         printf("单向链表为空,无可释放的节点");                                                                                                
 88         return;                                                                                                                                
 89     }                                                                                                                                          
 90     //尾删需要找到倒数第二个数据(利用循环判断)                                                                                                 
 91     while(p->next->next!=NULL)//p->next->next的节点为NULL时结束循环                                                                            
 92     {                                                                                                                                          
 93         p=p->next;                                                                                                                             
 94     }                                                                                                                                          
 95     //将需要删除的节点地址另存并释放掉                                                                                                         
 96     Linklist *temp;                                                                                                                            
 97     free(temp=p->next);                                                                                                                        
 98     p->next=NULL;//将倒数第二个结点的next置为NULL                                                                                              
 99     //头部定义的len做--                                                                                                                        
100     head->text.len--;                                                                                                                          
101 }                                                                                                                                              
102 //按位置插入                                                                                                                                   
103 void Pos_insert_linklist(Linklist *head,int index,datatype num)                                                                                
104 {                                                                                                                                              
105     //将传入进来的头部结点地址赋給p                                                                                                            
106     Linklist *p = head;                                                                                                                        
107     //创建一个新的结点赋地址给temp                                                                                                             
108     Linklist *temp=(Linklist*)malloc(sizeof(Linklist));                                                                                        
109     //判断是否成功向堆空间申请到一个结点空间                                                                                                   
110     if(temp == NULL)                                                                                                                           
111     {                                                                                                                                          
112         printf("创建节点失败,按位置插入失败");                                                                                                
113         return;                                                                                                                                
114     }                                                                                                                                          
115     temp->text.data=num;                                                                                                                       
116     temp->next=NULL;                                                                                                                           
117     //循环找到需要插入的位置                                                                                                                   
118     //判断删除位置是否合法                                                                                                                     
119     if(index<1)                                                                                                                                
120     {                                                                                                                                          
121                                                                                                                                                
122         printf("位置非法\n");                                                                                                                  
123         return;                                                                                                                                
124     }                                                                                                                                          
125     for(int i=0;i<index-1;i++)                                                                                                                 
126     {                                                                                                                                          
127         p=p->next;                                                                                                                             
128         if(p==NULL)                                                                                                                            
129         {                                                                                                                                      
130             printf("位置非法\n");                                                                                                              
131             return;                                                                                                                            
132         }                                                                                                                                      
133     }                                                                                                                                          
134     temp->next=p->next;//将原来前一位的结点存的地址赋給temp->next                                                                              
135     p->next=temp;//将temp的地址存入前一个结点的指针域中                                                                                        
136     //头部空间中的len需要做++                                                                                                                  
137     head->text.len++;                                                                                                                          
138     return;                                                                                                                                    
139 }                                                                                                                                              
140 //按位置删除                                                                                                                                   
141 void delete_Pos_linkilst(Linklist *head,int index)                                                                                             
142 {                                                                                                                                              
143     //定义一个指针p将传入的头部赋給p                                                                                                           
144     Linklist *p=head;                                                                                                                          
145     //判断链表是否为空                                                                                                                         
146     if(head->next==NULL)                                                                                                                       
147     {                                                                                                                                          
148         printf("链表为空,无法继续删除");                                                                                                      
149         return;                                                                                                                                
150     }                                                                                                                                          
151     //循环找到需要删除的前一个结点                                                                                                             
152     for(int i =1;i<index;i++)                                                                                                                  
153     {                                                                                                                                          
154         p=p->next;                                                                                                                             
155         if(p->next==NULL)                                                                                                                      
156         {                                                                                                                                      
157             printf("非法位置\n");                                                                                                              
158             return;                                                                                                                            
159         }                                                                                                                                      
160     }                                                                                                                                          
161     //将要删除的结点另存防止内存泄露                                                                                                           
162     Linklist *temp;                                                                                                                            
163     temp=p->next;                                                                                                                              
164     //将需要被删除的结点地址赋值给前一个结点的指针域                                                                                           
165     p->next=temp->next;                                                                                                                        
166     //头部定义的len需要做--                                                                                                                    
167     head->text.len--;                                                                                                                          
168                                                                                                                                                
169                                                                                                                                                
170 }                                                                                                                                              
171 //遍历输出                                                                                                                                     
172 void show_linklist(Linklist *head)                                                                                                             
173 {                                                                                                                                              
174     Linklist *p=head;                                                                                                                          
175     while(p->next!=NULL)                                                                                                                       
176     {                                                                                                                                          
177         p=p->next;                                                                                                                             
178         printf("%d  ",p->text.data);                                                                                                           
179     }                                                                                                                                          
180     putchar(10);                                                                                                                               
181     return;                                                                                                                                    
182 }                                                                                                                                              
  1 #ifndef  __02_lklstFunc__
  2 #define __02_lklstFunc__
  3 
  4 typedef int datatype;
  5 typedef struct lksil
  6 {
  7     union {
  8         int len;
  9         datatype data;
 10     }text;
 11     //数据域
 12     struct lksil * next;  //指针域
 13 }Linklist;
 14 
 15 
 16 //创建一个单链表
 17 Linklist* create_linklist(void);
 18 //头插法
 19 void insert_linklist_head(Linklist *head,datatype num);
 20 //遍历输出
 21 void show_linklist(Linklist *head);
 22 //尾插
 23 void tail_linklist(Linklist *head,datatype num);
 24 //头删
 25 void headshan_linklist(Linklist *head);
 26 //尾删
 27 void tail_shan_linklist(Linklist *head);
 28 //按位置插入
 29 void Pos_insert_linklist(Linklist *head,int index,datatype num);
 30 //按位置删除
 31 void delete_Pos_linkilst(Linklist *head,int index);
 32 
 33 
 34 
 35 
 36 
 37 
 38 
 39 #endif                                                                                                                                                                                                                                                                                                                                                                                                                                                 
  1 #include  <stdio.h>                                                                                 
  2 #include  <stdlib.h>                                                                                
  3 #include  "./02_linklistFunc.h"                                                                     
  4                                                                                                     
  5                                                                                                     
  6 int main(int argc, const char *argv[])                                                              
  7 {                                                                                                   
  8     Linklist *head;                                                                                 
  9     head = create_linklist();//创建一个单链表                                                       
 10     insert_linklist_head(head,100);//头插法                                                         
 11     insert_linklist_head(head,200);//头插法                                                         
 12     insert_linklist_head(head,300);                                                                 
 13     insert_linklist_head(head,400);                                                                 
 14     show_linklist(head);                                                                            
 15     tail_linklist(head,500);                                                                        
 16     show_linklist(head);//遍历输出                                                                  
 17     headshan_linklist(head);                                                                        
 18     show_linklist(head);                                                                            
 19     tail_shan_linklist(head);                                                                       
 20     show_linklist(head);                                                                            
 21     Pos_insert_linklist(head,2,789);                                                                
 22     show_linklist(head);                                                                            
 23     delete_Pos_linkilst(head,4);                                                                    
 24     show_linklist(head);                                                                            
 25     return 0;                                                                                       
 26 }                                                                                                                                                                                                 

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值