[已解决]发了两次贴还是没搞懂为什么释放内存会错。。。拜托求解！

a905448839

首先申明此代码不释放内存已经验证通过测试题检测

题目：

设计函数分别求两个一元多项式的乘积与和。
输入格式:

输入分2行，每行分别先给出多项式非零项的个数，再以指数递降方式输入一个多项式非零项系数和指数（绝对值均为不超过1000的整数）。数字间以空格分隔。
输出格式:

输出分2行，分别以指数递降方式输出乘积多项式以及和多项式非零项的系数和指数。数字间以空格分隔，但结尾不能有多余空格。零多项式应输出0 0。
输入样例:

4 3 4 -5 2  6 1  -2 0
3 5 20  -7 4  3 1

输出样例:

15 24 -25 22 30 21 -10 20 -21 8 35 6 -33 5 14 4 -15 3 18 2 -6 1
5 20 -4 4 -5 2 9 1 -2 0

我的代码：

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. 
   
4. typedef struct Node *node;
   
5. struct Node
   
6. {
   
7.     int x;
   
8.     int z;
   
9.     node next;
   
10. };
    
11. 
    
12. node read();
    
13. void print(node list);
    
14. node he(node list1,node list2);
    
15. node ji(node list1,node list2);
    
16. void freeList(node head);
    
17. 
    
18. node read()
    
19. {
    
20.         int i;
    
21.         scanf("%d",&i);
    
22.         node head = (node)malloc(sizeof(node));
    
23.         head->next = NULL;
    
24.         node p = head;
    
25.         
    
26.         while(i--)
    
27.         {
    
28.                 node temp = (node)malloc(sizeof(node));
    
29.                 scanf("%d %d",&temp->x,&temp->z);
    
30.                 p->next = temp;
    
31.                 p = p->next;
    
32.         }
    
33.         p->next = NULL;
    
34.         
    
35.         return head;
    
36. }
    
37. 
    
38. node he(node list1,node list2)
    
39. {
    
40.         node temp;
    
41.         node head = (node)malloc(sizeof(struct Node));
    
42.         head->next = NULL;
    
43.         node p = head;
    
44.         
    
45.         if(list2->next == NULL)
    
46.         {
    
47.         
    
48.                 return list1;
    
49. 
    
50.                 }
    
51.         else
    
52.         {
    
53.                 list1 = list1->next;
    
54.                 list2 = list2->next;
    
55. 
    
56.                 while(list1 && list2)
    
57.                 {
    
58.                         
    
59.                         temp = (node)malloc(sizeof(struct Node));
    
60.                         if(list1->z == list2->z)
    
61.                         {        
    
62.                                 temp->x = list1->x + list2->x;
    
63.                                 temp->z = list1->z;
    
64.                                 list1 = list1->next;
    
65.                                 list2 = list2->next;
    
66.                         }
    
67.                         else if(list1->z > list2->z)
    
68.                         {
    
69.                                 temp->x = list1->x;
    
70.                                 temp->z = list1->z;
    
71.                                 list1 = list1->next;
    
72.                         }
    
73.                         else
    
74.                         {
    
75.                                 temp->x = list2->x;
    
76.                                 temp->z = list2->z;
    
77.                                 list2 = list2->next;
    
78.                         }
    
79.                         p->next = temp;
    
80.                         p = p->next;                        
    
81.                 }
    
82.                 for(;list1;list1 = list1->next)temp = (node)malloc(sizeof(struct Node)),temp->x = list1->x,temp->z = list1->z,p->next = temp,p = p->next;
    
83.                 for(;list2;list2 = list2->next)temp = (node)malloc(sizeof(struct Node)),temp->x = list2->x,temp->z = list2->z,p->next = temp,p = p->next;
    
84.                 p->next = NULL;
    
85.                
    
86.               
    
87.         return head;
    
88.         }
    
89. }
    
90. 
    
91. node ji(node list1,node list2)
    
92. {
    
93.         
    
94.         node t,L = (node)malloc(sizeof(struct Node));
    
95.         L->next = NULL;
    
96.         list1 = list1->next;
    
97.         list2 = list2->next;
    
98.                
    
99.         for(list1;list1;list1=list1->next)
    
100.         {
     
101.                 node temp;
     
102.                 node head = (node)malloc(sizeof(struct Node));
     
103.                 head->next = NULL;
     
104.                 node p = head;
     
105.                 for(t = list2;t;t=t->next)
     
106.                 {
     
107.                         temp = (node)malloc(sizeof(struct Node));
     
108.                         temp->x = list1->x * t->x;
     
109.                         temp->z = list1->z + t->z;
     
110. 
     
111.                         p->next = temp;
     
112.                         p = p->next;
     
113.                 }
     
114.                 p->next = NULL;
     
115.               
     
116.                 printf("合并前head：");
     
117.                 print(head);
     
118.                 printf("合并前L：");
     
119.                 print(L);
     
120.                 L = he(head,L);
     
121.                 printf("合并后head：");
     
122.                 print(head);
     
123.                 printf("合并后L：");
     
124.                 print(L);
     
125. 
     
126. 
     
127.                 freeList(head);
     
128. 
     
129. 
     
130. 
     
131.         }
     
132.         //L->next = NULL;
     
133.         return L;
     
134.                
     
135. }
     
136. 
     
137. void freeList(node head)
     
138. {
     
139.     node temp;
     
140.     while (head != NULL)
     
141.         {
     
142.         temp = head;
     
143.         head = head->next;
     
144.         free(temp);
     
145.     }
     
146. }
     
147. 
     
148. void print(node list)
     
149. {
     
150. //        node t = list;
     
151.         int flag = 1;
     
152.         if(list->next)
     
153.         list = list->next;
     
154.         else
     
155.         {
     
156.                 printf("0 0\n");
     
157.                 return;
     
158.          }
     
159.         for(;list;list = list->next)
     
160.         {
     
161.                 if(!flag && list->x)   //控制空格输出
     
162.                         printf(" ");
     
163.                 if(list->x){   // 如果系数为 0，不输出
     
164.                         printf("%d %d",list->x,list->z);
     
165.                         flag =0;               
     
166.                 }
     
167.         }
     
168.         if(flag)
     
169.                 printf("0 0");
     
170.         printf("\n");
     
171. }
     
172. 
     
173. 
     
174. 
     
175. int main()
     
176. {
     
177.     node list1,list2;
     
178.     list1 = read();
     
179.     list2 = read();
     
180. 
     
181. //   print(list1);
     
182. //   print(list2);
     
183.         print(ji(list1,list2));
     
184.        // print(he(list1,list2));
     
185.         
     
186.         freeList(list1);
     
187.         freeList(list2);
     
188. 
     
189.   return 0;
     
190. }

复制代码

问题我在求两个一元多项式乘积的函数  node ji(node list1,node list2);
里释放掉一个临时生成的单链表（因为一元多项式乘积是依次各项相乘再相加 从而我遍历了两个一元多项式相乘另一个多项式 前一个每一项的多项式乘以后一个多项式每一项生成一个分配了空间的临时链表头节点为head  然后传入求和函数node he(node list1,node list2);
合并掉相同的指数项 得到一个新的合并后并分配了内存空间的链表头节点为L 这个新链表是在求和函数node he(node list1,node list2);中新生成的链表  我理解应该来说是和求积函数node ji(node list1,node list2);
的head链表是相互独立的存在  所以free掉这个临时的单链表  然后进入到第一个一元多项式下一个项依次乘以另一个多项式的项生成新的链表头节点为head  但是我free掉head这个链表之后  L链表就受到影响 L链表是求和里面return出来的 请问大佬是什么原因了！ 拜托求解！）

这是在求积函数中测试段代码和释放内存函数

1. printf("合并前head：");
   
2.                 print(head);
   
3.                 printf("合并前L：");
   
4.                 print(L);
   
5.                 L = he(head,L);
   
6.                 printf("合并后head：");
   
7.                 print(head);
   
8.                 printf("合并后L：");
   
9.                 print(L);
   
10. 
    
11. 
    
12.                 freeList(head);

复制代码

最佳答案

月排行榜 / 总排行榜

isdkz

2023-6-26 22:17:32

您的问题在于，您试图释放在  he()  函数内部创建并返回的链表（通过  L = he(head,L);  语句），然后立即释放该链表的原始版本（ head ）。在  he()  函数中，您并没有创建新的节点，而是重新使用了  head  和  L  中的节点。这就意味着  L  和  head  实际上是共享一些节点的，这就解释了为什么当你释放  head  时， L  也受到影响。

所以，当您在  ji()  函数中执行  freeList(head);  时，其实就是释放了  L  中的一部分或全部节点。这样做是不正确的，因为这些节点仍在  L  中使用。在释放  head  后， L  中的这些节点已经被释放，所以再次访问它们（例如，通过  print(L) ）就会出现错误。

解决这个问题的一种方法是，在  he()  函数中创建新的节点，而不是重用  head  和  L  中的节点。这样，您可以安全地在  ji()  函数中释放  head ，因为它不再与  L  共享任何节点。

以下是一种可能的解决方案，将您的  he()  函数修改为：

1. node he(node list1,node list2)
   
2. {
   
3.     node head = (node)malloc(sizeof(struct Node));
   
4.     head->next = NULL;
   
5.     node p = head;
   
6. 
   
7.     list1 = list1->next;
   
8.     list2 = list2->next;
   
9. 
   
10.     while(list1 && list2)
    
11.     {
    
12.         node temp = (node)malloc(sizeof(struct Node));
    
13.         if(list1->z == list2->z)
    
14.         {        
    
15.             temp->x = list1->x + list2->x;
    
16.             temp->z = list1->z;
    
17.             list1 = list1->next;
    
18.             list2 = list2->next;
    
19.         }
    
20.         else if(list1->z > list2->z)
    
21.         {
    
22.             temp->x = list1->x;
    
23.             temp->z = list1->z;
    
24.             list1 = list1->next;
    
25.         }
    
26.         else
    
27.         {
    
28.             temp->x = list2->x;
    
29.             temp->z = list2->z;
    
30.             list2 = list2->next;
    
31.         }
    
32.         p->next = temp;
    
33.         p = p->next;                        
    
34.     }
    
35. 
    
36.     while(list1) {
    
37.         node temp = (node)malloc(sizeof(struct Node));
    
38.         temp->x = list1->x;
    
39.         temp->z = list1->z;
    
40.         p->next = temp;
    
41.         p = p->next;
    
42.         list1 = list1->next;
    
43.     }
    
44. 
    
45.     while(list2) {
    
46.         node temp = (node)malloc(sizeof(struct Node));
    
47.         temp->x = list2->x;
    
48.         temp->z = list2->z;
    
49.         p->next = temp;
    
50.         p = p->next;
    
51.         list2 = list2->next;
    
52.     }
    
53. 
    
54.     p->next = NULL;
    
55. 
    
56.     return head;
    
57. }
    

复制代码

我这里对您原有的代码进行了一些修改，使其在合并链表时，始终生成新的节点，而不是复用原有的节点。这样就解决了原有的问题。希望这个解答对您有所帮助！

跳转到最佳答案楼层

sfqxx

问题出在这段代码中：

1. printf("合并前head：");
   
2. print(head);
   
3. printf("合并前L：");
   
4. print(L);
   
5. L = he(head,L);
   
6. printf("合并后head：");
   
7. print(head);
   
8. printf("合并后L：");
   
9. print(L);
   
10. 
    
11. freeList(head);

复制代码

在执行L = he(head, L);之后，L的值被修改为了合并后的链表，而head仍然指向原来的链表。所以当执行freeList(head);时，实际上是释放了合并前的临时链表，但是L仍然指向这个已经被释放的内存空间。

解决这个问题的方法是，在释放完合并前的链表之后，将head赋值为NULL，避免对已经释放的内存进行操作。修改的代码如下：

1. printf("合并前head：");
   
2. print(head);
   
3. printf("合并前L：");
   
4. print(L);
   
5. L = he(head, L);
   
6. printf("合并后head：");
   
7. print(head);
   
8. printf("合并后L：");
   
9. print(L);
   
10. 
    
11. freeList(head);
    
12. head = NULL;

复制代码

这样就可以确保在释放内存之后不再使用已经释放的指针了。

isdkz

您的问题在于，您试图释放在  he()  函数内部创建并返回的链表（通过  L = he(head,L);  语句），然后立即释放该链表的原始版本（ head ）。在  he()  函数中，您并没有创建新的节点，而是重新使用了  head  和  L  中的节点。这就意味着  L  和  head  实际上是共享一些节点的，这就解释了为什么当你释放  head  时， L  也受到影响。

所以，当您在  ji()  函数中执行  freeList(head);  时，其实就是释放了  L  中的一部分或全部节点。这样做是不正确的，因为这些节点仍在  L  中使用。在释放  head  后， L  中的这些节点已经被释放，所以再次访问它们（例如，通过  print(L) ）就会出现错误。

解决这个问题的一种方法是，在  he()  函数中创建新的节点，而不是重用  head  和  L  中的节点。这样，您可以安全地在  ji()  函数中释放  head ，因为它不再与  L  共享任何节点。

以下是一种可能的解决方案，将您的  he()  函数修改为：

1. node he(node list1,node list2)
   
2. {
   
3.     node head = (node)malloc(sizeof(struct Node));
   
4.     head->next = NULL;
   
5.     node p = head;
   
6. 
   
7.     list1 = list1->next;
   
8.     list2 = list2->next;
   
9. 
   
10.     while(list1 && list2)
    
11.     {
    
12.         node temp = (node)malloc(sizeof(struct Node));
    
13.         if(list1->z == list2->z)
    
14.         {        
    
15.             temp->x = list1->x + list2->x;
    
16.             temp->z = list1->z;
    
17.             list1 = list1->next;
    
18.             list2 = list2->next;
    
19.         }
    
20.         else if(list1->z > list2->z)
    
21.         {
    
22.             temp->x = list1->x;
    
23.             temp->z = list1->z;
    
24.             list1 = list1->next;
    
25.         }
    
26.         else
    
27.         {
    
28.             temp->x = list2->x;
    
29.             temp->z = list2->z;
    
30.             list2 = list2->next;
    
31.         }
    
32.         p->next = temp;
    
33.         p = p->next;                        
    
34.     }
    
35. 
    
36.     while(list1) {
    
37.         node temp = (node)malloc(sizeof(struct Node));
    
38.         temp->x = list1->x;
    
39.         temp->z = list1->z;
    
40.         p->next = temp;
    
41.         p = p->next;
    
42.         list1 = list1->next;
    
43.     }
    
44. 
    
45.     while(list2) {
    
46.         node temp = (node)malloc(sizeof(struct Node));
    
47.         temp->x = list2->x;
    
48.         temp->z = list2->z;
    
49.         p->next = temp;
    
50.         p = p->next;
    
51.         list2 = list2->next;
    
52.     }
    
53. 
    
54.     p->next = NULL;
    
55. 
    
56.     return head;
    
57. }
    

复制代码

我这里对您原有的代码进行了一些修改，使其在合并链表时，始终生成新的节点，而不是复用原有的节点。这样就解决了原有的问题。希望这个解答对您有所帮助！

a905448839

isdkz 发表于 2023-6-26 22:17
您的问题在于，您试图释放在  he()  函数内部创建并返回的链表（通过  L = he(head,L);  语句），然后立即 ...

感谢！

歌者文明清理员

sfqxx 发表于 2023-6-26 22:12
问题出在这段代码中：

555你能不能罢工一天

sfqxx

歌者文明清理员 发表于 2023-6-27 08:13
555你能不能罢工一天

不可以

歌者文明清理员

sfqxx 发表于 2023-6-27 09:12
不可以

哎（叹息）

a905448839

还有个问题能回答我一下吗？为什么你给出的代码 temp结构体指针要在每次循环里定义分配内存空间。 而我是在he函数一开始就声明一个temp结构体指针，再在每个循环里定义malloc分配内存空间。这两种做法有什么区别吗？