多项式计算【C】

yinda_peng

  数据结构课的作业，昨晚写完的，说是小组作业实则基本上就是我自己一个人写……其他人根本就不会啥

1. #include <stdio.h>
   
2. #include <math.h>
   
3. #include <stdlib.h>
   
4. 
   
5. typedef struct Node{
   
6.     float coef;   // 系数
   
7.     int exp;      // 指数
   
8.     struct Node *next;
   
9. }Node, *Polynomial;
   
10. 
    
11. // 创建新节点
    
12. Node* createNode(float coef, int exp){
    
13.     Node *node = (Node*)malloc(sizeof(Node));
    
14.     node->coef = coef;
    
15.     node->exp = exp;
    
16.     node->next = NULL;
    
17.     return node;
    
18. }
    
19. 
    
20. // 创建多项式
    
21. void createPolynomial(Polynomial *p){
    
22.     int n;
    
23.     float coef;
    
24.     int exp;
    
25. 
    
26.     printf("请输入待插入多项式的项数：");
    
27.     scanf("%d", &n);
    
28. 
    
29.     for(int i=0; i<n; i++){
    
30.         printf("请插入新第%d项的系数和指数：(按降幂输入)", i+1);
    
31.         scanf("%f %d", &coef, &exp);
    
32.         if(coef != 0){
    
33.             Node *node = createNode(coef, exp);
    
34.             if(*p == NULL){
    
35.                 *p = node;
    
36.             }else{
    
37.                 Node *last = *p;
    
38.                 while(last->next != NULL){
    
39.                     last = last->next;
    
40.                 }
    
41.                 last->next = node;
    
42.             }
    
43.         }
    
44.         else
    
45.         {
    
46.                 printf("系数不应为0！\n");
    
47.                 }
    
48.     }
    
49. }
    
50. 
    
51. // 输出多项式
    
52. void printPolynomial(Polynomial p){
    
53.     if(p == NULL){
    
54.         printf("0\n");
    
55.     }else{
    
56.         while(p != NULL){
    
57.             printf("%.2f", p->coef);
    
58.             if(p->exp != 0){
    
59.                 printf("x^%d", p->exp);
    
60.             }
    
61.             if(p->next != NULL && p->next->coef > 0){
    
62.                 printf("+");
    
63.             }
    
64.             p = p->next;
    
65.         }
    
66.         printf("\n");
    
67.     }
    
68. }
    
69. 
    
70. //多项式赋值
    
71. void assignPolynomial(Polynomial *a, Polynomial b){
    
72.     Node *p = NULL;
    
73.     Node *q = b;
    
74.     //int k;
    
75. 
    
76.     // 如果b为空链表，直接返回
    
77.     if (q == NULL) {
    
78.             printf("赋值多项式为空!\n");
    
79.         return;
    
80.     }
    
81. 
    
82.     // 如果a不为空链表，先删除a的所有节点
    
83.     while(*a != NULL){
    
84.         Node *temp = *a;
    
85.         *a = (*a)->next;
    
86.             free(temp);
    
87.     }
    
88.     /*k = (p == NULL);
    
89.     printf("%d\n",k);*/
    
90.    
    
91.     // 复制b的所有节点到a
    
92.     while(q != NULL){
    
93.         Node *node = createNode(q->coef, q->exp);
    
94.         if(p == NULL){
    
95.                 //printf("成功");
    
96.             *a = node;
    
97.             p = *a;
    
98.         }else{
    
99.             p->next = node;
    
100.             p = p->next;
     
101.         }
     
102.         q = q->next;
     
103.     }
     
104.    
     
105. }
     
106. 
     
107. 
     
108. // 多项式相加
     
109. Polynomial addPolynomial(Polynomial a, Polynomial b){
     
110.     Node *pa = a;
     
111.     Node *pb = b;
     
112.     Polynomial c = NULL, pc = NULL;
     
113. 
     
114.     while(pa != NULL && pb != NULL){
     
115.         if(pa->exp > pb->exp){
     
116.             if(pa->coef != 0){
     
117.                 Node *node = createNode(pa->coef, pa->exp);
     
118.                 if(c == NULL){
     
119.                     c = node;
     
120.                     pc = c;
     
121.                 }else{
     
122.                     pc->next = node;
     
123.                     pc = pc->next;
     
124.                 }
     
125.             }
     
126.             pa = pa->next;
     
127.         }else if(pa->exp < pb->exp){
     
128.             if(pb->coef != 0){
     
129.                 Node *node = createNode(pb->coef, pb->exp);
     
130.                 if(c == NULL){
     
131.                     c = node;
     
132.                     pc = c;
     
133.                 }else{
     
134.                     pc->next = node;
     
135.                     pc = pc->next;
     
136.                 }
     
137.             }
     
138.             pb = pb->next;
     
139.         }else{
     
140.             float coef_sum = pa->coef + pb->coef;
     
141.             if(coef_sum != 0){
     
142.                 Node *node = createNode(coef_sum, pa->exp);
     
143.                 if(c == NULL){
     
144.                     c = node;
     
145.                     pc = c;
     
146.                 }else{
     
147.                     pc->next = node;
     
148.                     pc = pc->next;
     
149.                 }
     
150.             }
     
151.             pa = pa->next;
     
152.             pb = pb->next;
     
153.         }
     
154.     }
     
155. 
     
156.     while(pa != NULL){
     
157.         if(pa->coef != 0){
     
158.             Node *node = createNode(pa->coef, pa->exp);
     
159.             pc->next = node;
     
160.             pc = pc->next;
     
161.         }
     
162.         pa = pa->next;
     
163.     }
     
164. 
     
165.     while(pb != NULL){
     
166.         if(pb->coef != 0){
     
167.             Node *node = createNode(pb->coef, pb->exp);
     
168.             pc->next = node;
     
169.             pc = pc->next;
     
170.         }
     
171.         pb = pb->next;
     
172.     }
     
173. 
     
174.     return c;
     
175. }
     
176. 
     
177. // 多项式相减
     
178. Polynomial subPolynomial(Polynomial a, Polynomial b){
     
179.     Node *pa = a;
     
180.     Node *pb = b;
     
181.     Polynomial c = NULL, pc = NULL;
     
182. 
     
183.     while(pa != NULL && pb != NULL){
     
184.         if(pa->exp > pb->exp){
     
185.             if(pa->coef != 0){
     
186.                 Node *node = createNode(pa->coef, pa->exp);
     
187.                 if(c == NULL){
     
188.                     c = node;
     
189.                     pc = c;
     
190.                 }else{
     
191.                     pc->next = node;
     
192.                     pc = pc->next;
     
193.                 }
     
194.             }
     
195.             pa = pa->next;
     
196.         }else if(pa->exp < pb->exp){
     
197.             if(-pb->coef != 0){
     
198.                 Node *node = createNode(-pb->coef, pb->exp);
     
199.                 if(c == NULL){
     
200.                     c = node;
     
201.                     pc = c;
     
202.                 }else{
     
203.                     pc->next = node;
     
204.                     pc = pc->next;
     
205.                 }
     
206.             }
     
207.             pb = pb->next;
     
208.         }else{
     
209.             float coef_diff = pa->coef - pb->coef;
     
210.             if(coef_diff != 0){
     
211.                 Node *node = createNode(coef_diff, pa->exp);
     
212.                 if(c == NULL){
     
213.                     c = node;
     
214.                     pc = c;
     
215.                 }else{
     
216.                     pc->next = node;
     
217.                     pc = pc->next;
     
218.                 }
     
219.             }
     
220.             pa = pa->next;
     
221.             pb = pb->next;
     
222.         }
     
223.     }
     
224. 
     
225.     while(pa != NULL){
     
226.         if(pa->coef != 0){
     
227.             Node *node = createNode(pa->coef, pa->exp);
     
228.             pc->next = node;
     
229.             pc = pc->next;
     
230.         }
     
231.         pa = pa->next;
     
232.     }
     
233. 
     
234.     while(pb != NULL){
     
235.         if(-pb->coef != 0){
     
236.             Node *node = createNode(-pb->coef, pb->exp);
     
237.             pc->next = node;
     
238.             pc = pc->next;
     
239.         }
     
240.         pb = pb->next;
     
241.     }
     
242. 
     
243.     return c;
     
244. }
     
245. 
     
246. 
     
247. // 多项式求值
     
248. float evalPolynomial(Polynomial p, float x){
     
249.     float sum = 0;
     
250. 
     
251.     while(p != NULL){
     
252.         float term = p->coef * pow(x, p->exp);
     
253.         sum += term;
     
254.         p = p->next;
     
255.     }
     
256. 
     
257.     return sum;
     
258. }
     
259. 
     
260. 
     
261. // 多项式求导
     
262. Polynomial derPolynomial(Polynomial p){
     
263.     Node *q = NULL, *last = NULL;
     
264. 
     
265.     while(p != NULL){
     
266.         if(p->exp > 0){
     
267.             float coef_der = p->coef * p->exp;
     
268.             Node *node = createNode(coef_der, p->exp-1);
     
269.             if(q == NULL){
     
270.                 q = node;
     
271.                 last = q;
     
272.             }else{
     
273.                 last->next = node;
     
274.                 last = last->next;
     
275.             }
     
276.         }
     
277.         p = p->next;
     
278.     }
     
279. 
     
280.     return q;
     
281. }
     
282. 
     
283. //更新多项式
     
284. void updatePolynomial(Polynomial *p)
     
285. {
     
286.         while(*p != NULL){
     
287.         Node *temp = *p;
     
288.         *p = (*p)->next;
     
289.         free(temp);
     
290.     }
     
291.    
     
292.     int n;
     
293.     float coef;
     
294.     int exp;
     
295. 
     
296.     printf("请输入待插入多项式的项数：");
     
297.     scanf("%d", &n);
     
298. 
     
299.     for(int i=0; i<n; i++){
     
300.         printf("请插入新第%d项的系数和指数：(按降幂输入)", i+1);
     
301.         scanf("%f %d", &coef, &exp);
     
302.         if(coef != 0){
     
303.             Node *node = createNode(coef, exp);
     
304.             if(*p == NULL){
     
305.                 *p = node;
     
306.             }else{
     
307.                 Node *last = *p;
     
308.                 while(last->next != NULL){
     
309.                     last = last->next;
     
310.                 }
     
311.                 last->next = node;
     
312.             }
     
313.         }
     
314.         else
     
315.         {
     
316.                 printf("系数不应为0！\n");
     
317.                 }
     
318.     }
     
319. }
     
320. 
     
321. int main(){
     
322.     Polynomial A = NULL, B = NULL;
     
323.     int choice;
     
324.     float x;
     
325. 
     
326.     while(1){
     
327.         printf("请选择操作：\n");
     
328.         printf("1.向多项式A插入\t\t");
     
329.         printf("2.向多项式B插入\n");
     
330.         printf("3.输出多项式A\t\t");
     
331.         printf("4.输出多项式B\n");
     
332.         printf("5.将A赋值给B\t\t");
     
333.         printf("6.将B赋值给A\n");
     
334.         printf("7.计算A+B\t\t");
     
335.         printf("8.计算A-B\n");
     
336.         printf("9.计算多项式的值\n");
     
337.         printf("10.求多项式的导数\n");
     
338.         printf("11.更新多项式A\t\t");
     
339.         printf("12.更新多项式B\n");
     
340.         printf("13.退出\n");
     
341.         scanf("%d", &choice);
     
342. 
     
343.         switch(choice){
     
344.             case 1:
     
345.                 createPolynomial(&A);
     
346.                 break;
     
347.             case 2:
     
348.                 createPolynomial(&B);
     
349.                 break;
     
350.             case 3:
     
351.                 printf("A = ");
     
352.                 printPolynomial(A);
     
353.                 break;
     
354.             case 4:
     
355.                 printf("B = ");
     
356.                 printPolynomial(B);
     
357.                 break;
     
358.             case 5:
     
359.                 assignPolynomial(&B, A);
     
360.                 /*if (B==NULL){
     
361.                         assignPolynomial(&B,A);
     
362.                                 }*/
     
363.                 break;
     
364.             case 6:
     
365.                 assignPolynomial(&A, B);
     
366.                 /*if (A==NULL){
     
367.                         assignPolynomial(&A,B);
     
368.                                 }*/
     
369.                 break;
     
370.             case 7:
     
371.                 printf("A + B = ");
     
372.                 printPolynomial(addPolynomial(A, B));
     
373.                 break;
     
374.             case 8:
     
375.                 printf("A - B = ");
     
376.                 printPolynomial(subPolynomial(A, B));
     
377.                 break;
     
378.             case 9:
     
379.                 printf("请输入x的值：");
     
380.                 scanf("%f", &x);
     
381.                 printf("A(%g) = %g\n", x, evalPolynomial(A, x));
     
382.                 printf("B(%g) = %g\n", x, evalPolynomial(B, x));
     
383.                 break;
     
384.             case 10:
     
385.                 printf("A' = ");
     
386.                 printPolynomial(derPolynomial(A));
     
387.                 printf("B' = ");
     
388.                 printPolynomial(derPolynomial(B));
     
389.                 break;
     
390.             case 11:
     
391.                                  updatePolynomial(&A);
     
392.                                  break;
     
393.                         case 12:
     
394.                                  updatePolynomial(&B);
     
395.                                  break;
     
396.             case 13:
     
397.                 return 0;
     
398.             default:
     
399.                 printf("无效操作，请重新选择。\n");
     
400.         }
     
401.     }
     
402. 
     
403.     return 0;
     
404. }
     

复制代码

FishC_GPT

这段代码是一个多项式计算器，可以实现多项式的创建、输出、赋值、相加、相减、求值、求导等功能。主要使用了链表来存储多项式的每一项。

首先，定义了一个结构体Node表示多项式中的每一项，包含系数和指数两个成员变量，同时声明了typedef别名Polynomial表示指向Node结构体的指针。

然后，实现了一些基本的操作函数，如createNode用于创建一个新节点，createPolynomial用于创建多项式，printPolynomial用于输出多项式，assignPolynomial用于将一个多项式赋值给另一个多项式，addPolynomial和subPolynomial分别用于多项式的相加和相减，evalPolynomial用于求多项式在某个特定值下的值，derPolynomial用于求多项式的导数，updatePolynomial用于更新多项式。

最后，在main函数中实现了一个简单的交互界面，通过输入选择操作，调用相应的函数进行处理。

这段代码中的注释已经很详细了，如果你有具体的问题，可以提出来让我帮你解答。
以上回复来自 -- ChatGPT（FishC官方接口），如未能正确解答您的问题，请继续追问。

tommyyu

我记得我之前用了 Python 写了一个类似的丐版

六翻了

这个你写了多久？
熟练度多少？
自学还是有人教？

yinda_peng

六翻了 发表于 2023-11-24 11:10
这个你写了多久？
熟练度多少？
自学还是有人教？

一个礼拜断断续续，熟练度，其实没有什么高级东西，就是简单的代码堆起来的，至于你最后那个问题，这是我们的作业……