C语言实现一元多项式的乘法与加法运算（求告知错误原因）

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 lsit);
    
14. node he(node list1,node list2);
    
15. node ji(node list1,node list2);
    
16. 
    
17. node read()
    
18. {
    
19.         int i;
    
20.         scanf("%d",&i);
    
21.         node head = (node)malloc(sizeof(node));
    
22.         head->next = NULL;
    
23.         node p = head;
    
24.        
    
25.         while(i--)
    
26.         {
    
27.                 node temp = (node)malloc(sizeof(node));
    
28.                 scanf("%d %d",&temp->x,&temp->z);
    
29.                 p->next = temp;
    
30.                 p = p->next;
    
31.         }
    
32.         p->next = NULL;
    
33.        
    
34.         return head;
    
35. }
    
36. 
    
37. node he(node list1,node list2)
    
38. {
    
39.         node temp;
    
40.         node head = (node)malloc(sizeof(node));
    
41.         head->next = NULL;
    
42.         node p = head;
    
43.        
    
44.         if(list2->next == NULL)
    
45.                 return list1;
    
46.         else
    
47.         {
    
48.                 list1 = list1->next;
    
49.                 list2 = list2->next;
    
50. 
    
51.                 while(list1 && list2)
    
52.                 {
    
53.                        
    
54.                         temp = (node)malloc(sizeof(node));
    
55.                         if(list1->z == list2->z)
    
56.                         {       
    
57.                                 temp->x = list1->x + list2->x;
    
58.                                 temp->z = list1->z;
    
59.                                 list1 = list1->next;
    
60.                                 list2 = list2->next;
    
61.                         }
    
62.                         else if(list1->z > list2->z)
    
63.                         {
    
64.                                 temp->x = list1->x;
    
65.                                 temp->z = list1->z;
    
66.                                 list1 = list1->next;
    
67.                         }
    
68.                         else
    
69.                         {
    
70.                                 temp->x = list2->x;
    
71.                                 temp->z = list2->z;
    
72.                                 list2 = list2->next;
    
73.                         }
    
74.                         p->next = temp;
    
75.                         p = p->next;                       
    
76.                 }
    
77.                 for(;list1;list1 = list1->next)temp = (node)malloc(sizeof(node)),temp->x = list1->x,temp->z = list1->z,p->next = temp,p = p->next;
    
78.                 for(;list2;list2 = list2->next)temp = (node)malloc(sizeof(node)),temp->x = list2->x,temp->z = list2->z,p->next = temp,p = p->next;
    
79.                 p->next = NULL;
    
80.         return head;
    
81.         }
    
82. }
    
83. 
    
84. node ji(node list1,node list2)
    
85. {
    
86.        
    
87.         node t;
    
88.         node OK = (node)malloc(sizeof(node));
    
89.         OK->next = NULL;
    
90.         node L = OK;
    
91. 
    
92.         list1 = list1->next;
    
93.         list2 = list2->next;
    
94.                
    
95.         for(list1;list1;list1=list1->next)
    
96.         {
    
97.                 node temp;
    
98.                 node head = (node)malloc(sizeof(node));
    
99.                 head->next = NULL;
    
100.                 node p = head;
     
101.                 for(t = list2;t;t=t->next)
     
102.                 {
     
103.                         temp = (node)malloc(sizeof(node));
     
104.                         temp->x = list1->x * t->x;
     
105.                         temp->z = list1->z + t->z;
     
106. 
     
107.                         p->next = temp;
     
108.                         p = p->next;
     
109.                 }
     
110.                 p->next = NULL;
     
111.                 L = he(head,L);
     
112.         }
     
113.         L->next = NULL;
     
114.         return OK;
     
115.                
     
116. }
     
117. 
     
118. 
     
119. 
     
120. void print(node list)
     
121. {
     
122.         if(list->next)
     
123.         {
     
124.                 list = list->next;
     
125.                 while(list)
     
126.                 {
     
127.                         printf("%d %d",list->x,list->z);
     
128.                         list = list->next;
     
129.                         if(list)
     
130.                         printf(" ");
     
131. 
     
132.                 }
     
133.         }
     
134.         else
     
135.         printf("0 ");
     
136. }
     
137. 
     
138. 
     
139. 
     
140. int main()
     
141. {
     
142.     node list1,list2;
     
143.     list1 = read();
     
144.     list2 = read();
     
145. 
     
146. //   print(list1);
     
147. //   print(list2);
     
148.         print(he(list1,list2));
     
149.         print(ji(list1,list2));
     
150.   return 0;
     
151. }

复制代码

isdkz

您的代码存在一些错误。首先，您在申请新的节点时大小应该为  sizeof(struct Node)  而不是  sizeof(node) 。其次，您在乘法函数  ji  中初始化  L  节点的时候， OK  节点的  next  未置为  NULL ，这会导致在乘法结果累加时出错。

以下是修改后的代码：

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. 
    
17. node read()
    
18. {
    
19.     int i;
    
20.     scanf("%d",&i);
    
21.     node head = (node)malloc(sizeof(struct Node));
    
22.     head->next = NULL;
    
23.     node p = head;
    
24.    
    
25.     while(i--)
    
26.     {
    
27.         node temp = (node)malloc(sizeof(struct Node));
    
28.         scanf("%d %d",&temp->x,&temp->z);
    
29.         temp->next = NULL;
    
30.         p->next = temp;
    
31.         p = p->next;
    
32.     }
    
33.    
    
34.     return head;
    
35. }
    
36. 
    
37. node he(node list1,node list2)
    
38. {
    
39.     node temp;
    
40.     node head = (node)malloc(sizeof(struct Node));
    
41.     head->next = NULL;
    
42.     node p = head;
    
43.    
    
44.     if(list2->next == NULL)
    
45.         return list1;
    
46.     else
    
47.     {
    
48.         list1 = list1->next;
    
49.         list2 = list2->next;
    
50.         while(list1 && list2)
    
51.         {
    
52.             temp = (node)malloc(sizeof(struct Node));
    
53.             if(list1->z == list2->z)
    
54.             {      
    
55.                 temp->x = list1->x + list2->x;
    
56.                 temp->z = list1->z;
    
57.                 list1 = list1->next;
    
58.                 list2 = list2->next;
    
59.             }
    
60.             else if(list1->z > list2->z)
    
61.             {
    
62.                 temp->x = list1->x;
    
63.                 temp->z = list1->z;
    
64.                 list1 = list1->next;
    
65.             }
    
66.             else
    
67.             {
    
68.                 temp->x = list2->x;
    
69.                 temp->z = list2->z;
    
70.                 list2 = list2->next;
    
71.             }
    
72.             temp->next = NULL;
    
73.             p->next = temp;
    
74.             p = p->next;                       
    
75.         }
    
76.         while(list1)
    
77.         {
    
78.             temp = (node)malloc(sizeof(struct Node));
    
79.             temp->x = list1->x;
    
80.             temp->z = list1->z;
    
81.             temp->next = NULL;
    
82.             p->next = temp;
    
83.             p = p->next;
    
84.             list1 = list1->next;
    
85.         }
    
86.         while(list2)
    
87.         {
    
88.             temp = (node)malloc(sizeof(struct Node));
    
89.             temp->x = list2->x;
    
90.             temp->z = list2->z;
    
91.             temp->next = NULL;
    
92.             p->next = temp;
    
93.             p = p->next;
    
94.             list2 = list2->next;
    
95.         }
    
96.         p->next = NULL;
    
97.         return head;
    
98.     }
    
99. }
    
100. 
     
101. node ji(node list1,node list2)
     
102. {
     
103.     node t;
     
104.     node OK = (node)malloc(sizeof(struct Node));
     
105.     OK->next = NULL;
     
106.     node L = OK;
     
107.     list1 = list1->next;
     
108.     list2 = list2->next;
     
109.            
     
110.     for(; list1; list1=list1->next)
     
111.     {
     
112.         node temp;
     
113.         node head = (node)malloc(sizeof(struct Node));
     
114.         head->next = NULL;
     
115.         node p = head;
     
116.         for(t = list2; t; t=t->next)
     
117.         {
     
118.             temp = (node)malloc(sizeof(struct Node));
     
119.             temp->x = list1->x * t->x;
     
120.             temp->z = list1->z + t->z;
     
121.             temp->next = NULL;
     
122.             p->next = temp;
     
123.             p = p->next;
     
124.         }
     
125.         L = he(head, L);
     
126.     }
     
127.     return L;
     
128. }
     
129. 
     
130. void print(node list)
     
131. {
     
132.     if(list->next)
     
133.     {
     
134.         list = list->next;
     
135.         while(list)
     
136.         {
     
137.             printf("%d %d",list->x,list->z);
     
138.             list = list->next;
     
139.             if(list)
     
140.                 printf(" ");
     
141.         }
     
142.     }
     
143.     else
     
144.         printf("0 0");
     
145. }
     
146. 
     
147. int main()
     
148. {
     
149.     node list1,list2;
     
150.     list1 = read();
     
151.     list2 = read();
     
152.     print(ji(list1,list2));
     
153.     printf("\n");
     
154.     print(he(list1,list2));
     
155.     return 0;
     
156. }
     

复制代码

注意：
· 你需要在新的  node  分配后立即将  next  指针设置为  NULL 。这样可以防止你在后续代码中意外地访问到未初始化的内存。
· 你需要先打印乘法的结果，再打印加法的结果，以符合题目的输出顺序。
· 空的多项式应输出  0 0 ，而非  0 。

a905448839

isdkz 发表于 2023-6-25 23:29
您的代码存在一些错误。首先，您在申请新的节点时大小应该为  sizeof(struct Node)  而不是  sizeof(node)  ...

如要释放内存需要在何时释放呢？

isdkz

a905448839 发表于 2023-6-26 09:37
如要释放内存需要在何时释放呢？

在C语言中，你需要在不再需要动态分配的内存时释放它，以防止内存泄露。在你的程序中，可能在  main  函数的末尾释放所有动态分配的内存。

你可以通过迭代链表，并对每个节点使用  free  函数来释放内存。然而，你需要注意，一旦一个节点被释放，你就不能再访问它的  next  指针。所以，你需要在释放节点前先保存下一个节点的指针。

下面是一个释放链表内存的函数示例：

1. void freeList(node head) {
   
2.     node temp;
   
3.     while (head != NULL) {
   
4.         temp = head;
   
5.         head = head->next;
   
6.         free(temp);
   
7.     }
   
8. }
   

复制代码

然后在你的  main  函数中调用该函数：

1. int main() {
   
2.     node list1,list2;
   
3.     list1 = read();
   
4.     list2 = read();
   
5.     print(ji(list1,list2));
   
6.     printf("\n");
   
7.     print(he(list1,list2));
   
8. 
   
9.     // 释放链表内存
   
10.     freeList(list1);
    
11.     freeList(list2);
    
12. 
    
13.     return 0;
    
14. }
    

复制代码

这样可以确保你的程序不会引起内存泄露。但请注意，如果你的程序在其他地方仍然保存有这些节点的指针，并试图在后续的代码中使用它们，那么就会导致未定义的行为。因此，你需要确保在释放内存后不再使用这些指针。

a905448839

isdkz 发表于 2023-6-26 09:39
在C语言中，你需要在不再需要动态分配的内存时释放它，以防止内存泄露。在你的程序中，可能在  main  函 ...

我在ji函数里面分配的内存空间，创建的链表传入了he函数。而he函数又是新创建的链表，也分配了内存空间。，所以在最后只用free释放掉list1和list2吗？ji函数和he函数里分配的内存空间，创建的链表不用去管他吗？