[已解决]关于链表多次插入的问题

MeowMoo

这个程序是创建一个保存学生编号和成绩的链表，然后实现在链表里插入一个学生的信息和成绩。单次插入学生信息的函数我写完了，就是那个add（）函数，现在我想用这个函数来实现多次插入信息。我截的这一段程序是输入要插入的学生信息然后调用add函数，完整程序在后面。我的思路是，当addstu这个节点完成插入后，将它释放然后重新赋值，再次插入，但是写的这段代码有问题，问题在哪呢，又该怎么实现多次插入节点？求大佬解答。

1. while(1)
   
2.         {
   
3.                 addstu=(struct student *)malloc(sizeof(struct student));
   
4.                 addstu->num=0;
   
5.                 addstu->score=0;
   
6.                 addstu->next=NULL;
   
7.                 printf("请输入你想加入的学生的编号和成绩(输入0结束添加):");
   
8.                 scanf("%d,%f",&addstu->num,&addstu->score);
   
9.                 printf("\n");
   
10.                 add(stu,addstu);
    
11.                 free(addstu);
    
12.                 if(0==addstu->num)
    
13.                 {
    
14.                         break;
    
15.                 }
    
16.         }

复制代码

完整程序：

1. #include <stdio.h>
   
2. #include <malloc.h>
   
3. 
   
4. 
   
5. struct student
   
6. {
   
7.         int num;
   
8.         float score;
   
9.         struct student *next;
   
10. };
    
11. int n;
    
12. int main(void)
    
13. {
    
14.         struct student *creat();
    
15.         void print(struct student *r);
    
16.         void del(struct student *q,int num1);
    
17.         void add(struct student *a,struct student *a0);
    
18. 
    
19.         int m;
    
20.         struct student *stu;
    
21.         struct student *addstu;
    
22. 
    
23.         stu=creat();
    
24.         printf("\nThere are %d record!\n\n",n);
    
25.         print(stu);
    
26. 
    
27.         printf("请输入你想删除的学生的编号：");
    
28.         scanf("%d",&m);
    
29.         while(m==0)
    
30.         {
    
31.                 printf("不能为0请重新输入：");
    
32.                 scanf("%d",&m);
    
33.         }
    
34.         printf("\n");
    
35.         del(stu,m);
    
36. 
    
37.         while(1)
    
38.         {
    
39.                 addstu=(struct student *)malloc(sizeof(struct student));
    
40.                 addstu->num=0;
    
41.                 addstu->score=0;
    
42.                 addstu->next=NULL;
    
43.                 printf("请输入你想加入的学生的编号和成绩(输入0结束添加):");
    
44.                 scanf("%d,%f",&addstu->num,&addstu->score);
    
45.                 printf("\n");
    
46.                 add(stu,addstu);
    
47.                 free(addstu);
    
48.                 if(0==addstu->num)
    
49.                 {
    
50.                         break;
    
51.                 }
    
52.         }
    
53. 
    
54.         printf("\n\n");
    
55. }
    
56. struct student *creat()
    
57. {
    
58.         struct student *p1,*p2,*head;
    
59.         n=0;
    
60.         head=NULL;
    
61.         p2=(struct student *)malloc(sizeof(struct student));
    
62.         while(1)
    
63.         {
    
64.                 p1=(struct student *)malloc(sizeof(struct student));
    
65.                 printf("Please enter this student number:");
    
66.                 scanf("%d",&p1->num);
    
67.                 printf("Please enter this student score:");
    
68.                 scanf("%f",&p1->score);
    
69.                 if(0==p1->num)
    
70.                 {
    
71.                         break;
    
72.                 }
    
73.                 else
    
74.                 {
    
75.                         n++;
    
76.                         if(1==n)
    
77.                         {
    
78.                                 head=p1;
    
79.                                 p2=p1;
    
80.                         }
    
81.                         else
    
82.                         {
    
83.                                 p2->next=p1;
    
84.                                 p2=p1;
    
85.                         }
    
86.                 }               
    
87. }
    
88.         p2->next=NULL;
    
89. 
    
90.         return head;
    
91. }
    
92. void print(struct student *r)
    
93. {
    
94.        
    
95.         while(r)
    
96.         {
    
97.                 printf("第 %d 位学生的成绩是 %.2f\n",r->num,r->score);
    
98.                 r=r->next;
    
99.         }
    
100.         printf("\n");
     
101. }
     
102. void del(struct student *q,int num1)
     
103. {
     
104.         void print(struct student *r);
     
105. 
     
106.         struct student *q1,*q2,*q3;
     
107.         q1=q3=q;
     
108. 
     
109.         if(q==NULL)
     
110.         {
     
111.                 printf("空表不能操作！");
     
112.         }
     
113.         else
     
114.         {
     
115.                 while(1)
     
116.                 {
     
117.                         int i=0;
     
118.                         while(1)
     
119.                         {
     
120.                                 if(num1==q3->num)
     
121.                                 {
     
122.                                         i=1;
     
123.                                         break;
     
124.                                 }
     
125.                                 if(q3->next==NULL)
     
126.                                 {
     
127.                                         break;
     
128.                                 }
     
129.                                 q3=q3->next;
     
130.                         }
     
131.                         if(0==i)
     
132.                         {
     
133.                                 printf("没有该学生信息！\n请重新输入:");
     
134.                                 scanf("%d",&num1);
     
135.                                 q3=q;
     
136.                         }
     
137.                         if(1==i)
     
138.                                 break;
     
139.                 }
     
140.                 printf("\n");
     
141.                 if(num1==q1->num)
     
142.                 {
     
143.                         q=q->next;
     
144.                 }
     
145.                 else
     
146.                 {
     
147.                         while(1)
     
148.                         {
     
149.                                 if(num1!=q1->num)
     
150.                                 {
     
151.                                         q2=q1;
     
152.                                         q1=q1->next;
     
153.                                 }
     
154.                                 else
     
155.                                 {
     
156.                                         q2->next=q1->next;
     
157.                                         free(q1);
     
158.                                         break;
     
159.                                 }
     
160.                         }
     
161.                 }
     
162.                 printf("\nThere are %d record!\n\n",n-1);
     
163.                 print(q);
     
164.                 printf("%d号学生成绩已删除\n\n",num1);
     
165.         }
     
166. 
     
167. }
     
168. void add(struct student *a,struct student *a0)
     
169. {
     
170.         struct student *a1,*a2,*a3;
     
171.         a1=a;
     
172. 
     
173.         if(a0->num<a->num)//第一种情况，插入节点编号在首节点前
     
174.         {
     
175.                 a0->next=a;
     
176.                 a=a0;
     
177.         }
     
178.         else
     
179.         {
     
180.                 while(1)
     
181.                 {
     
182.                         if(a1->next==NULL)
     
183.                         {
     
184.                                 a3=a1;
     
185.                                 break;
     
186.                         }
     
187.                         a1=a1->next;
     
188.                 }
     
189. 
     
190.                 a1=a;
     
191.                 if(a0->num>a3->num)
     
192.                 {
     
193.                         a3->next=a0;
     
194.                         a0->next=NULL;
     
195.                 }
     
196.                 else
     
197.                 {
     
198.                         while(1)
     
199.                         {
     
200.                                 if(a0->num<a1->num)
     
201.                                 {
     
202.                                         a2->next=a0;
     
203.                                         a0->next=a1;
     
204.                                         break;
     
205.                                 }
     
206.                                 a2=a1;
     
207.                                 a1=a1->next;
     
208. 
     
209.                         }
     
210.                 }
     
211.         }
     
212.         printf("\nThere are %d record!\n\n",n);
     
213.         print(a);//函数嵌套使用
     
214.         printf("%d号学生成绩添加成功\n\n",a0->num);
     
215. }

复制代码

最佳答案

月排行榜 / 总排行榜

xieglt

2021-1-22 15:57:42

代码太长，没细看。至少有两个主要问题。

1、被链接到链表的节点为什么要 free ? 内存分配后，只要还要使用，就不能 free，free后就不能再去访问。

2、add()这个函数里没有判断表头是否为空，都表头为空时，访问出错。

还有就是 malloc 分配的内存在程序结束前没有 free。
create 函数里，输入学号0 的时候，不生成表头，但是分配的内存又没有释放。

跳转到最佳答案楼层

xieglt

代码太长，没细看。至少有两个主要问题。

1、被链接到链表的节点为什么要 free ? 内存分配后，只要还要使用，就不能 free，free后就不能再去访问。

2、add()这个函数里没有判断表头是否为空，都表头为空时，访问出错。

还有就是 malloc 分配的内存在程序结束前没有 free。
create 函数里，输入学号0 的时候，不生成表头，但是分配的内存又没有释放。

MeowMoo

xieglt 发表于 2021-1-22 15:57
代码太长，没细看。至少有两个主要问题。

1、被链接到链表的节点为什么要 free ? 内存分配后，只要还要 ...

哦，去掉free就可以多次了，free函数没仔细去研究，我以为free完后只要重新分配内存就可以用。
add没判断是因为我懒得去写了，然后前面直接声明不让输入0，但是后来前面的声明又改了
还有我想问一下，你说free后不能用了只是当前函数不能用了吗？
还有你说程序结束前free，是在主程序的末尾free吗？如果不free会怎么样?
求大哥解答！

xieglt

MeowMoo 发表于 2021-1-22 16:13
哦，去掉free就可以多次了，free函数没仔细去研究，我以为free完后只要重新分配内存就可以用。
add没判 ...

分配的内存不释放会造成内存泄露。
如果你的程序一直在分配内存而不释放，会造成系统可用内存越来越少，最后只能重启电脑了。

当你确定你分配的内存不再使用时就可以free。当你无法确认你分配的内存用不用，就在 main 函数尾部free

MeowMoo

xieglt 发表于 2021-1-22 16:32
分配的内存不释放会造成内存泄露。
如果你的程序一直在分配内存而不释放，会造成系统可用内存越来越少， ...

我刚刚试了在子函数释放内存很容易出错，但是我有个疑问，形参在使用完成后不是系统会自动释放内存吗，意思子函数内部是不是不必使用free函数，只需要在main函数执行free操作就行了？

xieglt

MeowMoo 发表于 2021-1-22 16:45
我刚刚试了在子函数释放内存很容易出错，但是我有个疑问，形参在使用完成后不是系统会自动释放内存吗，意 ...

好难解释。
子函数内部分配的内存，如果能把内存指针传出来，在main里面free就可以。
比如说链表节点，这个节点在后面还要使用的，你malloc出来立刻又free掉
跟没有malloc有什么区别？如果不能传递出来，就在子函数内部free.

MeowMoo

xieglt 发表于 2021-1-22 16:53
好难解释。
子函数内部分配的内存，如果能把内存指针传出来，在main里面free就可以。
比如说链表节点， ...

哈哈哈好吧，我再研究一下，谢谢你

MeowMoo

xieglt 发表于 2021-1-22 16:53
好难解释。
子函数内部分配的内存，如果能把内存指针传出来，在main里面free就可以。
比如说链表节点， ...

哥我再请教一下关于free函数的问题，是不是可以这样理解，只有直接使用malloc函数分配内存的变量才需要去free，而在其他函数调用这些变量的形参是不用去free的，除非在函数内又使用了malloc。比如我在main函数用malloc给p1分配了内存，然后在子函数的形参q1调用了p1，那q1是不用free的？

xieglt

MeowMoo 发表于 2021-1-25 11:03
哥我再请教一下关于free函数的问题，是不是可以这样理解，只有直接使用malloc函数分配内存的变量才需要去 ...

没错。凡是用malloc , calloc , realloc 分配的内存都需要用free 去释放。
通常遵循谁分配，谁释放的原则。需要传递到函数外面的指针例外。
所以通常尽量少用（不用）在函数里分配内存，传递到函数外面，因为有可能会忘记free。

1、主函数里分配，主函数里释放

1. 
   
2. void fun1 (char * buffer)
   
3. {
   
4.      strcpy(buffer,"Hello,world");
   
5. }
   
6. 
   
7. int main()
   
8. {
   
9.     char * str = (char *)malloc(100);
   
10.     fun1(str);
    
11.     printf("%s",str);
    
12.     free(str);
    
13.     return 0;
    
14. }
    

复制代码

2、子函数里分配，子函数里释放

1. 
   
2. void  fun2()
   
3. {
   
4.       char * temp = (char *)malloc(100);
   
5.       strcpy(temp,"hello,world");
   
6.       printf("%s\n",temp);
   
7.       free(temp);
   
8. }
   
9. 
   
10. int main()
    
11. {
    
12.       fun2();
    
13. }
    

复制代码

3、子函数里分配，main里释放
(这是非常差的编程习惯，尤其是当你的函数编译成库提供给别人用的时候，别人无法把握这个指针需不需要释放)

1. 
   
2. char * fun3()
   
3. {
   
4.         char * buffer = (char *)malloc(100);
   
5.         strcpy(buffer,"hello,world");
   
6.         return buffer;
   
7. }
   
8. 
   
9. int main()
   
10. {
    
11.        char * str = fun3();
    
12.        printf("%s\n",str);
    
13.        free(str);
    
14.        return 0;
    
15. }
    

复制代码

xieglt

MeowMoo 发表于 2021-1-25 11:03
哥我再请教一下关于free函数的问题，是不是可以这样理解，只有直接使用malloc函数分配内存的变量才需要去 ...

操作系统对内存管理通常是这样的。
用户程序提出内存分配申请 ----> 操作系统在内存中寻找一块符合用户申请大小的内存，如找到，将
这块内存标记为已使用，并将内存地址返回给用户，如找不到，则返回null ---> 用户使用完内存，free
内存 ----> 操作系统接到free请求,将该块内存标记为未使用。

如果你只分配内存，却不释放。那么系统里的内存渐渐地都被标记为已使用，最后导致无内存可用。

MeowMoo

xieglt 发表于 2021-1-25 11:49
操作系统对内存管理通常是这样的。
用户程序提出内存分配申请 ----> 操作系统在内存中寻找一块符合用户 ...

好的，明白了，非常感谢！