两个一元多项式相加-c++版

合集下载

数据结构（C语言）用单链表存储一元多项式,并实现两个多项式的相加运算

#include<stdio.h>#include<stdlib.h>#include<malloc.h>typedef int ElemType;/*单项链表的声明*/typedef struct PolynNode{int coef; // 系数int expn; // 指数struct PolynNode *next;}PolynNode,*PolynList;/*正位序(插在表尾)输入n个元素的值，建立带表头结构的单链线性表*/ /*指数系数一对一对输入*/void CreatePolyn(PolynList &L,int n){int i;PolynList p,q;L=(PolynList)malloc(sizeof(PolynNode)); // 生成头结点L->next=NULL;q=L;printf("成对输入%d个数据\n",n);for(i=1;i<=n;i++){p=(PolynList)malloc(sizeof(PolynNode));scanf("%d%d",&p->coef,&p->expn); //指数和系数成对输入q->next=p;q=q->next;}p->next=NULL;}// 初始条件：单链表L已存在// 操作结果: 依次对L的每个数据元素调用函数vi()。

一旦vi()失败,则操作失败void PolynTraverse(PolynList L,void(*vi)(ElemType, ElemType)){PolynList p=L->next;while(p){vi(p->coef, p->expn);if(p->next){printf(" + "); //“+”号的输出，最后一项后面没有“+” }p=p->next;}printf("\n");}/*ListTraverse()调用的函数(类型要一致)*/void visit(ElemType c, ElemType e){if(c != 0){printf("%dX^%d",c,e); //格式化输出多项式每一项}}/* 多项式相加，原理：归并 *//* 参数：两个已经存在的多项式 *//* 返回值：归并后新的多项式的头结点 */PolynList MergeList(PolynList La, PolynList Lb){PolynList pa, pb, pc, Lc;pa = La->next;pb = Lb->next;Lc = pc = La; // 用La的头结点作为Lc的头结点while(pa&&pb){if(pa->expn < pb->expn){pc->next = pa; //如果指数不相等，pc指针连上指数小的结点，pc = pa;pa = pa->next; //指向该结点的指针后移}else if(pa ->expn > pb->expn ){pc->next = pb; //pc指针连上指数小的结点，pc = pb;pb = pb->next; //指向该结点的指针后移}else//(pa ->expn = pb->expn ){pa->coef = pa->coef + pb->coef; //指数相等时，系数相加 pc->next = pa;pc = pa;pa = pa->next; //两指针都往后移pb = pb->next;}}pc->next = pa ? pa:pb; // 插入剩余段return Lc;}void main(){PolynList ha,hb,hc;printf("非递减输入多项式ha， ");CreatePolyn(ha,5); // 正位序输入n个元素的值printf("非递减输入多项式hb， ");CreatePolyn(hb,5); // 正位序输入n个元素的值printf("多项式ha :");PolynTraverse(ha, visit); printf("\n");printf("多项式hb :"); PolynTraverse(hb, visit); printf("\n");hc = MergeList(ha,hb); PolynTraverse(hc, visit); }。

数据结构C语言实现之一元多项式的表示及相加(2)

以单链表作为存储结构并且和多项式中的结点无需另生成则可看成是将多项式b加到多项式a中由此得到下列运算规则设pq分别指向多项式ab的一项比较结点的指数项若pexpqexp则结点p所指的结点应是和多项式中的一项令指针p后移
数据结构 C 语言实现之一元多项式的表示及相加（2）
一元多项式的表示及相加对于符号多项式的各种操作，实际上都可以利用线性表来处理。比较典型的是关于一元多项式的处理。在
} } e>next; /*将 q 结点加入到和多项式中*/ q =q->next; } }
} if(p!=NULL)/*多项式 A 中还有剩余，则将剩余的结点加入到和多项式中*/
pre->next=p;
else /*否则，将 B 中的结点加入到和多项式中*/ pre->next=q; }
算法 2.24 多项式相加假设 A 多项式有 M 项，B 多项式有 N 项，则上述算法的时间复杂度为 O(M+N) 图 2.20 所示为图 2.19 中两个多项式的和，其中孤立的结点代表被释放的结点。
通过对多项式加法的介绍，我们可以将其推广到实现两个多项式的相乘，因为乘法可以分解为一系列的加法运算。
“中的结点无需另生成，则可看成是将多项式 B 加到多项式 A 中，由此得到下列运算规则（设 p、q 分别指向多项式 A，B 的一项，比较结点的指数项）
若 p->exp< q->exp，则结点 p 所指的结点应是“和多项式”中的一项，令指针 p 后移；若 p>exp>q->exp，则结点 q 所指的结点应是“和多项式”中的一项，将结点 q 插入在结点 p 之前，且令指针 q 在原来的链表上后移；
（1）用单链表存储多项式的结点结构如下： struct Polynode { int coef; int exp; Polynode *next; } Polynode , * Polylist;

一元多项式的各种运算实现(c++,c)

{
float a=1.0;
for(int i=1;i<=k;i++)
a=a*1e-1;
return a;
}
//赋值，参数是指向头结点的指针
void fuzhi(node *&toup)
{
float fumi(int k);
void init(node *&toup);
if(!toup) init(toup);
if(toup) destory(toup);//假如有头结点或元素节点，销毁结点
toup=(node*)malloc(sizeof(node));
if(!toup){cout<<"溢出错误"<<endl;exit(0ext=NULL;
}
//销毁全部，包括头结点
cout<<"*******************************************************************************"<<endl;
cout<<"举例:3 x3 9.3x-3 -x....."<<endl;
}
//求未知数指数是-k时的值
float fumi(int k)
while(p)
{
if(p->data ==0)
{
if(!pr)
{
tem=p;
toup->next =p->next ;
p=p->next ;
toup->length--;
free(tem);
tem=NULL;

两个一元多项式相加

两个一元多项式相加
《两个一元多项式相加》
哎呀！今天老师在数学课上讲了两个一元多项式相加，这可把我难住啦！
啥是一元多项式呀？一开始我是一头雾水。

老师在黑板上写了一堆式子，比如说：3x + 5 和2x - 1 。

老师说要把它们相加，这可咋办？
我瞅瞅同桌，他也皱着眉头，一脸迷茫。

我小声问他：“你懂了没？”他摇摇头说：“这也太难了，谁能搞明白呀？”
老师开始讲解啦，她就像一个神奇的魔法师，一边写一边说：“同学们，咱们先看这两个多项式的同类项，啥是同类项呢？就像一群小伙伴，x 就是它们的标志，系数不一样没关系，但字母和指数得一样。

” 我心里想：这咋跟找朋友似的？
老师接着说：“那3x 和2x 就是同类项，5 和-1 也是同类项。

把同类项的系数相加，3x + 2x 不就等于5x 嘛，5 + （-1）不就是4 嘛。

” 我恍然大悟，这不就像把相同颜色的糖果放到一起嘛！
我赶紧拿起笔自己算，可算着算着又迷糊了。

我拍拍前桌的肩膀问：“你能再给我讲讲不？”前桌回过头来，耐心地说：“你看啊，就像搭积木，相同的积木块堆在一起，数字和字母都不能乱。

”
经过一番努力，我终于算出了几道题。

这感觉太棒啦，就像解开了一个超级大谜题！
等到下课铃响，我还有点意犹未尽呢。

我跟小伙伴们说：“这两个一元多项式相加，一开始觉得像个大怪兽，现在发现也没那么可怕嘛！”
我觉得呀，数学虽然有时候很难，但是只要我们认真听老师讲，多和同学们讨论，就一定能战胜这些难题！就像爬山一样，虽然过程中会累会遇到困难，但是当我们爬到山顶，看到美丽的风景，就会觉得一切都值得！。

c语言数据结构实现——一元多项式的基本运算

文章标题：深入理解C语言中的数据结构实现——一元多项式的基本运算在C语言中，数据结构是非常重要的一个概念，它为我们处理各种复杂的数据提供了便利。

其中，一元多项式的基本运算是数据结构中的一个重要内容，它涉及到多种数据结构的操作和算法，是我们学习C 语言中数据结构的一个重要入口。

在本文中，我们将深入探讨C语言中一元多项式的基本运算，帮助读者更深入地理解这一重要的概念。

一、一元多项式的表示方式在C语言中，一元多项式可以使用数组来表示。

每个数组元素对应一个项，数组的下标对应每一项的次数，数组的值对应该项的系数。

一个一元多项式可以表示为：```cfloat polynomial[10] = {0, 1, 2, 0, 4}; // 表示多项式 1 + 2x + 4x^4 ```二、一元多项式的基本运算1. 一元多项式的加法有两个多项式 A 和 B，它们分别表示为 `float polynomialA[10]` 和`float polynomialB[10]`，那么它们的加法运算可以表示为：```cfor (int i = 0; i < 10; i++) {polynomialC[i] = polynomialA[i] + polynomialB[i];}```2. 一元多项式的减法一元多项式的减法是指将两个多项式相减得到一个新的多项式。

与加法类似，多项式 A 和 B 的减法运算可以表示为：```cfor (int i = 0; i < 10; i++) {polynomialC[i] = polynomialA[i] - polynomialB[i];}```3. 一元多项式的乘法式 A 和 B 的乘法运算可以表示为：```cfor (int i = 0; i < 10; i++) {for (int j = 0; j < 10; j++) {polynomialC[i+j] += polynomialA[i] * polynomialB[j];}}```4. 一元多项式的除法一元多项式的除法涉及到较为复杂的算法，需要考虑余数和商的处理。

一元多项式运算c语言版

#include <stdio.h>#include <stdlib.h>#include <math.h>#define OK 1;#define ERROR 0;#define TURE 1;#define FALSE 0;#define MAXSIZE 100;typedef struct{float coef;int expn;}term,elemtype;typedef struct LNode{elemtype data;struct LNode *next;}List,*LinkList;typedef LinkList polynomail;int Initlist(LinkList *p){*p=(LinkList)malloc(sizeof(List));(*p)->next=NULL;return OK;}int cmp(term a,term b){if(a.expn<b.expn) return -1;else if(a.expn==b.expn) return 0;else return 1;}int LocateElem(LinkList *p,elemtype e,LinkList *q){ if(*p==NULL) return OVERFLOW;*q=(*p)->next;if((*q)==NULL){*q=*p;return ERROR;}while((*q)!=NULL){if(cmp(e,(*q)->data)==0) break;else *q=(*q)->next;}if((*q)!=NULL) return TURE;if((*q)==NULL) {return FALSE;}}int MakeNode(LinkList *s,elemtype e){if(!(*s)) return OVERFLOW;(*s)->data=e;(*s)->next=NULL;return OK;}void InsFirst(LinkList *q,LinkList *s){ (*s)->next=(*q)->next;(*q)->next=*s;}int DelFirst(LinkList *q,LinkList *s){LinkList p;p=*s;(*q)->next=p->next;return OK;}void FreeNode(LinkList *p){LinkList q;q=*p;free(q);}LinkList NextPos(LinkList *p,LinkList *q){ return (*q)->next;}void SetCurElem(polynomail *p,float m){ ((*p)->data).coef=m;}int ListEmpty(LinkList p){if(p->next==NULL) return TURE;if(p->next!=NULL) return FALSE;}void Append(LinkList *p,LinkList *s){ LinkList q;q=*p;while(q->next!=NULL) q=q->next;q->next=*s;}void SortPolyn(polynomail *p){polynomail q,s,t,m,n,x,y,x1,x2;q=*p;Initlist(&m);m->data.coef=0.0;m->data.expn=-1;n=m;s=q;y=s->next;t=y->next;x=q->next;x1=s;x2=t;while(x2!=NULL){while(t!=NULL){if(cmp(x->data,y->data)<=0){s=s->next;y=y->next;t=t->next;}else {x=y;x1=s;x2=t;}}if(cmp(x->data,y->data)>0){x=y;x1=s;x2=t;}x1->next=x2;n->next=x;x->next=NULL;n=n->next;x1=q;x=q->next;x2=x->next;s=x1;y=x;t=x2;}n->next=x;x->next=NULL;q->next=NULL;free(q);*p=m;}void CreatePolyn(polynomail *p,int m){ polynomail h,q[100],s[100],x;int i;elemtype e;elemtype t[100];h=*p;e.coef=0.0;e.expn=-1;h->data=e;h->next=NULL;q[0]=h;Initlist(&x);for(i=0;i<m;i++){Initlist(&s[i]);printf("please input the coef: the expn:\n");scanf("%f%d",&t[i].coef,&t[i].expn);if(!LocateElem(p,t[i],&x)){if(MakeNode(&s[i],t[i])) InsFirst(&q[i],&s[i]);q[i+1]=s[i];}else q[i+1]=q[i];}SortPolyn(p);}void PrintPolyn(polynomail q){q=q->next;if((q->data).coef>0.0&&(q->data).expn!=0)printf("%.4f*x^(%d)",(q->data).coef,(q->data).expn);else if((q->data).expn==0) printf("%.4f",(q->data).coef);else printf("%.4f*x^(%d)",(q->data).coef,(q->data).expn);q=q->next;while(q!=NULL){if((q->data).coef>0.0&&(q->data).expn!=0)printf("+%.4f*x^(%d)",(q->data).coef,(q->data).expn);else if((q->data).expn==0&&(q->data).coef>0.0) printf("+%.4f",(q->data).coef);else if((q->data).expn==0&&(q->data).coef<0.0) printf("%.4f",(q->data).coef);else printf("%.4f*x^(%d)",(q->data).coef,(q->data).expn);q=q->next;}printf("\n");}void AddPolyn(polynomail *pa,polynomail *pb){polynomail ha,hb,qa,qb;ha=*pa;hb=*pb;qa=NextPos(pa,&ha);qb=NextPos(pb,&hb);elemtype a,b;float sum;while(qa&&qb){a=qa->data;b=qb->data;switch(cmp(a,b)){case -1:ha=qa;qa=NextPos(pa,&qa);break;case 0:sum=a.coef+b.coef;if(sum!=0.0){SetCurElem(&qa,sum);ha=qa;}else {DelFirst(&ha,&qa);FreeNode(&qa);}DelFirst(&hb,&qb);FreeNode(&qb);qb=NextPos(pb,&hb);qa=NextPos(pa,&ha);break;case 1:DelFirst(&hb,&qb);InsFirst(&ha,&qb);qb=NextPos(pb,&hb);ha=NextPos(pa,&ha);break;}}if(!ListEmpty(*pb)) Append(pa,&qb);FreeNode(&hb);}void SubStractPolyn(polynomail *pa,polynomail *pb){ polynomail ha,hb,qa,qb;ha=*pa;hb=*pb;qa=NextPos(pa,&ha);qb=NextPos(pb,&hb);elemtype a,b;float sum;while(qb!=NULL){qb->data.coef=-qb->data.coef;qb=qb->next;}qb=NextPos(pb,&hb);while(qa&&qb){a=qa->data;b=qb->data;switch(cmp(a,b)){case -1:ha=qa;qa=NextPos(pa,&qa);break;case 0:sum=a.coef+b.coef;if(sum!=0.0){SetCurElem(&qa,sum);ha=qa;}else {DelFirst(&ha,&qa);FreeNode(&qa);}DelFirst(&hb,&qb);FreeNode(&qb);qb=NextPos(pb,&hb);qa=NextPos(pa,&ha);break;case 1:DelFirst(&hb,&qb);InsFirst(&ha,&qb);qb=NextPos(pb,&hb);ha=NextPos(pa,&ha);break;}}if(!ListEmpty(*pb)) Append(pa,&qb);FreeNode(&hb);}double EvaluatePolyn(polynomail p,float x){ polynomail q;double y=0.0;q=p->next;while(q!=NULL){y+=(q->data.coef)*pow(x,q->data.expn);q=q->next;}return y;}void DestroyPolyn(polynomail *p){free(*p);}void ClearPolyn(polynomail *p){polynomail q;q=*p;while(*p!=NULL){*p=(*p)->next;free(q);q=*p;}}int InsertPolyn(polynomail *q,polynomail *s){while((*q)->next!=NULL){switch(cmp((*q)->next->data,(*s)->data)){case -1:*q=(*q)->next;break;case 0:(*q)->data.coef+=(*s)->data.coef;return OK;case 1:(*s)->next=(*q)->next;(*q)->next=*s;return OK;}(*q)->next=*s;return OK;}}int DeletePolyn(polynomail *q,elemtype x){polynomail t;while((*q)->next!=NULL){if(((*q)->next->data.coef==x.coef)&&((*q)->next->data.expn==x.expn)){ t=(*q)->next;(*q)->next=t->next;free(t);return OK;}else *q=(*q)->next;}if((*q)->next==NULL) return FALSE;}int ChangePolyn(polynomail *p,elemtype x,elemtype y){ polynomail s;MakeNode(&s,y);DeletePolyn(p,x);InsertPolyn(p,&s);return OK;}void DifferentialPolyn(polynomail *p,int n){polynomail q,s;int i;q=*p;s=q->next;for(i=0;i<n;i++){while(s!=NULL){if(s->data.expn!=0){s->data.coef*=s->data.expn;s->data.expn--;q=q->next;s=q->next;}else {q->next=s->next;s=q->next;}}q=*p;s=q->next;}}void MultiplyPolyn(polynomail *pa,polynomail *pb){ int n=0,i;polynomail s,t,q[100];s=*pb;while(s->next!=NULL){n++;s=s->next;}s=(*pb)->next;for(i=0;i<n;i++){q[i]=*pa;t=q[i]->next;while(t!=NULL){t->data.coef*=s->data.coef;t->data.expn+=s->data.expn;t=t->next;}s=s->next;}for(i=1;i<n;i++){AddPolyn(&q[0],&q[i]);}*pa=q[0];}void IntegratePolyn(polynomail *p){polynomail q,s;q=*p;s=q->next;while(s!=NULL){s->data.coef/=s->data.expn+1;s->data.expn++;q=q->next;s=q->next;}}double DefiniteIntegralPolyn(polynomail *p,float x,float y){ IntegratePolyn(p);double f;f=EvaluatePolyn(*p,y)-EvaluatePolyn(*p,x);return f;}void InvolutionPolyn(polynomail *p,int n){polynomail q[100];int i;for(i=0;i<n;i++) q[i]=*p;for(i=1;i<n;i++) MultiplyPolyn(&q[0],&q[i]);*p=q[0];}void DivisionPolyn(polynomail *p,polynomail *q){ polynomail s,t,x,q1,q2,rest;int n,m;s=*p;t=*q;while(s->next!=NULL) s=s->next;while(t->next!=NULL) t=t->next;m=s->data.expn;n=t->data.expn;Initlist(&x);x->data.coef=0.0;x->data.expn=-1;Initlist(&rest);rest->data.coef=0.0;rest->data.expn=-1;while(m!=0&&m>=n){Initlist(&q1);q1->data.coef=0.0;q1->data.expn=-1;AddPolyn(&q1,q);x->data.coef=s->data.coef/(t->data.coef);x->data.expn=s->data.expn-t->data.expn;InsFirst(&rest,&x);q2=(*q)->next;while(q2!=NULL){q2->data.coef*=x->data.coef;q2->data.expn+=x->data.expn;q2=q2->next;}SubStractPolyn(p,&q1);DestroyPolyn(&q1);s=*p;t=*q;while(s->next!=NULL) s=s->next;while(t->next!=NULL) t=t->next;m=s->data.expn;n=t->data.expn;}q1=*p;q2=*q;*p=rest;*q=q1;DestroyPolyn(&q2);}void main(){polynomail p,q,p1,q1;int m,n,t;Initlist(&p);Initlist(&q);Initlist(&p1);Initlist(&q1);printf("please input the length of polynomail:\n");scanf("%d",&m);CreatePolyn(&p,m);CreatePolyn(&q,m);PrintPolyn(p);PrintPolyn(q);AddPolyn(&p,&q);PrintPolyn(p);printf("please input n= \n");scanf("%d",&n);DifferentialPolyn(&p,n);PrintPolyn(p);IntegratePolyn(&p);PrintPolyn(p);printf("please input the length of polynomail:\n");scanf("%d",&t);CreatePolyn(&p1,t);CreatePolyn(&q1,t);PrintPolyn(p1);PrintPolyn(q1);DivisionPolyn(&p1,&q1);PrintPolyn(p1);PrintPolyn(q1);printf("%lf\n",EvaluatePolyn(p,3.0));}。

用C语言实现一元多项式的加减法计算课程设计

用C语言实现一元多项式的加减法计算课程设计武汉理工大学华夏学院课程设计报告书课程名称: 数据结构与算法分析题目: 用C语言实现一元多项式的加减法计算系名: 信息工程系专业班级:姓名:学号:指导教师:7>2014年 1 月 3 日武汉理工大学华夏学院信息工程系课程设计任务书课程名称: 数据结构与算法分析指导教师班级名称: 开课系、教研室:一、课程设计目的与任务《数据结构》课程设计是为训练学生的数据组织能力和提高程序设计能力而设置的增强实践能力的课程。

目的:学习数据结构课程,旨在使学生学会分析研究数据对象的特性,学会数据的组织方法,以便选择合适的数据的逻辑结构和存储结构以及相应操作,把现实世界中的问题转换为计算机内部的表示和处理,这就是一个良好的程序设计技能训练的过程。

提高学生的程序设计能力、掌握基本知识、基本技能,提高算法设计质量与程序设计素质的培养就是本门课程的课程设计的目的。

任务:根据题目要求,完成算法设计与程序实现,并按规定写出课程设计报告。

二、课程设计的内容与基本要求设计题目:用C语言实现一元多项式的加减法计算〔问题描述〕输入并建立两个多项式并输出多项式设计一个程序:对两个多项式进行加、减法运算,建立一个新多项式并输出。

〔实现提示〕:选择单链表存储多项式具体要完成的任务是:A. 编制完成上述问题的C语言程序、进行程序调试并能得出正确的运行结果。

B. 写出规范的课程设计报告书;三、课程设计步骤及时间进度和场地安排时间:本课程设计安排在第18周地点:现代教育中心具体时间安排如下:第一天:布置题目,确定任务、查找相关资料第二天~第四天:功能分析,编写程序,调试程序、运行系统;第五天上午:撰写设计报告;第五天下午:程序验收、答辩。

四、课程设计考核及评分标准课程设计考核将综合考虑学生的系统设计方案、运行结果、课程设计报告书的质量、态度、考勤、答辩情况等各因素。

具体评分标准如下:(1)设计方案正确,具有可行性、创新性; 30分(2)系统开发效果较好;20分(3)设计报告规范、课程设计报告质量高; 20分(4)课程设计答辩时,问题回答正确;20分(5)态度认真、刻苦钻研、遵守纪律;10分按上述五项分别记分后求和,总分按五级制记载最后成绩。

c语言数据结构实现——一元多项式的基本运算

c语言数据结构实现——一元多项式的基本运算在C语言中，一元多项式的表示与运算是常见的数据结构操作之一。

一元多项式由一系列具有相同变量的单项式组成，每个单项式由系数和指数组成。

本文将介绍如何使用C语言实现一元多项式的基本运算，包括多项式的创建、求和、差、乘积等操作。

首先，我们需要定义一个结构体来表示单项式。

每个单项式由一个系数和一个指数组成，我们可以将其定义如下：```cstruct term{float coefficient; // 系数int exponent; // 指数};typedef struct term Term;```接下来，我们可以定义一个结构体来表示一元多项式。

一元多项式由一系列单项式组成，可以使用一个动态数组来存储这些单项式。

```cstruct polynomial{Term* terms; // 单项式数组int num_terms; // 单项式数量};typedef struct polynomial Polynomial;```现在，我们可以开始实现一元多项式的基本运算了。

1. 创建一元多项式要创建一元多项式，我们需要输入每个单项式的系数和指数。

我们可以使用动态内存分配来创建一个适应输入的单项式数组。

```cPolynomial create_polynomial(){Polynomial poly;printf("请输入多项式的项数：");scanf("%d", &poly.num_terms);poly.terms = (Term*)malloc(poly.num_terms * sizeof(Term));for(int i = 0; i < poly.num_terms; i++){printf("请输入第%d个单项式的系数和指数：", i+1);scanf("%f %d", &poly.terms[i].coefficient, &poly.terms[i].exponent);}return poly;}```2. 求两个一元多项式的和两个一元多项式的和等于对应指数相同的单项式系数相加的结果。

一元稀疏多项式运算(数据结构c语言)

if(InsertLocate(h,expn,&pp))//返回值非0表示插入新结点
{ CreateItem(p);
p->coef=coef;
p->expn=expn;
insert(pp,p);
}
else if(Select("has the same expn,Replace older value?"))
/************************************************************///要添加
Polyn SubtractPolyn(Polyn h1,Polyn h2)
{
//int flag;
Item *head,*last,*pa=h1->next,*pb=h2->next,*s,*s0;
}
else if(q->expn==expn)
{ *p=q;
return(0);
}
else
{ *p=pre;
return(-1);
}
}
/************************************************************/
/************************************************************/
int ItemComp(Item x,Item y)
{ if(x.expn<y.expn)
return(-1);
else if(x.expn==y.expn)
h->next=NULL;

两个一元多项式之间进行简单的加减运算

目录1 课题描述及问题分析和任务定义 (2)2逻辑设计 (3)4详细设计 (9)5程序编码 (10)6 程序调试与测试 (17)7总结 (20)参考文献 (21)1 课题描述及问题分析和任务定义采用C语言编写一个一元多项式计算器，能将一个或两个一元多项式输入到计算机中，实现基本的加减计算功能。

实现的具体功能：（1）输入并建立多项式a和b；（2）输出多项式a和b；（3）多项式a和b相加，建立并输出多项式a+b；（4）多项式a和b相减，建立并输出多项式a-b；（5）输入多项式中的未知数，计算多项式的结果。

最终使使用者轻松运用此计算器解决一元多项式的加减计算本计算器主要是为了执行两个一元多项式之间进行简单的加减运算，为此我们需要正确的输入输出多项式。

并能够通过他们的运算关系建立相应的函数，使其能过准确的输出结果。

为此我们需要通过学过的知识写出简单又正确的c语言程序2逻辑设计2.1Status main 程序主函数图2.12.2要求其他子函数不含同类项且指数递减图2.2图2.3图2.4图2.52.6输入有误指令函数运行过程4详细设计status CreatPoly(P_Poly*,int); //创建多项式链表void OutP_Poly(P_Poly); //输出多项式void AddPoly(P_Poly*,P_Poly,P_Poly); //求和void DecPoly(P_Poly*,P_Poly,P_Poly); //求差void DelPoly(P_Poly*); //删除并释放多项式运用上述函数进行编程，组建成函数语句，使其正确运行达到目的5程序编码可依据上述程序流程设计图编写程序#include <stdio.h>#include <stdlib.h>#define OK 1;#define READ(I) while (((I)=getchar())=='\n'); //读入合法字符typedef int status;typedef struct PolyNode{float coef;int expn;struct PolyNode *next;}Poly,*P_Poly;status CreatPoly(P_Poly*,int); //创建多项式链表void OutP_Poly(P_Poly); //输出多项式void AddPoly(P_Poly*,P_Poly,P_Poly); //求和void DecPoly(P_Poly*,P_Poly,P_Poly); //求差void DelPoly(P_Poly*); //删除并释放多项式status main(){P_Poly PolyHead[26]={0};char menu,name;for (;;){printf ("********************\n");printf ("1.建立多项式\n");printf ("2.输出多项式\n");printf ("3.求两个多项式之和(必须先创建),建立和式并输出\n");printf ("4.求两个多项式之差(必须先创建),建立差式并输出\n");printf ("5.删除多项式\n");printf ("6.退出\n");printf ("********************\n");printf ("请选择指令:");READ(menu)switch (menu){case '1':{int n;printf ("请输入要创建的多项式的名称（单个小写字母表示）:"); READ(name)printf ("此多项式已经存在!\n");break;}printf ("请输入项数:");scanf ("%d",&n);if(CreatPoly(&PolyHead[name-'a'],n)) printf ("多项式%c创建完毕!\n",name); break;}case '2':printf ("请输入要输出的多项式的名称:");READ(name)if (NULL==PolyHead[name-'a']){printf ("此多项式不存在!\n");break;}OutP_Poly(PolyHead[name-'a']);break;case '3':{char name1,name2;printf ("请输入加式一的名称:");READ(name1)if (NULL==PolyHead[name1-'a']){printf ("此多项式不存在!请先创建\n");break;}printf ("请输入加式二的名称:");READ(name2)if (NULL==PolyHead[name2-'a']){printf ("此多项式不存在!请先创建\n");break;}printf ("请输入要创建的和式的名称:");READ(name)if (NULL!=PolyHead[name-'a']){printf ("此多项式已经存在!\n");break;}AddPoly(&PolyHead[name-'a'],PolyHead[name1-'a'],PolyHead[name2-'a']);OutP_Poly(PolyHead[name-'a']);break;}case '4':{char name1,name2;printf ("请输入被减式的名称:");READ(name1)if (NULL==PolyHead[name1-'a'])printf ("此多项式不存在!请先创建\n");break;}printf ("请输入减式的名称:");READ(name2)if (NULL==PolyHead[name2-'a']){printf ("此多项式不存在!请先创建\n");break;}printf ("请输入要创建的差式的名称:");READ(name)if (NULL!=PolyHead[name-'a']){printf ("此多项式已经存在!\n");break;}DecPoly(&PolyHead[name-'a'],PolyHead[name1-'a'],PolyHead[name2-'a']); OutP_Poly(PolyHead[name-'a']);break;}case '5':printf ("请输入要删除的多项式名称:");READ(name)if (NULL==PolyHead[name-'a']){printf ("此多项式不存在!\n");break;}DelPoly(&PolyHead[name-'a']);printf ("多项式%c已删除!\n",name);break;case '6':return OK;}}}status CreatPoly(P_Poly* P_PolyHead,int n){ //为确保其他子函数正常运行，入口参数要求不含同类项、指数递减int i=0;P_Poly p,tail;*P_PolyHead=(Poly*)malloc(sizeof(Poly));(*P_PolyHead)->expn=n;tail=*P_PolyHead;printf ("请按照指数递减序输入最简形式的多项式\n");for (;i<n;i++){p=(Poly*)malloc(sizeof(Poly));printf ("请输入第%d项的系数和指数(系数，指数):",i+1);scanf ("%f,%d",&(p->coef),&(p->expn));tail->next=p;tail=p;}tail->next=NULL;return OK;}void OutP_Poly(P_Poly PolyHead){int i=0;P_Poly p;printf ("%d ",PolyHead->expn);p=PolyHead->next;for (;i<PolyHead->expn;i++){printf ("%f,%d ",p->coef,p->expn);p=p->next;}printf ("\n");}void AddPoly(P_Poly* P_PolyHead,P_Poly PolyHead1,P_Poly PolyHead2) {int i=0;P_Poly p1,p2,p,tail;p1=PolyHead1->next;p2=PolyHead2->next;*P_PolyHead=(P_Poly)malloc(sizeof(Poly));p=tail=*P_PolyHead;while(p1&&p2){int e1,e2;e1=p1->expn;e2=p2->expn;if (e1>e2){p=(P_Poly)malloc(sizeof(Poly));tail->next=p;tail=p;*p=*p1;p1=p1->next;i++;}else if(e1==e2){float sum_c=p1->coef+p2->coef;if (sum_c!=0.0){p=(P_Poly)malloc(sizeof(Poly));tail->next=p;tail=p;p->coef=sum_c;p->expn=e1;i++;}p1=p1->next;p2=p2->next;}else if (e1<e2){p=(P_Poly)malloc(sizeof(Poly));tail->next=p;tail=p;*p=*p2;p2=p2->next;i++;}}while (p1){p=(Poly*)malloc(sizeof(Poly));*p=*p1;tail->next=p;tail=p;p1=p1->next;i++;}while (p2){p=(Poly*)malloc(sizeof(Poly));*p=*p2;tail->next=p;tail=p;p2=p2->next;i++;}(*P_PolyHead)->expn=i;tail->next=NULL;}void DecPoly(P_Poly* P_PolyHead,P_Poly PolyHead1,P_Poly PolyHead2) {int i=0;P_Poly p1,p2,p,tail;p1=PolyHead1->next;p2=PolyHead2->next;*P_PolyHead=(P_Poly)malloc(sizeof(Poly));p=tail=*P_PolyHead;while(p1&&p2){int e1,e2;e1=p1->expn;e2=p2->expn;if (e1>e2){p=(P_Poly)malloc(sizeof(Poly)); tail->next=p;tail=p;*p=*p1;p1=p1->next;i++;}else if(e1==e2){float dif_c=p1->coef-p2->coef; if (dif_c!=0.0){p=(P_Poly)malloc(sizeof(Poly)); tail->next=p;tail=p;p->coef=dif_c;p->expn=e1;i++;}p1=p1->next;p2=p2->next;}else if (e1<e2){p=(P_Poly)malloc(sizeof(Poly)); tail->next=p;tail=p;p->coef=-p2->coef;p->expn=p2->expn;p2=p2->next;i++;}}while (p1){p=(Poly*)malloc(sizeof(Poly));*p=*p1;tail->next=p;tail=p;p1=p1->next;i++;}while (p2){p=(Poly*)malloc(sizeof(Poly));*p=*p2;tail->next=p;tail=p;p2=p2->next;i++;}(*P_PolyHead)->expn=i;tail->next=NULL;}void DelPoly(P_Poly* P_PolyHead) {P_Poly p,prior;p=prior=*P_PolyHead;while (p->next){p=p->next;free(prior);prior=p;}*P_PolyHead=NULL;}6 程序调试与测试在vc6.0的运行环境下，经过调试可以实现以下结果和功能：1.建立多项式图6.1为建立多项式2.输出多项式a图6.2为输出多项式3.输入多项式b图6.3为输入多项式4.求多项式m=a+b并输出结果图6.4为求多项式m=a+b并输出结果5.求多项式n=a-b并输出结果图6.5为求多项式n=a-b并输出结果6.分别删除多项式a和b图6.6为分别删除多项式a和b7.若选择指令错误图6.7为指令错误根据输出的结果:当提示选择指令时,只有输入程序规定的格式时,才会进入下一层程序,否则将输出请选择指令：其正确的输入我们将可输入输出多项式及进行加减运算7总结本次实验通过学过的知识和老师的指导，已经达到最终目的。

一元多项式相加减c语言

一元多项式相加减c语言一元多项式相加减是一个基础的多项式操作，其基本形式是用数组存储系数和指数（对于非零项来说），然后进行相应的加减操作。

以下是一个简单的C语言实现：```c#include <stdio.h>struct term {int coeff; // 系数int exp; // 指数};struct poly {int len; // 多项式的长度struct term *arr; // 存储多项式每一项的数组};// 创建多项式struct poly create_poly(int coeff[], int exp[]) {struct poly p;p.len = sizeof(coeff) / sizeof(coeff[0]);p.arr = (struct term*)malloc(p.len * sizeof(struct term));for (int i = 0; i < p.len; i++) {p.arr[i].coeff = coeff[i];p.arr[i].exp = exp[i];}return p;}// 多项式相加struct poly poly_add(struct poly p1, struct poly p2) {struct poly result = {0, NULL};int len = p1.len > p2.len ? p1.len : p2.len;result.arr = (struct term*)malloc(len * sizeof(struct term));for (int i = 0; i < len; i++) {if (i < p1.len && i < p2.len && p1.arr[i].exp == p2.arr[i].exp) {result.arr[i].coeff = p1.arr[i].coeff + p2.arr[i].coeff; } else if (i < p1.len) {result.arr[i].coeff = p1.arr[i].coeff;result.arr[i].exp = p1.arr[i].exp;} else { // i < p2.lenresult.arr[i].coeff = p2.arr[i].coeff;result.arr[i].exp = p2.arr[i].exp;}}result.len = len;return result;}// 多项式相减struct poly poly_sub(struct poly p1, struct poly p2) {struct poly result = {0, NULL};int len = p1.len > p2.len ? p1.len : p2.len;result.arr = (struct term*)malloc(len * sizeof(struct term));for (int i = 0; i < len; i++) {if (i < p1.len && i < p2.len && p1.arr[i].exp == p2.arr[i].exp) {result.arr[i].coeff = p1.arr[i].coeff - p2.arr[i].coeff; } else if (i < p1.len) { // 如果p1有该项，而p2没有，则直接复制p1的项到结果中。

数据结构C++单链表一元多项式的相加

数据结构C++单链表⼀元多项式的相加#include <iostream>using namespace std;struct Node {double coe; //系数int exp; //指数Node *next;};void CreatPoly(Node *&head, int n) // ⽣成带表头结点的单链表，除头结点外另⽣成n个结点{head = (Node *)new Node;head->coe = 0;head->exp = 0;head->next = NULL; // 初始化头结点cout << "分别每⾏输⼊各项系数及指数：" << endl;Node *p = head;for(int i = 0; i < n; i++) {p->next = (Node *)new Node; // ⽣成新结点，尾插⼊⽣成链表p = p->next;cin >> p->coe >> p->exp;p->next = NULL;}}void ShowPoly(Node *&head){if(head->next == NULL) // 结果是0时直接输出0putchar('0');else {for(Node *p = head->next; p != NULL; p = p->next) {if(p != head->next && p->coe >0) // 当p⾮⾸项且指向的系数为正时才输出'+'putchar('+'); // 之前只判定了p->coe >0if(p->coe == 1) { // 系数为1或-1时特殊处理if(p->exp == 0)putchar('1'); // 判断条件不能写在⼀起：} // if(p->coe == 1 && p->exp == 0) putchar('1');else if(p->coe == -1)putchar('-');elsecout << p->coe;// 指数为0或1时特殊处理switch(p->exp) {case 0:break;case 1:putchar('x');break;default:p->exp < 0 ? printf("x^(%d)", p->exp) : printf("x^%d", p->exp); // 指数⼩于0时打括号break;}}}cout << endl;}char comp(int a, int b)if(a > b)return '>';if(a < b)return '<';return '=';}void Free(Node *&head){Node *q = NULL;for(Node *p = head; p != NULL; p = q) {q = p->next;free(p);}}void AddPolynomial(Node *&pA, Node *&pB) // 传进两个链表的头指针{Node *ha = pA;Node *hb = pB;Node *qa = ha->next; // ha, hb分别跟在qa, qb的后⼀位置Node *qb = hb->next; // qa, qb分别指向Pa, Pb中当前⽐较元素while(qa && qb){double sum = 0;int a = qa->exp;int b = qb->exp;switch( comp(a, b) ) {case '<':ha = qa;qa = qa->next; // ⾮ha = ha->next;break;case '=':sum = qa->coe + qb->coe;if(sum != 0.0) {qa->coe = sum;ha = qa;}else {if(ha->next != qa)cout << "Error: ha->next != qa" << endl;ha->next = ha->next->next; // 删除和为0的结点，ha不变，还在qa后⼀位置free(qa);}if(hb->next != qb)cout << "Error: hb->next != qb" << endl;hb->next = hb->next->next;free(qb);qb = hb->next;qa = ha->next;break;case '>':hb->next = hb->next->next; // 删除qb指向的结点qb->next = ha->next; // 将qb插⼊ha后qa前ha->next = qb;qb = hb->next; // not qb = ha->nextha = ha->next;break;default:cout << "Error!" << endl;break;}if(qb)ha->next = qb;free(hb);}void main(void){Node *A = NULL;Node *B = NULL;int countA;int countB;cout << "请输⼊A的项数：" << endl, cin >> countA; CreatPoly(A, countA); // ⽣成A链表cout << "请输⼊B的项数：" << endl; // ⽣成B链表cin >> countB;CreatPoly(B, countB);cout << " A = ";ShowPoly(A);cout << " B = ";ShowPoly(B);AddPolynomial(A, B); // A = A + Bcout << "A+B= ";ShowPoly(A); // 输出相加的和cout << endl;// 释放结点delete A;}。

C++一元多项式合并实验报告

实验二一元多项式相加问题本实验的目的是进一步熟练掌握应用链表处理实际问题的能力。

一、问题描述一元多项式相加是通过键盘输入两个形如P0+P1X1+P2X2+···+PnX n的多项式，经过程序运算后在屏幕上输出它们的相加和。

二、数据结构设计分析任意一元多项式的描述方法可知，一个一元多项式的每一个子项都由“系数—指数”两部分组成，所以可将它抽象成一个由“系数—指数对”构成线性表，由于对多项式中系数为0的子项可以不记录他的数值，对于这样的情况就不再付出存储空间来存放它了。

基于这样的分析，可以采取一个带有头结点的单链表来表示一个一元多项式。

具体数据结构定义为：typedef struct node{float ce; //系数域float ex; //指数域struct node *next; //指针域}lnode,*linklist;三功能（函数）设计1、输入并建立多项式的功能模块此模块要求按照指数递增的顺序和一定的输入格式输入各个系数不为0的子项的“系数—指数对”，输入一个子项建立一个相关的节点，当遇到输入结束标志时结束输入，而转去执行程序下面的部分。

屏幕提示：input ce & ex and end with 0：ce=1ex=2ce=0ex=0 //输入结束标志input ce & ex and end with 0：ce=2ex=2ce=0ex=0 //输入结束标志输入后程序将分别建立两个链表来描述两个一元多项式：A=X^2B=2X^2这两个多项式的相加的结果应该为：C=3X^22、多项式相加的功能模块此模块根据在1中建立的两个多项式进行相加运算，并存放在以C为头指针的一个新建表中。

可以采用以下方法进行设计：开始时a，b分别指向A,B的开头，如果ab不为空，进行判断：如果a所指的结点的指数和b所指的结点的指数相同，将它们的系数相加做成C式中的一项，如果不一样则将小的一项加到C中。

一元多项式相加C语言代码

数据结构作业一元多项式相加C语言代码#include<stdio.h>#include<malloc.h>typedef struct node{int exp,coef;struct node *link;}PolyNode,*Polylinklist;Polylinklist Creat(int n){Polylinklist p,r=NULL,list=NULL;int coef,exp,i;for(i=1;i<=n;i++){scanf("%d %d",&coef,&exp);p=(Polylinklist)malloc(sizeof(PolyNode));p->coef=coef;p->exp=exp;p->link=NULL;if(list==NULL)list=p;elser->link=p;r=p;}return(list);}Polylinklist ATTACH(int coef,int exp,Polylinklist r){Polylinklist w;w=(Polylinklist)malloc(sizeof(PolyNode));w->exp=exp;w->coef=coef;r->link=w;return w;}Polylinklist PADD(Polylinklist a,Polylinklist b){Polylinklist c;Polylinklist r,p=a,q=b;int x;c=(Polylinklist)malloc(sizeof(PolyNode));r=c;while(p!=NULL&&q!=NULL)if(p->exp==q->exp){x=p->coef+q->coef;if(x!=0)r=ATTACH(x,q->exp,r);p=p->link;q=q->link;}else if(p->exp<q->exp){r=ATTACH(q->coef,q->exp,r);q=q->link;}else {r=ATTACH(p->coef,p->exp,r);p=p->link;}while(p!=NULL){r=ATTACH(p->coef,p->exp,r);p=p->link;}while(q!=NULL){r=ATTACH(q->coef,q->exp,r);q=q->link;}r->link=NULL;p=c;c=c->link;free(p);return c;}void Result(Polylinklist w){Polylinklist m;m=w;while(w==NULL){printf("0");break;}while(w!=NULL){if(w->exp==0)printf("%d",w->coef);elseprintf("%d*x^%d",w->coef,w->exp);w=w->link;while(w!=NULL){if(w->coef>0){if(w->exp==0)printf("+%d",w->coef);elseprintf("+%d*x^%d",w->coef,w->exp);}else{if(w->exp!=0)printf("%d*x^%d",w->coef,w->exp);elseprintf("%d",w->coef);}w=w->link;}}}void main(){Polylinklist c=NULL;PolyNode *Lengtha;PolyNode *Lengthb;int a1,b1;printf("Please input a's Length:");scanf("%d",&a1);Lengtha=Creat(a1);printf(" a=");Result(Lengtha);printf("\n");printf("Please input b's Length:");scanf("%d",&b1);Lengthb=Creat(b1);printf(" b=");Result(Lengthb);printf("\n");c=PADD(Lengtha,Lengthb);printf("\n");printf(" c=");Result(c);printf("\n");}。

c++一元多项式求和顺序表

在C++中，可以使用顺序表来实现一元多项式的求和操作。

一元多项式可以表示为一系列的系数和指数对，例如：3x^2 + 2x + 5。

下面是一个简单的C++代码示例，用于实现一元多项式的求和顺序表：#include <iostream>#include <vector>struct Term {int coefficient; // 系数int exponent; // 指数};// 求和函数std::vector<Term> sumPolynomials(const std::vector<Term>& poly1, const std::vector<Term>& poly2) {std::vector<Term> result;int i = 0, j = 0;while (i < poly1.size() && j < poly2.size()) {if (poly1[i].exponent > poly2[j].exponent) {result.push_back(poly1[i]);i++;} else if (poly1[i].exponent < poly2[j].exponent) {result.push_back(poly2[j]);j++;} else {int sum = poly1[i].coefficient + poly2[j].coefficient;if (sum != 0) {Term term;term.coefficient = sum;term.exponent = poly1[i].exponent;result.push_back(term);}i++;j++;}}// 将剩余的项添加到结果中while (i < poly1.size()) {result.push_back(poly1[i]);i++;}while (j < poly2.size()) {result.push_back(poly2[j]);j++;}return result;}int main() {std::vector<Term> poly1 = {{3, 2}, {2, 1}, {5, 0}}; // 3x^2 + 2x + 5std::vector<Term> poly2 = {{-1, 2}, {3, 1}, {2, 0}}; // -x^2 + 3x + 2std::vector<Term> result = sumPolynomials(poly1, poly2);// 输出结果for (const auto& term : result) {std::cout << term.coefficient << "x^" << term.exponent << " ";}std::cout << std::endl;return 0;}在这个示例中，我们定义了一个结构体Term来表示一元多项式的每一项，然后编写了一个sumPolynomials函数来实现两个多项式的求和操作。

一元多项式相加(C语言实现)

//一元多项式相加//#define ERROR 0#include<stdio.h>#include<malloc.h>//#include<stdlib.h>typedef struct poly{ float coef;int expn;struct poly *next;}poly,*Linkpoly;void main(){Linkpoly creatpoly();Linkpoly addpoly(Linkpoly La,Linkpoly Lb);void printpoly(Linkpoly L);Linkpoly La,Lb;La=creatpoly();Lb=creatpoly();printf("多项式1:\n");printpoly(La);printf("\n");printf("多项式2:\n");printpoly(Lb);printf("\n");addpoly(La,Lb);printf("相加后的多项式:\n");printpoly(La);}Linkpoly creatpoly()//创建链表，输入多项式{int i,n;Linkpoly p,L;printf("请输入多项式项数:\n");scanf("%d",&n);printf("逆序输入多项式: <系数,指数>\n");L=(Linkpoly)malloc(sizeof(poly));//头结点L->next=NULL;for(i=n;i>0;--i){p=(Linkpoly)malloc(sizeof(poly));scanf("%f,%d",&p->coef,&p->expn);p->next=L->next; L->next=p;}return L;}Linkpoly addpoly(Linkpoly La,Linkpoly Lb)//多项式相加{Linkpoly p,r,q,s,s1,s2;r=La;//r指向p的前驱p=La->next;q=Lb->next;while(p&&q){if(p->expn<q->expn) { r=p;p=p->next;continue;}if(p->expn>q->expn) {s=q->next;q->next=r->next;r->next=q;q=s;r=r->next;continue;}if(p->expn==q->expn&&(p->coef+q->coef)!=0) { p->coef=p->coef+q->coef;r=p;p=p->next;q=q->next;continue;} if(p->expn==q->expn&&(p->coef+q->coef)==0) { s1=p;s2=q;p=r;p->next=p->next->next;p=p->next;q=q->next;continue;free(s1);free(s2);}}if(q){p=r;p->next=q;p=p->next;// free(p);}// return La;}void printpoly(Linkpoly L){Linkpoly p;p=L->next;while(p){printf("<%0.2f,%d> ",p->coef,p->expn);p=p->next;}}。

一元多项式(C语言版)

//指数相同
sum=p1->coef+p2->coef;
//sum 保存两项的系数和
if(sum){
//系数和不为 0
p1->coef=sum;
//修改 pa 当前结点 p1 的系数值
为两项系数的和
p3->next=p1;p3=p1;
//将修改后的 pa 当前结点 p1 链在
p3 之后,p3 指向 p1
pre 之间
}
printf("--创建成功--\n");
return p;
}
//一元多项式项数
int pnodelength(polynomial p)
{
polynomial q;
//q
int count=0;
//总共有多少项
q=p->next;
//第一项(首结点)
while(q)
//while(q)
pre=p;
//pre 用于保存 q 的前驱,初值为
头结点
q=p->next;
//q 初值为首结点
while(q&&q->expn<=s->expn){
//通过比较找到第一个大于输入
项指数的项 q
pre=q;
//
q=q->next;
//
}
//
s->next=q;pre->next=s;
//将输入项 s 插入到 q 和其前驱结点
q=q->next;
//指向下一个项
}
if(i!=0) putchar('\n');
//多项式不空,换行
}