一元多项式Polynomial的C语言实现

  1 /*
  2    编译器：Dev-c++ 5.4.0
  3    文件名：Polynomial.cpp
  4    代码版本号：1.0
  5    时间：2015年10月9日21:53:26
  6  */
  7
  8  /*
  9 总结：
 10     1.结构体指针指向的区域要手动分配内存
 11     2.反复使用的代码封装成函数
 12 */
 13 #include <stdio.h>
 14 #include <stdlib.h>
 15
 16 #define ERROR 0
 17 #define OK 1
 18 #define TRUE 1
 19 #define FALSE 0
 20 #define OVERFLOW -2
 21
 22 typedef int Status;
 23 typedef struct
 24 {
 25     float coef;
 26     int expn;
 27 }term, ElemType;
 28
 29 typedef struct LNode
 30 {
 31     ElemType *data;
 32     struct LNode *next;
 33 }LNode,*Link,*Position;
 34
 35 typedef struct _LinkList
 36 {
 37     Link head,tail;
 38     int len;
 39 }LinkList;
 40
 41 /*多项式的初始化,建立头结点*/
 42 Status initPolynomial(LinkList *l){
 43     Link p;
 44     p=(Link)malloc(sizeof(LNode));
 45     if(!p)
 46         exit(OVERFLOW);
 47
 48     p->next=NULL;
 49     (*l).head=(*l).tail=p;
 50     (*l).len=0;
 51     printf("多项式初始化成功\n");
 52     return OK;
 53 }
 54
 55 /*判断多项式是否为空表*/
 56 bool listEmpty(LinkList *l){
 57     return !l->len;
 58 }
 59
 60 /*整数比较函数*/
 61 int comp(int a1,int a2)
 62 {
 63     if(a1>a2)
 64         return 1;
 65     else
 66         if(a1==a2)
 67             return 0;
 68         else
 69             return -1;
 70 }
 71
 72 /*判断新节点的指数，定位节点在多项式中是否已经存在*/
 73 int locateLNode(LinkList *l,LNode *p){
 74
 75     LNode *q=((*l).head)->next;
 76 //    if(q) printf("q->data->expn为%d,p->data->expn为%d",q->data->expn,p->data->expn);
 77     while(q&&(q->data->expn!=p->data->expn))
 78     {
 79         q=q->next;
 80
 81     }
 82     //    printf("地址%p\n",q);
 83     if(!q)
 84         return 0;
 85     else
 86         {
 87         return 1;
 88         };
 89
 90 }
 91 /*销毁多项式*/
 92 Status destroyPoly(LinkList *l){
 93     LNode *p;
 94     LNode *q=l->head;
 95     while(q)
 96     {
 97         p=q->next;
 98         free(p);
 99         q=q->next;
100     }
101     free(l->head);
102
103
104     return OK;
105 }
106 /*创建一个结点*/
107 LNode *createLNode(){
108     LNode *q=(LNode*)malloc(sizeof(LNode));
109     q->data=(ElemType*)malloc(sizeof(ElemType));
110     return q;
111 }
112
113 /*case 新节点的指数相等时只需系数相加*/
114 Status lNodePlus(LinkList *l,LNode *p){
115
116     LNode *q=((*l).head)->next;
117     while(q && q->data->expn!=p->data->expn)
118     {
119         q=q->next;
120
121     }
122     if(!q)
123         return OK;
124     else
125         {
126
127         q->data->coef+=p->data->coef;
128         return OK;
129         }
130 }
131 /*case 插入新节点*/
132 Status insertLNode(LinkList *l,LNode *p){
133
134     LNode *q=((*l).head)->next;
135
136     LNode *qian=(*l).head;//q的前一个节点
137     while(q&&q->data->expn < p->data->expn){
138
139         qian=q;
140         q=q->next;
141     }
142     p->next=q;
143     qian->next=p;
144     l->len++;
145     return OK;
146 }
147 /*all 插入节点*/
148 Status LNodePlus(LinkList *l,LNode *p){
149         if(locateLNode(l,p)){
150             lNodePlus(l,p);//指数相等时只需要系数相加
151         }
152         else{
153             insertLNode(l,p);
154         }
155         return OK;
156 }
157
158 /*创建多项式m项的系数和指数*/
159 Status createPolynomial(LinkList *l,int m){
160
161     float coef;    //系数coefficient
162     int expn;//指数exponent
163      for(int i=1;i<=m;i++){
164          printf("\n请输入第%d个系数和指数",i);
165         LNode *p=createLNode();
166         scanf("%f",&(p->data->coef));
167         scanf("%d",&(p->data->expn));
168         LNodePlus(l,p);
169     }
170     printf("多项式创建完毕\n");
171 }
172
173 /*循环输出多项式的系数和指数*/
174 Status polyTraverse(LinkList *l)
175 {
176     LNode *q=((*l).head)->next;
177     printf("\n该多项式有%d个项\n",l->len);
178     while(q)
179     {
180         printf("%fx^%d+",q->data->coef,q->data->expn);
181         q=q->next;
182     }
183     return OK;
184 }
185
186
187 /*多项式的加法*/
188 LinkList addPoly(LinkList *l1,LinkList *l2){
189
190     LNode *q1=((*l1).head)->next;
191     LNode *q2=((*l2).head)->next;
192     LinkList l;
193     initPolynomial(&l);
194     LNode* p=l.head;//p指向多项式最后一项
195     while(q1 && q2){
196
197     switch(comp(q1->data->expn,q2->data->expn))
198         {
199             case 1:{
200                 LNode *q=createLNode();
201
202                 q->data->coef=q2->data->coef;
203                 q->data->expn=q2->data->expn;
204
205                 q->next=NULL;
206                 p->next=q;
207                 p=p->next;
208
209                 q2=q2->next;
210                 l.len++;
211                 break;
212                 }
213             case 0:{
214                 LNode *q=createLNode();
215
216                 q->data->coef=q1->data->coef+q2->data->coef;
217                 q->data->expn=q1->data->expn;
218
219                 q->next=NULL;
220                 p->next=q;
221                 p=p->next;
222
223                 q1=q1->next;
224                 q2=q2->next;
225                 l.len++;
226                 break;
227                 }
228             case -1:{
229                 LNode *q=createLNode();
230
231                 q->data->coef=q1->data->coef;
232                 q->data->expn=q1->data->expn;
233
234                 q->next=NULL;
235                 p->next=q;
236                 p=p->next;
237
238                 q1=q1->next;
239                 l.len++;
240                 break;
241                 }
242         }
243     }
244
245     while(q1){
246         LNode *q=createLNode();
247         q->data->coef=q1->data->coef;
248         q->data->expn=q1->data->expn;
249         q->next=NULL;
250         p->next=q;
251         p=p->next;
252         q1=q1->next;
253         l.len++;
254     }
255
256     while(q2){
257         LNode *q=createLNode();
258         q->data->coef=q2->data->coef;
259         q->data->expn=q2->data->expn;
260         q->next=NULL;
261         p->next=q;
262         p=p->next;
263         q2=q2->next;
264         l.len++;
265     }
266
267
268     return l;
269 }
270
271 /*多项式系数取反*/
272 Status getOpposite(LinkList *l){
273     LNode *q=l->head->next;
274     while(q)
275     {
276         q->data->coef=(-(q->data->coef));
277         q=q->next;
278     }
279     return OK;
280 }
281 /*多项式的减法*/
282 LinkList subtractPoly(LinkList *l1,LinkList *l2){
283     getOpposite(l2);
284     LinkList l=addPoly(l1,l2);
285     getOpposite(l2);
286     return l;
287 }
288
289 /*多项式的乘法*/
290 LinkList multiplyPoly(LinkList *l1,LinkList *l2){
291
292     LinkList l;
293     initPolynomial(&l);
294     LNode *q1=l1->head->next;
295     LNode *q2=l2->head->next;
296     while(q1){
297         q2=l2->head->next;
298         while(q2){
299             LNode *q=createLNode();
300             q->data->coef=q1->data->coef*q2->data->coef;
301             q->data->expn=q1->data->expn+q2->data->expn;
302             printf("q2->data->coef为%f\n",q2->data->coef);
303             LNodePlus(&l,q);
304             q2=q2->next;
305         }
306         q1=q1->next;
307     }
308     return l;
309 }
310
311
312 int main(){
313     LinkList l1,l2;
314
315     /*int n;
316     LinkList l3;
317     initPolynomial(&l3);
318     printf("请输入多项式的term个数:\n");
319     scanf("%d",&n);
320     createPolynomial(&l3,n);
321     polyTraverse(&l3);
322     destroyPoly(&l3);
323     printf("删除后遍历:\n");
324     polyTraverse(&l3);*/
325
326     int m;
327     initPolynomial(&l1);
328     initPolynomial(&l2);
329     printf("请输入多项式的term个数:\n");
330     scanf("%d",&m);
331     createPolynomial(&l1,m);
332     createPolynomial(&l2,m);
333     polyTraverse(&l1);
334     polyTraverse(&l2);
335     LinkList L3=addPoly(&l1,&l2);
336     printf("多项式相加后\n");
337     polyTraverse(&L3);
338     LinkList L4=subtractPoly(&l1,&l2);
339     printf("多项式相减后\n");
340     polyTraverse(&L4);
341     LinkList L5=multiplyPoly(&l1,&l2);
342     printf("多项式相乘后\n");
343     polyTraverse(&L5);
344     system("pause");
345     return 0;
346 }

时间： 2024-07-30 02:44:35

一元多项式Polynomial的C语言实现的相关文章

线性表在一元多项式运算中的应用

实验题1-1 多项式运算 [问题描述]有两个指数递减的一元多项式,写一程序先求这两个多项式的和,再求它们的积. [提示] 用带表头结点的单链表作为多项式的存储表示:要建立两个单链表:多项式相加就是要把一个单链表中的结点插入到另一个单链表中去,要注意插入.删除操作中指针的正确修改. #include <iostream> using namespace std; int k = 1; typedef struct { float coef; //系数 int expn; //指数 }term;

数据结构算法C语言实现（六）---2.4一元多项式的表示及相加

一.简述利用链表表示稀疏多项式,并基于之前的一些操作(编程实现上还是有所不同的)组合新的操作实现一元多项式的表示及相加. 二.ADT 1 抽象数据类型一元多项式的定义 2 ADT Polyomail{ 3 数据对象:D = {a[i]|a[i]属于TermSet, i = 1,2,3...,m,m>=0 4 TermSet中每个元素包含一个表示系数的实数和表示指数的整数} 5 数据关系 6 基本操作: 7 CreatPolyn(&P, m) 8 操作结果:输入 m 项的系数和指数,建立一元

[PAT] 一元多项式的乘法与加法运算 C语言实现

[PAT] 02-线性结构1 一元多项式的乘法与加法运算设计函数分别求两个一元多项式的乘积与和. 输入格式: 输入分2行,每行分别先给出多项式非零项的个数,再以指数递降方式输入一个多项式非零项系数和指数(绝对值均为不超过1000的整数).数字间以空格分隔. 输出格式: 输出分2行,分别以指数递降方式输出乘积多项式以及和多项式非零项的系数和指数.数字间以空格分隔,但结尾不能有多余空格.零多项式应输出0 0. 输入样例: 4 3 4 -5 2 6 1 -2 0 3 5 20 -7 4 3 1 输出

【c++版数据结构】之用带头节点的单链表实现一元多项式（C语言版）

所实现的一元多项式的结构如下图所示: 若只对多项式进行"求值"等不改变多项式系数和指数的运算,采用类似顺序表的顺序存储结构即可,否则应采用链式存储结构,本文因为要进行一元多项式的加法,加法,乘法,故采用的是链式存储结构 Polynomail.h #include<stdio.h> #include<assert.h> struct Node { int coef; //系数 int expn; //指数 }; //节点结构 typedef struct Poly

华为面试题：一元多项式的化简 C语言实现源码

编程实现如下功能:对输入的一元多项式,进行同类项合并,并按指数降序排序,输出处理后的一元多项式. 说明: 1.多项式由若干个单项式组成,单项式之间为加.减(+,-)关系. 2.单项式指数字与字母幂的乘积构成的代数式.对一元多项式,字母只有一种. 3.同类项合并指将多项式中指数相同的单项式,系数经过加减求和,合并为一个单项式.按指数降序指多项式中,单项式按指数从大到小顺序相连. 格式说明一元多项式输入输出时以字符串形式表示,格式如下 l.单项式之间用单个加减运算符相连,运算符:+,- 2.单项

一道 google曾出过的笔试题：编程实现对数学一元多项式的相加和相乘操作（1）

数学中一元n次多项式可表示成如下的形式: Pn(x)=p0+p1x+p2x^2+…+pnx^n (最多有 n+1 项,n +1 个系数唯一确定她) (1)请设计一套接口用以表示和操作一元多项式 (2)根据上述设计实现一元n次多项式的加法运算 (3)根据上述设计实现一元n次多项式的乘法运算分析: 题目大概意思: 数学里常见的一元 n 次表达式,设计出加减乘除的函数(方法),同时提供对外接口,把内部实现封装起来,而 n 的大小没有指定. 问题的本质: 就是一系列的单个未知数 x,指数和系

第二章：5.线性表应用---一元多项式的表示及相加

前言: 学习了线性表的顺序结构和链式结构,那么这种学习有什么用? 本节将会学习如何用线性表来实现一元多项式的表示及相加. 目录: 1.一元多项式正文: 一元多项式: 数学上,一个一元多项式可写成按幂升序排列的形式: Pn(x)= P0 + P1x1 + P2x2 + .... + Pnxn 它由 n+1 个系数唯一确定,因此在计算机里可以用线性表 P 来表示: P= (P0,P1, P2 , .... Pn): 其中每一项的指数隐藏在Pi 的序号中一元多项式的相加(采用顺序存储

数据结构之一元多项式的加法和乘法

Polynomial.h 1 #define _CRT_SECURE_NO_DEPRECATE 2 #include "Polynomial.h" 3 #include <stdio.h> 4 #include <stdlib.h> 5 6 int ListLength(NormLinkList *L) 7 { 8 int num = 0; 9 Link p = NextPos(L, GetHead(L)); 10 while(p) 11 { 12 num++;

线性结构CT 02-线性结构1 一元多项式的乘法与加法运算

设计函数分别求两个一元多项式的乘积与和. 输入格式: 输入分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