实验一-一元多项式运算

合集下载

一元多项式加减乘除运算

一元多项式加减乘除运算

中国计量学院实验报告实验课程:算法与数据结构实验名称:一元二项式班级:学号:姓名:实验日期: 2013-5-7一.实验题目:①创建2个一元多项式②实现2个多项式相加③实现2个多项式相减④实现2个多项式相乘⑤实现2个多项式相除⑥销毁一元多项式实验成绩:指导教师:二.算法说明①存储结构:一元多项式的表示在计算机内可以用链表来表示,为了节省存储空间,只存储多项式中系数非零的项。

链表中的每一个结点存放多项式的一个系数非零项,它包含三个域,分别存放该项的系数、指数以及指向下一个多项式项结点的指针。

创建一元多项式链表,对一元多项式的运算中会出现的各种可能情况进行分析,实现一元多项式的相加、相减操作。

②加法算法三.测试结果四.分析与探讨实验数据正确,部分代码过于赘余,可以精简。

五.附录:源代码#include<>#include<>#include<>typedef struct Polynomial {float coef;int expn;struct Polynomial *next;}*Polyn,Polynomial;出多项式a和b\n\t2.多项式相加a+b\n\t3.多项式相减a-b\n");printf("\t4.多项式相除a*b\n\t5.多项式相除a/b\n\t6.销毁多项式\n");printf("\t7.退出\n*********************************** ***********\n");printf("执行:");scanf("%d",&flag);switch(flag){case(1):printf("多项式a:");PrintPolyn(pa); printf("多项式b:");PrintPolyn(pb);break;case(2):pc=AddPolyn(pa,pb);printf("多项式a+b:");PrintPolyn(pc);DestroyPolyn(pc);break;case(3):pd=SubtractPolyn(pa,pb);printf("多项式a-b:");PrintPolyn(pd);DestroyPolyn(pd);break;case(4):pf=MultiplyPolyn(pa,pb);printf("多项式a*b:");PrintPolyn(pf); DestroyPolyn(pf);break;case(5):DevicePolyn(pa,pb);break;case(6):DestroyPolyn(pa);DestroyPolyn(pb);printf("成功销毁2个一元二项式\n");printf("\n接下来要执行的操作:\n1 重新创建2个一元二项式 \n2 退出程序\n");printf("执行:");scanf("%d",&i);if(i==1){// Polyn pa=0,pb=0,pc,pd,pf;//定义各式的头指针,pa与pb在使用前付初值NULLprintf("请输入a的项数:");scanf("%d",&m);pa=CreatePolyn(pa,m);//建立多项式aprintf("请输入b的项数:");scanf("%d",&n);pb=CreatePolyn(pb,n);//建立多项式bbreak;}if(i==2)return 0; case(7): return 0;} } } }。

北邮数据结构实验一元多项式实验报告

北邮数据结构实验一元多项式实验报告

数据结构实验报告实验名称:实验一—线性表实现一个多项式学生姓名:黄锦雨班级:2011211109班内序号:20学号:2011210263日期:2012年10月31日实验目的:1.熟悉C++语言的基本编程方法,掌握集成编译环境的调试方法2.学习指针、模板类、异常处理的使用3.掌握线性表的操作的实现方法4.学习使用线性表解决实际问题的能力实验内容:利用线性表实现一个一元多项式Polynomialf(x) = a0 + a1x + a2x2 + a3x3+ … + a n x n要求:1.能够实现一元多项式的输入和输出2.能够进行一元多项式相加3.能够进行一元多项式相减4.能够计算一元多项式在x处的值5.能够计算一元多项式的导数(选作)6.能够进行一元多项式相乘(选作)7.编写测试main()函数测试线性表的正确性2. 程序分析由于多项式是线性结构,故选择线性表来实现,在这个程序中我采用的是单链表结构,每个结点代表一个项,多项式的每一项可以用其系数和指数唯一的表示。

如果采用顺序存储,那么对于结点的插入和删除的操作会比较麻烦,而且顺序表的结点个数固定,对于可能发生的情况无法很好的处理,而采用链表就会简单许多,还能自由控制链表的长度。

两个多项式要进行多次的计算,为了保护原始的数据,方便进行以后的计算,故选择把结果存储在一个新建的链表里。

2.1本程序完成的主要功能:1.输入和输出:需要输入的信息有多项式的项数,用来向系统动态申请内存;多项式各项的系数和指数,用来构造每个结点,形成链表。

输出即是将多项式的内容向屏幕输出。

2.多项式相加与相减:多项式的加减要指数相同即是同类项才能实现,所以在运算时要注意判断指数出现的各种不同的情况,分别写出计算方法。

将每项运算得到的结果都插入到新的链表中,形成结果多项式。

3.多项式的求导运算:多项式的求导根据数学知识,就是将每项的系数乘以指数,将指数减1即可,将每项得到的结果插入到结果多项式的链表中。

一元多项式的运算

一元多项式的运算

⼀元多项式的运算以⼀元多项式加法运算为例:A,B可⽤线性链表可以表⽰为:“和多项式”链表如下(图中的长⽅框表⽰已经被释放的结点):#include <stdio.h>#include <stdlib.h>typedef struct Polyn{int data;int index;struct Polyn *next;}Polyn,*Polynlist;void CreatPolyn(Polynlist &p,int m)//输⼊m项的系数和指数,建⽴⼀元多项式P{//有头结点Polyn *q=p;for(int i=0;i<m;i++){q->next=(Polyn*)malloc(sizeof(Polyn));q=q->next;// printf("第%d项系数、指数:",i+1);scanf("%d%d",&q->data,&q->index);}q->next=0;}void PrintPolyn(Polynlist &p)//打印⼀元多项式P{Polyn *q=p->next;//(x^0)和(x^1)要做特别处理if(q->index == 0){printf("%d",q->data);//可能第⼆项指数为xq=q->next;q=q->next;if(q && q->index == 1){if(q->data != 1)printf("%+dx",q->data);//正数则在前⾯加+,否则不加elseprintf("+x");q = q->next;}}else if(q->index == 1){if(q->data != 1)printf("%dx",q->data);elseprintf("x");q = q->next;}else{printf("%dx^%d",q->data,q->index);q = q->next;}while(q){printf("%+dx^%d",q->data,q->index);q=q->next;}printf("\n");}void CopyPolyn(Polynlist &q,Polyn *r)//空指针必须引⽤去创建,新开辟结点链表并复制(数据域和指针域) {q = (Polyn *)malloc(sizeof(Polyn));Polyn *q1 = q,*r1 = r->next;while(r1){q1->next = (Polyn *)malloc(sizeof(Polyn));q1 = q1->next;q1->data = r1->data;q1->index = r1->index;r1 = r1->next;}q1->next = NULL;}void ShowMenu(){printf("\t\t\t1.多项式相加\n");printf("\t\t\t2.多项式相减\n");printf("\t\t\t3.多项式相乘\n");printf("\t\t\t4.退出\n");}void AddPolyn(Polyn *p,Polyn *p1)//完成多项式相加运算,p=p+p1,并销毁p1{Polyn *qa,*qb,*prior,*r;//设置prior是为B链表中的结点插⼊A链表⽤prior = p;qa = p->next;qb = p1->next;while(qa && qb){if(qa->index < qb->index){prior = qa;qa = qa->next;}else if(qa->index > qb->index){r = qb;qb = qb->next;//摘取qb到“和多项式”链表中r->next = qa;prior->next = r;//更新priorprior = r;}else{else{if(qa->data + qb->data != 0){//修改qa所指结点的系数值,同时释放qb所指的结点qa->data = qa->data + qb->data;r = qb;qb = qb->next;free(r);}else{//释放指针qa和qb所指的结点r = qa;qa = qa->next;prior->next = qa;//衔接free(r);r = qb;qb = qb->next;free(r);}}}//B链表还有结点if(qb){prior->next = qb;//此时qa已为空指针}free(p1);//释放B头结点}void reverse(Polyn *p){Polyn *q = p->next;while(q){q->data = -(q->data);q = q->next;}}void DestroyPolyn(Polyn *r){Polyn *q;do{q = r;r = r->next;free(q);}while(r);}void AdjustPolyn(Polyn *r,int data,int index)//调整每⼀项{Polyn *q = r->next;while(q){q->data *= data;q->index += index;q = q->next;}}void SubtractPolyn(Polynlist &p,Polynlist &p1)//完成多项式相减运算,p=p-p1,并销毁p1 {reverse(p1);//将B链表的data域置反AddPolyn(p,p1);}void MultiplyPolyn(Polynlist &p,Polyn *p1)//完成多项式相乘运算,p=p*p1,并销毁p1{Polyn *q,*r = NULL,*r1 = NULL;q = p1->next;//A(x)--》bi*A(x)*x^eiCopyPolyn(r,p);AdjustPolyn(r,q->data,q->index);q = q->next;while(q){CopyPolyn(r1,p);AdjustPolyn(r1,q->data,q->index);AdjustPolyn(r1,q->data,q->index);AddPolyn(r,r1);//r1将被销毁r1 = NULL;//必须将r1置空q = q->next;}//r-->p,同时释放r链表DestroyPolyn(p);p = NULL;CopyPolyn(p,r);DestroyPolyn(r);}int main(){int m;Polyn *p=(Polyn*)malloc(sizeof(Polyn));Polyn *p1=(Polyn*)malloc(sizeof(Polyn));Polyn *p2 = NULL,*p3 = NULL;printf("按升幂输⼊多项式A(x),B(x)的系数,指数\n");printf("A(x)的项数:");scanf("%d",&m);CreatPolyn(p,m);printf("A(x)=");PrintPolyn(p);printf("B(x)的项数:");scanf("%d",&m);CreatPolyn(p1,m);printf("B(x)=");PrintPolyn(p1);//保存A,B原始多项式,此处的复制是新开辟结点链表CopyPolyn(p2,p);CopyPolyn(p3,p1);system("pause");system("cls");printf("A(x)=");PrintPolyn(p);printf("B(x)=");PrintPolyn(p1);printf("选择以下⼀种操作⽅式:\n");ShowMenu();do{printf("请输⼊你的选择:");scanf("%d",&m);switch(m){case1:AddPolyn(p,p1);printf("A(x)+B(x)=");PrintPolyn(p);break;case2:SubtractPolyn(p,p1);printf("A(x)-B(x)=");PrintPolyn(p);break;case3:MultiplyPolyn(p,p1);printf("A(x)*B(x)=");PrintPolyn(p);break;default:exit(0);}fflush(stdin);DestroyPolyn(p);p1 = p = NULL;//此时的p、p1为游离指针,必须要置空 CopyPolyn(p,p2);CopyPolyn(p1,p3);}while(1);return0;}运⾏结果截图:按Enter键之后。

一元多项式的定义和运算讲解

一元多项式的定义和运算讲解
定理 2.4.1
令f (x)是F [x]的一个次数大于零的多项式,并且
此处
定理 2.4.2
例 在有理数域上分解多项式 为不可约因式的乘积.容易看出
(2)
一次因式x + 1自然在有理数域上不可约.我们证明, 二次因式 也在有理数域上不可约.不然的话, 将能写成有理数域上两个次数小于2的因式 的乘积,因此将能写成
这个定义的条件也可以用另一种形式来叙述
若多项式 有一个非平凡因式 而 ,那么 与 的次数显然都小于 的次数.反之,若 能写成两个这样的多项式的乘积,那么 有非平凡因式.因此我们可以说:
这里
多项式的减法
2.1.5 多项式加法和乘法的运算规则
(1)加法交换律:
(2)加法结合律:
(3)乘法交换律:
(4)乘法结合律:
(5)乘法对加法的分配律:
注意:
要把一个多项式按“降幂”书写

时,
叫做多项式的首项.
2.1.6 多项式的运算性质
定理
是数环R上两个多项式,并且
定义 2
设 是多项式 与 的一个公因式.若是 能被 与 的每一个公因式整除,那么 叫做 与 的一个最大公因式.
定义 1
的任意两个多项式 与 一定有最大公因式.除一个零次因式外, 与 的最大公因式是唯一确定的,这就是说,若 是 与 的一个最大公因式,那么数域F的任何一个不为零的数 c与 的乘积 ,而且当 与 不全为零多项式时,只有这样的乘积是 与 的最大公因式.
由此得出,


的最大公因式,而
定理 2.3.3
的两个多项式 与 互素的充分且必要条 件是:在 中可以求得多项式 与 ,使

一元多项式相加问题实验报告

一元多项式相加问题实验报告

一元多项式相加问题实验报告一元多项式相加问题一、问题描述通过键盘输入两个形如P 0 +P 1 X 1 +P 2 X 2 +…+P n X 的多项式,经过程序运后在屏幕上输出它们的相加和。

二、数据结构设计一个一元多项式的每一个子项都由“系数-指数”两部分组成,因此可将其抽象为包含系数coef、指数exp、指针域next 构成的链式线性表。

将两个多项式分别存放在两个线性表中,然后经过相加后将所得多项式存放在一个新的线性表中,但是不用再开辟新的存储空间,只依靠结点的移动来构成新的线性表,期间可以将某些不需要的空间回收。

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

具体数据类型定义为:struct node {float coef;//系数域int exp;//指数域struct node *next; }; 三、功能函数设计1、输入多项式的系数和指数初始化多项式的功能模块具体函数为node *in_fun() 此函数的处理较为全面,要求用户按照指数递增的顺序和一定的输入格式输入各个系数不为0 的子项,输入一个子项建立一个相关结点,当遇到输入结束标志时停止输入。

关键步骤具体如下:⑴控制用户按照指数递增的顺序输入r=a; while(r!=q-next){if(y=r-exp){cout“请按照指数递增顺序输入,请重新输入“;cinxy;break;}r=r-next;} 从头开始遍历,若遇到目前输入的指数不是最大时,就跳出循环,让用户重新输入。

⑵当输入的系数为零时,不为其分配存储空间存储while(x==0) { cinxy; continue;} 即若系数为0,不再进行动态分配并新建结点,而是重新提取用户输入的下一个子项的系数和指数,利用continue 进入下一次循环。

⑶初始化完成后将最后一个结点的指针域置为空,并返回该新建链表的首地址。

if(q!=NULL)q-next=NULL;return a; ⑷动态分配空间新建结点存储系数和指数的代码如下:p=new node;p-coef=x;p-exp=y;if(a==NULL) a=p;else q-next=p;q=p; 2、多项式显示功能函数由于系数有正有负,故采取如下处理:对于正数,输出时在前面加“+”,头指针除外;对于负数,直接将系数输出即可,即:p=a;while(p){if(p==a)coutp-coef"*x^"p-else if(p-coef0)coutp-coef"*x^"p-else if(p-coef0)cout"+"p-coef"*x^"p-p=p-next;} 输出的多项式的形式形如:P 1 X^1+P 2 X^2+…+P n X^n 3、多项式相加的功能函数函数为:node *plus_fun(node *a,node *b) 此函数根据在 1 中初始化的两个多项式进行相加运算,并存放在以c 为头指针的一个新链表中。

一元多项式计算(数据结构课程设计)

一元多项式计算(数据结构课程设计)

一元多项式计算(数据结构课程设计)一、系统设计1、算法思想根据一元多项式相加的运算规则:对于两个一元多项式中所有指数相同的项,对应指数相加(减),若其和(差)不为零,则构成“和(差)多项式”中的一项;对于两个一元多项式中所有指数不相同的项,则分别写到“和(差)多项式”中去。

因为多项式指数最高项以及项数是不确定的,因此采用线性链表的存储结构便于实现一元多项式的运算。

为了节省空间,我采用两个链表分别存放多项式a 和多项式b,对于最后计算所得的多项式则利用多项式a进行存储。

主要用到了单链表的插入和删除操作。

(1)一元多项式加法运算它从两个多项式的头部开始,两个多项式的某一项都不为空时,如果指数相等的话,系数就应该相加;相加的和不为零的话,用头插法建立一个新的节点。

P 的指数小于q的指数的话就应该复制q的节点到多项式中。

P的指数大于q的指数的话,就应该复制p节点到多项式中。

当第二个多项式空,第一个多项式不为空时,将第一个多项式用新节点产生。

当第一个多项式空,第二个多项式不为空时,将第二个多项式用新节点产生。

(2)一元多项式的减法运算它从两个多项式的头部开始,两个多项式的某一项都不为空时,如果指数相等的话,系数就相减;相加的和不为零的话,用头插法建立一个新的节点。

p的指数小于q的指数的话,就应该复制q的节点到多项式中。

P的指数大于q的指数的话就应该复制p的节点到多项式中,并且建立的节点的系数为原来的相反数;当第二个多项式空,第一个多项式不为空时,将第一个多项式用新节点产生。

当第一个多项式空,第二个多项式不为空时,将第二个多项式用新节点产生,并且建立的节点的系数为原来的相反数。

2、概要设计(1)主函数流程图:(注:a代表第一个一元二次方程,b代表第二个一元二次方程)(2)一元多项式计算算法用类C语言表示:Typedef struct00{ //项的表示,多项式的项作为LinkList的数据元素Float coef;//细数Int expn;//指数}term,ElemType;//两个类型名:term用于本ADT,ElemType为LinkList的数据对象名Typedef LinkList polynomial://用带表头的节点的有序链表表示多项式//基本操作的函数原型说明Void CreatePolyn(polynomail&P);//输入n的系数和指数,建立表示一元多项式的有序链表P 销毁一元多项式P Void DestroyPolyn(polynomailP);销毁一元多项式PvoidPrintPoly(polynomail P);//打印输入一元多项式PIntPolynLength(polynnomail P);//返回一元多项式P中的项数void CreatPolyn(polynomail&Pa.polunomail&Pb);//完成多项式相加运算,即:Pa=Pa+Pb,并贤惠一元多项式Pb voidSubtractPolyn(polunomail&Papolunomail&Pb);//完成多项式相减运算,即:Pa=Pa-Pb,并销毁一元多项式Pb//基本操作的算法描述Int cmp(tem a,temp b);//依a的指数值<(或=)(或>b的住数值,分别返回-1、0和+1Void CreatePolyn(polynomail&P,int m){//输入m项的系数和指数,建立表示一元多项式的有序链表PInitList(P);h=GetHead(P);E.coef=0.0; e.expn=-1;S erCurElem(h,e);//设置头结点的数据元素For (i=1;i<=m;++i){ //依次输入m个非零项Scanf(e.coef,e.epn);If(!LocateElem(P,e,q,(*cmp)())){//当前链表中不存在该指数项If(MakeNode(s,e))InsFirst(q,s);//生成节点并插入链表}}}//CreatPolun二、详细设计1、算法实现(1)输入一元多项式函数:void shuchu(pnode *head){pnode *p;int one_time=1;p=head;while(p!=NULL) /*如果不为空*/{if(one_time==1){if(p->zhishu==0) /*如果指数为0的话,直接输出系数*/printf("%5.2f",p->xishu); /*如果系数是正的话前面就要加+号*/else if(p->xishu==1||p->xishu==-1)printf("X^%d",p->zhishu); /*如果系数是1的话就直接输出+x*//*如果系数是-1的话就直接输出-x号*/else if(p->xishu>0) /*如果系数是大于0的话就输出+系数x^指数的形式*/ printf("%5.2fX^%d",p->xishu,p->zhishu);else if(p->xishu<0) /*如果系数是小于0的话就输出系数x^指数的形式*/ printf("%5.2fX^%d",p->xishu,p->zhishu);one_time=0;}else{if(p->zhishu==0) /*如果指数为0的话,直接输出系数*/{if(p->xishu>0)printf("+%5.2f",p->xishu); /*如果系数是正的话前面就要加+号*/}else if(p->xishu==1) /*如果系数是1的话就直接输出+x号*/printf("+X^%d",p->zhishu);else if(p->xishu==-1) /*如果系数是-1的话就直接输出-x号*/printf("X^%d",p->zhishu);else if(p->xishu>0) /*如果系数是大于0的话就输出+系数x^指数的形式*/ printf("+%5.2fX^%d",p->xishu,p->zhishu);else if(p->xishu<0) /*如果系数是小于0的话就输出系数x^指数的形式*/printf("%5.2fX^%d",p->xishu,p->zhishu);}p=p->next; /*指向下一个指针*/}printf("\n");}(2)加法函数/*两个多项式的加法运算*/pnode * add(pnode *heada,pnode *headb){pnode *headc,*p,*q,*s,*r; /*headc为头指针,r,s为临时指针,p指向第1个多项式并向右移动,q指向第2个多项式并向右移动*/float x; /*x为系数的求和*/p=heada; /*指向第一个多项式的头*/q=headb; /*指向第二个多项式的头*/headc=(pnode *)malloc(sizeof(pnode)); /*开辟空间*/r=headc;while(p!=NULL&&q!=NULL) /*2个多项式的某一项都不为空时*/{if(p->zhishu==q->zhishu) /*指数相等的话*/{x=p->xishu+q->xishu; /*系数就应该相加*/if(x!=0) /*相加的和不为0的话*/{s=(pnode *)malloc(sizeof(pnode)); /*用头插法建立一个新的节点*/s->xishu=x;s->zhishu=p->zhishu;r->next=s;r=s;}q=q->next;p=p->next; /*2个多项式都向右移*/}else if(p->zhishu<q->zhishu) /*p的系数小于q的系数的话,就应该复制q节点到多项式中*/{s=(pnode *)malloc(sizeof(pnode));s->xishu=q->xishu;s->zhishu=q->zhishu;r->next=s;r=s;q=q->next; /*q向右移动*/}else/*p的系数大于q的系数的话,就应该复制p节点到多项式中*/{s=(pnode *)malloc(sizeof(pnode));s->xishu=p->xishu;s->zhishu=p->zhishu;r->next=s;r=s;p=p->next; /*p向右移动*/}}/*当第2个多项式空,第1个数不为空时,将第一个数剩下的全用新节点产生*/ while(p!=NULL){s=(pnode *)malloc(sizeof(pnode));s->xishu=p->xishu;s->zhishu=p->zhishu;r->next=s;r=s;p=p->next;}/*当第1个多项式空,第1个数不为空时,将第2个数剩下的全用新节点产生*/ while(q!=NULL){s=(pnode *)malloc(sizeof(pnode));s->xishu=q->xishu;s->zhishu=q->zhishu;r->next=s;r=s;q=q->next;}r->next=NULL; /*最后指向空*/headc=headc->next; /*第一个头没有用到*/return headc; /*返回头接点*/}(3)减法函数/*两个多项式的加法运算*/pnode * add(pnode *heada,pnode *headb){pnode *headc,*p,*q,*s,*r; /*headc为头指针,r,s为临时指针,p指向第1个多项式并向右移动,q指向第2个多项式并向右移动*/float x; /*x为系数的求和*/p=heada; /*指向第一个多项式的头*/q=headb; /*指向第二个多项式的头*/headc=(pnode *)malloc(sizeof(pnode)); /*开辟空间*/r=headc;while(p!=NULL&&q!=NULL) /*2个多项式的某一项都不为空时*/{if(p->zhishu==q->zhishu) /*指数相等的话*/{x=p->xishu+q->xishu; /*系数就应该相加*/if(x!=0) /*相加的和不为0的话*/{s=(pnode *)malloc(sizeof(pnode)); /*用头插法建立一个新的节点*/s->xishu=x;s->zhishu=p->zhishu;r->next=s;r=s;}q=q->next;p=p->next; /*2个多项式都向右移*/}else if(p->zhishu<q->zhishu) /*p的系数小于q的系数的话,就应该复制q节点到多项式中*/{s=(pnode *)malloc(sizeof(pnode));s->xishu=q->xishu;s->zhishu=q->zhishu;r->next=s;r=s;q=q->next; /*q向右移动*/}else/*p的系数大于q的系数的话,就应该复制p节点到多项式中*/{s=(pnode *)malloc(sizeof(pnode));s->xishu=p->xishu;s->zhishu=p->zhishu;r->next=s;r=s;p=p->next; /*p向右移动*/}}/*当第2个多项式空,第1个数不为空时,将第一个数剩下的全用新节点产生*/ while(p!=NULL){s=(pnode *)malloc(sizeof(pnode));s->xishu=p->xishu;s->zhishu=p->zhishu;r->next=s;r=s;p=p->next;}/*当第1个多项式空,第1个数不为空时,将第2个数剩下的全用新节点产生*/ while(q!=NULL){s=(pnode *)malloc(sizeof(pnode));s->xishu=q->xishu;s->zhishu=q->zhishu;r->next=s;r=s;q=q->next;}r->next=NULL; /*最后指向空*/headc=headc->next; /*第一个头没有用到*/return headc; /*返回头接点*/}2、程序代码/*一元多项式计算*//*程序功能:能够按照指数降序排列建立并输出多项式;能够完成两个多项式的相加、相减,并将结果输出;*//*提示:输入完一元多项式之后,输入“0 0”结束本一元多项式的输入*//*注意:系数只精确到百分位,最大系数只能为999.99,指数为整数.如果需要输入更大的系数,可以对程序中5.2%f进行相应的修改*/#include<stdio.h>#include<malloc.h>#include<stdlib.h>#include<conio.h>/*建立结构体*/typedef struct pnode{float xishu; /*系数*/int zhishu; /*指数*/struct pnode *next; /*下一个指针*/}pnode;/*用头插法生成一个多项式,系数和指数输入0时退出输入*/pnode * creat()int m;float n;pnode *head,*rear,*s; /*head为头指针,rear和s为临时指针*/ head=(pnode *)malloc(sizeof(pnode));rear=head; /*指向头*/scanf("%f",&n); /*系数*/scanf("%d",&m); /*输入指数*/while(n!=0) /*输入0退出*/{s=(pnode *)malloc(sizeof(pnode));s->xishu=n;s->zhishu=m;s->next=NULL;rear->next=s; /*头插法*/rear=s;scanf("%f",&n); /*输入系数*/scanf("%d",&m); /*输入指数*/}head=head->next; /*第一个头没有用到*/return head;}/*调整多项式*/void tiaozhen(pnode *head){pnode *p,*q,*t;float temp;p=head;while(p!=NULL){q=p;t=q->next;while(t!=NULL){if(t->zhishu>q->zhishu)q=t;t=t->next;}temp=p->xishu;p->xishu=q->xishu;q->xishu=temp;temp=p->zhishu;p->zhishu=q->zhishu;q->zhishu=temp;p=p->next;}/*显示一个多项式*/void shuchu(pnode *head){pnode *p;int one_time=1;p=head;while(p!=NULL) /*如果不为空*/{if(one_time==1){if(p->zhishu==0) /*如果指数为0的话,直接输出系数*/printf("%5.2f",p->xishu); /*如果系数是正的话前面就要加+号*/else if(p->xishu==1||p->xishu==-1)printf("X^%d",p->zhishu); /*如果系数是1的话就直接输出+x*//*如果系数是-1的话就直接输出-x号*/else if(p->xishu>0) /*如果系数是大于0的话就输出+系数x^指数的形式*/ printf("%5.2fX^%d",p->xishu,p->zhishu);else if(p->xishu<0) /*如果系数是小于0的话就输出系数x^指数的形式*/ printf("%5.2fX^%d",p->xishu,p->zhishu);one_time=0;}else{if(p->zhishu==0) /*如果指数为0的话,直接输出系数*/{if(p->xishu>0)printf("+%5.2f",p->xishu); /*如果系数是正的话前面就要加+号*/}else if(p->xishu==1) /*如果系数是1的话就直接输出+x号*/printf("+X^%d",p->zhishu);else if(p->xishu==-1) /*如果系数是-1的话就直接输出-x号*/printf("X^%d",p->zhishu);else if(p->xishu>0) /*如果系数是大于0的话就输出+系数x^指数的形式*/ printf("+%5.2fX^%d",p->xishu,p->zhishu);else if(p->xishu<0) /*如果系数是小于0的话就输出系数x^指数的形式*/ printf("%5.2fX^%d",p->xishu,p->zhishu);}p=p->next; /*指向下一个指针*/}printf("\n");/*两个多项式的加法运算*/pnode * add(pnode *heada,pnode *headb){pnode *headc,*p,*q,*s,*r; /*headc为头指针,r,s为临时指针,p指向第1个多项式并向右移动,q指向第2个多项式并向右移动*/float x; /*x为系数的求和*/p=heada; /*指向第一个多项式的头*/q=headb; /*指向第二个多项式的头*/headc=(pnode *)malloc(sizeof(pnode)); /*开辟空间*/r=headc;while(p!=NULL&&q!=NULL) /*2个多项式的某一项都不为空时*/{if(p->zhishu==q->zhishu) /*指数相等的话*/{x=p->xishu+q->xishu; /*系数就应该相加*/if(x!=0) /*相加的和不为0的话*/{s=(pnode *)malloc(sizeof(pnode)); /*用头插法建立一个新的节点*/s->xishu=x;s->zhishu=p->zhishu;r->next=s;r=s;}q=q->next;p=p->next; /*2个多项式都向右移*/}else if(p->zhishu<q->zhishu) /*p的系数小于q的系数的话,就应该复制q节点到多项式中*/{s=(pnode *)malloc(sizeof(pnode));s->xishu=q->xishu;s->zhishu=q->zhishu;r->next=s;r=s;q=q->next; /*q向右移动*/}else/*p的系数大于q的系数的话,就应该复制p节点到多项式中*/{s=(pnode *)malloc(sizeof(pnode));s->xishu=p->xishu;s->zhishu=p->zhishu;r->next=s;r=s;p=p->next; /*p向右移动*/}}/*当第2个多项式空,第1个数不为空时,将第一个数剩下的全用新节点产生*/ while(p!=NULL){s=(pnode *)malloc(sizeof(pnode));s->xishu=p->xishu;s->zhishu=p->zhishu;r->next=s;r=s;p=p->next;}/*当第1个多项式空,第1个数不为空时,将第2个数剩下的全用新节点产生*/ while(q!=NULL){s=(pnode *)malloc(sizeof(pnode));s->xishu=q->xishu;s->zhishu=q->zhishu;r->next=s;r=s;q=q->next;}r->next=NULL; /*最后指向空*/headc=headc->next; /*第一个头没有用到*/return headc; /*返回头接点*/}/*两个多项式的减法运算*/pnode * sub(pnode *heada,pnode *headb){pnode *headc,*p,*q,*s,*r;float x; /*x为系数相减*/p=heada; /*指向第一个多项式的头*/q=headb; /*指向第二个多项式的头*/headc=(pnode *)malloc(sizeof(pnode)); /*开辟空间*/r=headc;while(p!=NULL&&q!=NULL) /*两个多项式的某一项都不为空时*/{if(p->zhishu==q->zhishu) /*指数相等的话*/{x=p->xishu-q->xishu; /*系数相减*/if(x!=0) /*相减的差不为0的话*/{s=(pnode *)malloc(sizeof(pnode)); /*用头插法建立一个新的节点*/s->xishu=x;s->zhishu=p->zhishu;r->next=s;r=s;}q=q->next;p=p->next; /*2个多项式都向右移*/}else if(p->zhishu<q->zhishu) /*p的系数小于q的系数的话*/{s=(pnode *)malloc(sizeof(pnode));s->xishu=-q->xishu; /*建立的节点的系数为原来的相反数*/s->zhishu=q->zhishu;r->next=s;r=s;q=q->next;}else{s=(pnode *)malloc(sizeof(pnode));s->xishu=p->xishu;s->zhishu=p->zhishu;r->next=s;r=s;p=p->next; /*p向右移动*/}}while(p!=NULL) /*当第2个多项式空,第1个数不为空时,将第一个数剩下的全用新节点产生*/{s=(pnode *)malloc(sizeof(pnode));s->xishu=p->xishu;s->zhishu=p->zhishu;r->next=s;r=s;p=p->next;}while(q!=NULL) /*当第1个多项式空,第1个数不为空时,将第2个数剩下的全用新节点产生*/{s=(pnode *)malloc(sizeof(pnode));s->xishu=-q->xishu; /*建立的节点的系数为原来的相反数*/ s->zhishu=q->zhishu;r->next=s;r=s;q=q->next;}r->next=NULL; /*最后指向空*/headc=headc->next; /*第一个头没有用到*/return headc; /*返回头接点*/}void add_main(){pnode * a,*b,*c;printf("\n输入第一个一元多项式:\n系数指数\n");a=creat();tiaozhen(a);printf("\n输入第二个一元多项式:\n系数指数\n");b=creat();tiaozhen(b);c=add(a,b);printf("第一个一元多项式如下:");shuchu(a);printf("第二个一元多项式如下:");shuchu(b);printf("两式相加如下:");shuchu(c);}void sub_main(){pnode * a,*b,*c;printf("\n输入第一个一元多项式:\n系数指数\n");a=creat();tiaozhen(a);printf("\n输入第二个一元多项式:\n系数指数\n");b=creat();tiaozhen(b);c=sub(a,b);printf("第一个一元多项式如下:");shuchu(a);printf("第二个一元多项式如下:");shuchu(b);printf("两式相减如下:");shuchu(c);}void open(){printf("\n****************************************************\n");printf(" 功能项: * 1 两个一元多项式相加;2 两个一元多项式相减;0 退出*\n");printf("****************************************************\n\n请选择操作: ");}void main(){int choose;open();while(choose!=0){scanf("%d",&choose);getchar();switch(choose){case 0:return;case 1:printf("\n 两个一元多项式相加\n");add_main();choose=-1;open();break;case 2:printf("\n 两个一元多项式相减\n");sub_main();choose=-1;open();break;default:printf("没有该选项!请重新选择操作!\n\n");open();}}}三、测试方案及结果1、测试方案在Visual C++ 6.0环境中调试运行。

完整word版一元多项式求和实验报告范文_

完整word版一元多项式求和实验报告范文_

完整word版一元多项式求和实验报告范文_实验一、线性结构综合应用一、实验题目:顺序表的应用二、实验内容:一元多项式求和。

把任意给定的两个一元多项式P(某),Q(某)输入计算机,计算它们的和并输出计算结果。

三、设计分析:实现要定义的一元多项式应采用链式存储结构。

根据一元多项式相加的运算法则,对于两个多项式中所有指数相同的项,对应系数相加,若其和不为零,则构成新多项式的一项;对于两个多项式中所有指数不同的项,分别复制到新多项式中。

新多项式不必另外生成,而是在原来的两个多项式中摘取结点即可。

采用顺序存储结构存储多项式系数A,使多项式的某些运算变得更简洁。

但在实际使用时,多项式的阶数可能很高,不同的多项式阶数可能相差很大,这使顺序存储结构的最大长度难以确定。

而且,最高次幂与最低次幂项之间缺项很多时,采用顺序存储结构显然十分浪费存储空间,因此,一般情况下多采用链式存储结构来存储高阶多项式。

在用线性链表来存储一个多项式时,多项式中的每个非零项系数对应一个结点,结点由数据元素项和指针组成。

数据元素项中包含系数和指数值,设计中先定义定义数据元素中的数据,其中有指数、系数级指针ne某t等。

并要先构造一元多项式。

在定义输出、删除、合并等模块。

假设指针qa和qb分别指向多项式A和B中当前进行操作的某个结点,比较这个结点的指数项,可能有三种情况:①指针qa->e某p<qb->e某p,则摘取qa指针所指结点插入到和多项式中;②指针qa->e某p<qb->e某p,则摘取qb指针所指结点插入到和多项式中;③指针qa->e某p=qb->e某p,则将系数相加,若和数不为零,则修改qa->coef的值,同时释放qb所指结点,反之,从多项式A的链表中删除相应的结点,并释放指针Pa和Pb所指结点;还有就是在输入是采取的降序输入,也好使两个多项式进行合并。

并输出。

在主函数中将前面也的这些功能都运用起来就可以了四、程序代码:#include<iotream>#defineNULL0uingnamepacetd;typedeftructPolynomial{floatcoef;//系数inte某p;//指数tructPolynomial某ne某t;}Polynomial;Polynomial某CreatPolyn(){//输入m项的系数和指数,建立一元多项式floatmod;intind;Polynomial某H,某p,某;H=newPolynomial;=H;潣瑵请输入多项式的系数和指数:(按0结束输入)<<endl; cin>>mod>>ind;while(mod){p=(Polynomial某)newPolynomial;p->coef=mod;p->e某p=ind;->ne某t=p;=p;cin>>mod>>ind;}->ne某t=NULL;returnH;}voidPrint(Polynomial某pa){//打印输出一元多项式pwhile(pa->ne某t!=NULL){pa=pa->ne某t;cout<<pa->coef<<某某^<<pa->e某p;if(pa->ne某t!=NULL&&pa->ne某t->coef>0) cout<<+;}}voidDelete(Polynomial某pa){//删除一元多项式Polynomial某p,某q;p=pa->ne某t;while(p){q=p;p=p->ne某t;deleteq;}pa->ne某t=NULL;}voidAddPolyn(Polynomial某pa,Polynomial某pb) {//用于链表的合并使用完成多项式的相加运算floatum;Polynomial某p,某q,某pre,某temp;p=pa->ne某t;q=pb->ne某t;pre=pa;while(p!=NULL&&q!=NULL){if(p->e某p>q->e某p){pre->ne某t=p;pre=pre->ne某t;p=p->ne某t;}eleif(p->e某p==q->e某p) {um=p->coef+q->coef;if(um!=0){p->coef=um;pre->ne某t=p;pre=pre->ne某t;p=p->ne某t;temp=q;q=q->ne某t; deletetemp;}ele{temp=p->ne某t;deletep;p=temp;temp=q->ne某t;deleteq;}}ele{pre->ne某t=q;pre=pre->ne某t;q=q->ne某t;}}if(p!=NULL)//将多项式A中剩余的结点加入到和多项式中pre->ne某t=p;elepre->ne某t=q;}intmain(){intc;intt=1;cout<<某某某某某某某某某某某某某某某某某某菜单某某某某某某某某某某某某某某某某某<<endl<<endl;cout<<.创建并显示一元多项式A和B,计算一元多项式A加B并显示和<<endl<<endl;cout<<.退出程序.<<endl;cin>>c;witch(c){cae1:Polynomial某p1,某p2;p1=CreatPolyn();潣瑵一元多项式A是:;Print(p1);cout<<endl;p2=CreatPolyn();潣瑵一元多项式B是:;Print(p2);cout<<endl;AddPolyn(p1,p2);潣瑵一元多项式A加B的和是:;Print(p1);cout<<endl;Delete(p1);break;cae2:t=0;break;}}ytem(paue);return0;}五、测试用例:六、实验总结通过这次实验,对于链表的应用知识有了更加深刻的认识,虽然中间出了很多问题,但是经过调试以后都得以解决。

一元多项式的表示及其运算的研究与实现

一元多项式的表示及其运算的研究与实现

蒋浩钧一元多项式的表示及其运算的研究与实现第1页共27页一元多项式的表示及其运算的研究与实现学生姓名:蒋浩钧指导老师:乐晓波摘要一元多项式计算是用C语言设计一个一元多项式简单计算器。

它能够实现按指数降序排列建立并输出多项式,并且能够完成两个多项式的相加,想减的运算和将其结果输入的功能。

体会链式存存储结构的优缺点和适用性。

了解并掌握数据结构与算法的设计方法,具备初步的独立分析和设计能力;初步掌握软件开发过程的问题分析、系统设计、程序编码、测试等基本方法和技提高综合运用所学的理论知识和方法独立分析和解决问题的能力;加深对常用数据结构的理解,强化学生的逻辑思维能力和动手能力,巩固良好的编程习惯,掌握工程软件设计的基本方法,为后续课程的学习打下坚实基础。

关键词C语言;一元多项式;链式存存储结构;指数降序排列目录1前言--------------------------------------------31.1课程设计目的-----------------------------------3 1.2需求分析----------------------------------------3 2概要设计----------------------------------------42.1一元多项式的数学模型------------------------------4 2.2一元多项式数据结构的构造 ----------------------------------4 2.3系统结构与功能模块流程图 ----------------------------------5 3详细设计----------------------------------------73.1一元多项式的建立-----------------------------73.2一元多项式的显示------------------------------83.3一元多项式的加法运算-------------------------93.4一元多项式的减法运算-------------------------125.5一元多项式的乘法运算-------------------------143.6帮助----------------------------------------16 4调试及运行结果-----------------------------------------17 5设计体会与总结------------------------------------------19 5.1设计体会------------------------------------------19 5.2总结--------------------------------------------20 参考文献-----------------------------------------20 附录:源程序---------------------------------------------211 前言一元多项式算法程序的数据结构是选择用带头结点的单链表存储多项式。

(C语言)加法运算实验报告

(C语言)加法运算实验报告

cout<<"两个多项式之和为:"<<endl;
cout<<"A+B=";
result(add(A,B));
cout<<endl;
return 0;
}
//当 p 不为空时进行循环;
{
PolyLink A,B;
A=Ini_polynode();
B=Ini_polynode();
cout<<"输入第一个多项式:"<<endl;
input(A);
cout<<"A=";
result(A);
cout<<"输入第二个多项式:"<<endl;
input(B);
cout<<"B=";
result(B);
2、 测试结果:
①输入 A=x+3x^6-8x^11
输入 B=6-3x^6+21x^9
输出 A+B=6+x+21x^9-8x^11
②输入 A=x+x^3
输入 B=-x-x^3
输出 A+B=0
③输入 A=x+x^100
输入 B=x^100+x^200
输出 A+B=x+2x^100+x^200
④输入 A=x+x^2+x^3
一元多项式的加法运算
一、 需求分析
1、 程序的基本功能 1 按照指数升序次序,输入并建立多项式 A 与 B。 2 计算多项式 A 与 B 的和,即建立多项式 A+B。 3 按照指数升序次序,输出多项式 A、B、A+B。 2、 输入输出要求: 1 输入多项式;

一元多项式的运算

一元多项式的运算

数据结构课程设计实验报告专业班级:学号:姓名:2011年1月1日题目:一元多项式的运算1、题目描述一元多项式的运算在此题中实现加、减法的运算,而多项式的减法可以通过加法来实现(只需在减法运算时系数前加负号)。

在数学上,一个一元n次多项式P n(X)可按降序写成:P n(X)= P n X^n+ P(n-1)X^(n-1)+......+ P1X+P0它由n+1个系数惟一确定,因此,在计算机里它可以用一个线性表P来表示:P=(P n,P(n-1),......,P1,P0)每一项的指数i隐含在其系数P i的序号里。

假设Q m(X)是一元m次多项式,同样可以用一个线性表Q来表示:Q=(q m,q(m-1),.....,q1,q0)不是一般性,假设吗吗m<n,则两个多想是相加的结果:R n(X)= P n(X)+ Q m(X)很显然,可以对P,Q和R采用顺序存储结构,使得多项式相加的算法定义和实现简单化。

然而,在通常的应用中,多项式的次数可能变化很大而且很高,使得顺序存储结构的最大长度很难确定。

特别是在处理项数少且次数特别高的情况下,对内存空间的浪费是相当大的。

因此,一般情况下,都采用链式存储结构来处理多项式的运算,使得两个线性链表分别表示一元多项式P n(X)和Q m(X),每个结点表示多项式中的一项。

通过分析多项式的特征,不难看出多项式是由单项式构成的,而每个单项式都具有系数和指数,当系数为0时,该项就是去了意义,在计算机内要表示一个多项式,至少具有以下数据信息:系数信息、指数信息和指向下一个单项式的指针。

通过指针,我们就可以把多个单项式连接起来,形成一个多项式。

2、任务要求系数定义的是float型,范围是3.4*10^-38~3.4*10^38;指数定义的是int型,范围是-2147483648~+2147483647;输入多项式系数及指数,系统会自动将系数转化为浮点型。

功能:(1).提示输入数据。

数据结构_一元多项式的表示与相加

数据结构_一元多项式的表示与相加

实验一一元多项式的表示与相加实验目的:1.复习并熟练掌握数据结构所使用的程序设计语言——C语言;2.学会单步跟踪、调试自己的程序;3.加深对线性表特别是链表知识的理解和掌握,并能够运用相关知识来解决相关的具体问题,如一元多项式相加等;程序流程:1.定义一元多项式链表结构体类型;2.输入多项式项数以分配存储空间;3.输入多项式每项的系数和指数,将其插入当前多项式链表。

同时判断是否有与当前节点指数相同的项,若存在,则将两项系数相加合并。

此外,若存在系数为0的项,将其存储空间释放;4.进行多项数加法时,新建一个存储结果的链表,分别将两多项式各项依次插入结果多项式即完成多项式相加运算;5.进行多项数加法时,将减项多项式各项系数化为相反数后进行加法操作,即完成多项式相减运算;6.对x赋值后,将x值代入多项式进行运算得到多项式的值;7.输出多项式。

注意:进行完一次运算以后,应该及时销毁无用多项式以释放空间以便再次应用。

算法及注释:1)定义一元多项式链表结构体类型typedef struct Lnode{float cof; //定义系数int exp; //定义指数struct Lnode *next; //定义指针变量指向下一个节点}Lnode ,*Linklist; //定义新的变量类型2)建立多项式存储线性链表头结点void makehead(Linklist &head){head=(Linklist)malloc(sizeof(Lnode)); //建立新的节点head->exp=-1;head->next=NULL; //指针赋空head->cof=1;}3)将输入的多项式信息存储于节点中void makelnode(Lnode *&p){p=(Lnode*)malloc(sizeof(Lnode)); //建立新的节点printf("Input the cof and exp\n");scanf("%fx%d",&p->cof,&p->exp); //输入多项式底数指数信息p->next=NULL; //指针赋空}4)清除系数为零的多项式节点void clear(Linklist la){Lnode *p,*q; //定义两个指向结构体的指针p=la;q=p->next;while (q){if (fabs(q->cof)<=0.000001) { //判断系数为零p->next=q->next; //指针指向相隔的下一个节点free(q); //销毁系数为零的节点q=p->next; //指针后移一位}else {p=p->next; //p q分别后移一位q=q->next;}}}5)找到多项式中与当前节点同指数项位置int locate(Linklist l,Lnode *&p,Lnode*e){p=l;//标记表头if (!l->next)return(0);while(p&&e->exp!=p->exp){//当p存在且指数不相等时指针后移p=p->next;}if(p)return(p);//当p存在时,返回p地址else {//没找到时寻找出插入位置p=l;while (p->next&&e->exp<=p->next->exp)p=p->next;if (!p->next){p=p;return(0);}return(0);}}6)将多项式节点插入已有多项式链表中,同时完成系数运算void caseinsert(Linklist &l,Lnode *e){Lnode *p;if (locate(l,p,e)){//指数相同项系数相加p->cof += e->cof;free(e);}else{//插入新的项e->next=p->next;p->next=e;}}7)创建新的多项式链表void creat(Linklist &head,int m){Lnode *p;int i;makehead(head);//建立头结点for (i=1;i<=m;i++){p=(Linklist)malloc(sizeof(Linklist));//建立新的多项式单个节点空间makelnode(p);//建立赋值caseinsert(head,p);//将多项式节点插入已有多项式链表中,同时完成系数运算}clear(head);}8)输入多项式项数并创建节点进行存储void input(Linklist &l){int m;printf("Input the Poly numbers\n");scanf("%d",&m);creat(l,m);//建立一个l指向的头指针有m项的多项式链表}9)输出多项式void print(Linklist l){Lnode *p;p=l->next;printf("Poly:%6fx^%d",p->cof,p->exp);p=p->next;while (p){if(p->cof>0) printf("+");//系数正负号if (fabs(p->cof)<=0.000001); break;//不输出系数为零的项printf("%6fx^%d",p->cof,p->exp);p=p->next;//指针后移}printf("\n");}10)进行多项式加法运算void add(Linklist la,Linklist lb,Linklist &lc){ Lnode *p,*q,*q1,*p1;p=la->next;q=lb->next;makehead(lc);//建立一个新的表头while(p){p1=p->next;caseinsert(lc,p);//将多项式节点p插入已有多项式链表lc中,同时完成系数运算p=p1;//指针后移}while(q){q1=q->next;caseinsert(lc,q);//将多项式节点q插入已有多项式链表lc中,同时完成系数运算q=q1;}}11)将减项多项式转化为系数为相反数的多项式便于转化为加法运算void reverse(Linklist &l){Linklist p;p=l->next;while(p){p->cof*=-1;//系数自乘-1p=p->next;}}12)进行多项式减法运算void sub(Linklist la,Linklist lb,Linklist &lc){reverse(lb);add(la,lb,lc);clear(lc);//清除头结点}13)对x赋值进行多项式赋值运算float value(Linklist l,float x){float sum=0,t;int i;Linklist p=l->next;while(p){t=1;for (i=p->exp;i>0;i--)t*=x;sum=sum+t*p->cof;p=p->next;}return(sum);}14)销毁已有多项式,清除已有多项式占用的存储空间void destroy(Linklist la){Lnode *p,*q;p=la;while(p){q=p;p=p->next;free(q);}}15)创建主程序即菜单界面void main(){Linklist l[10];int c,n,m,i;float a;printf("Choose the number to operate:\n");printf(" 1:Creat a Poly\n");printf(" 2:Poly Addition\n");printf(" 3:Poly Substraction\n");printf(" 4:Evaluation\n");printf(" 5:Destroy a Poly\n");printf(" 6:Print a Poly\n");printf(" 0:Exit\n");printf("\nDestroy the Polys after used.\n");printf("\n*use ',' to separate\n");scanf("%d",&c);while (c){switch (c){case 1: printf("Input the Poly number 1~9\n");scanf("%d",&n);input(l[n]);break;case 2: printf(" Input the Poly number to add,and the Poly number stored in\n");scanf("%d,%d,%d",&n,&m,&i);add(l[n],l[m],l[i]);break;case 3: printf(" Input the Poly number to subtract,and the Poly number stored in\n");scanf("%d,%d,%d",&n,&m,&i);sub(l[n],l[m],l[i]);break;case 4: printf("Input the number to operate and the value of x:\n");scanf("%d,%f",&n,&a);printf("%f\n",value(l[n],a));break;case 5: printf("Input the Poly number:\n");scanf("%d",&n);destroy(l[n]);break;case 6: printf(" Input the Poly number:\n");scanf("%d",&n);print(l[n]);case 0: n=0;break;default:printf("ERROR!");}printf("Choose the number to operate:\n");scanf("%d",&c);}printf("OK!\n");程序运行截图:实验总结:这次实验室数据结构第一次上机实验,由于与C语言课程的学习相隔已经一个学期,对C语言有些生疏和遗忘,在编程过程中出现很多错误。

一元多项式的定义和运算

一元多项式的定义和运算

多 问题:5、除了定义之外,判断一个集合是数环 有没有其他简单的方法? 项 式
定理1.1.1:设S是一个非空数集,S是数环的充 高 等 要条件是S中任两个数的差和积仍在S中。 代 二、数域 数 定义2: 设F是一个含有不等零的数的数集,如果F
中任两个数的和、差、积、商(除数不为0)仍在F中, 则称F是一个数域。 定义 2: 设F是一个数环,如果 ① F内含有一个非 1 零数; ② 对 a, b F , 且 b 0 ,则 a b F 则称F是一个数域。 多 例如:有理数集Q,实数集R,复数集C都是数域,
高 等 代 数
第一章 多项式
学时:28学时 教学方法和手段
由于多项式与整数在许多方面有相似之处,因此在建 立多项式分解理论时要注意与整数理论作对比。
基本内容和教学目的
1
本章主要讨论一元多项式的概念和运算,建立多项式 因式分解理论,并讨论与之有密切关系的求根问题。 这是中学有关知识的加深和扩充。
有理数、实数、复数。再比如讨论多项式的因式分 解、方程的根的情况,都跟数的范围有关。
例如
1
x 2 在有理数范围内不能分解,在实数范围内
2
多 项 式
就可以分解。 x2 1 0 在实数范围内没有根,在复数范围内就 有根。等等。
我们目前学习的解析几何,数学分析都是在实数 高 等 范围内来讨论问题的。但在高等代数中,通常不做 代 这样的限制。 在代数中,我们主要考虑一个集合中元素的加减 数
多 项 式
本章的重点和难点
重点:一元多项式的因式分解理论. 难点:最大公因式的概念,多项式的整除,互素和不可约多 项式等概念之间的联系与区别.
§1.1 数环和数域 高 研究数学问题常常需要明确规定所考虑的数的 等 代 范围,学习数学也是如此。 数 比如,先学习自然数,然后整数,再正有理数、

§1.2_一元多项式的定义和运算

§1.2_一元多项式的定义和运算

an 0, bm 0 anbm 0
f x g x 0
f x g x nm
多项式乘法没有零因子。
第一章 多项式
推论1:若 f x g x 0 f x 0或g x 0 证:若f=0或g=0,则必有fg=0。 反之,若 f x 0, g x 0
第一章
多项式
定义2: f x , g x 是两个多项式, f x g x
最高次项, 亦称为首项。 除系数为0的项之外,同次项的系数都相等。 多项式的表法唯一。 方程 a0 a1x an xn 0 是一个条件等式而不是 两个多项式相等。 定义3: 设 f x a0 a1x
k 相乘积的和作为 x 的系数。得:
k f x g x aib j x k 0 i j k 2 3 2 例1.2.3:设 f x 3x 4x 5, g x x 2x x 1
nm
f x g x x 5x 5x 6
f x n.
第一章 多项式
an xn , an 0,
非负整数n称为 f x 的次数,记为:
2 f x 3 x 2x 1, f x 2, 例1.2.2:
f x 3, f x 0
零次多项式:次数为0的多项式即非零常数。 零多项式:系数全为0的多项式。对零多项式不 定义次数,因此,在谈论多项式的次数时,意味着这 个多项式不是零多项式。 首一多项式:首项系数为1的多项式。 二、多项式的运算 定义4: 设 f x a0 a1x
第一章 多项式

数据结构实验报告-一元多项式的加法运算

数据结构实验报告-一元多项式的加法运算

问题描述:设Pn (x)和Qm(x)分别两个一元多项式。

试编写程序实现一元多项式的加法运算。

一、需求分析:1、本程序需要基于线性表的基本操作来实现一元多项式的加法,也可以用数组实现。

2、两个多项式都有键盘输入相应的系数和指数。

3、//第一个多项式为9x15+ 7x8+5x3+3x输入4 //表示第一个多项式的项数9, 15(回车) //表示9x157, 8 (回车)5, 3 (回车)3, 1 (回车)输出9x^15+ 7x^8+5x^3+3x^1//第二个多项式为 -7x8+6x3+2输入3 //表示第二个多项式的项数6, 3(回车) //表示9x15-7, 8(回车)2, 0 (回车)输出-7x^8+ 6x^3+2x^0求和结果9x^15+11x^3+3x^1+ 2x^0二、概要设计:抽象数据类型为实现上述程序的功能,应以整数存储用户的输入,以及计算的结果。

实现多项式的运算,利用数组的方式需开辟一个二维数组,利用链表的方式须创造两个链表。

算法的基本思想数组实现:定义一个结构体数组,p存储系数,q存储指数。

分别输出两次输入的多项式。

将两次输入的多项式的指数按从大到小的顺序进行排列,同时相应的系数要进行交换。

输出时如果进行判断。

如果当前该项与下一项的的系数相同,将两项系数相加后输出,并跳过下一项。

如果不相等,直接输出。

输出时需注意的问题:当系数为0时,该项不输出当系数为负数时,不要再在前面输出+。

程序的流程程序由三个模块组成:输入模块:完成两个多项式的输入。

处理模块:将多项式按其指数大小进行排列。

输出模块:输出合并后的多项式。

三、详细设计算法的具体步骤:数组方法:struct code{int p,q;}a[1000],b[1000];//结构体数组,可以用二维数组代//替for(i=0;i<n;i++){for(j=i+1;j<n;j++){if(a[j].q>a[i].q) {temp=a[j].q;//指数排序a[j].q=a[i].q;a[i].q=temp;temp=a[j].p;//系数跟着变化a[j].p=a[i].p;a[i].p=temp;}}//对输入的指数进行排序,相应的系数跟着变化cout<<a[0].p<<"x^"<<a[0].q; //先输出第一项if(a[i].p>0)else if(a[i].p<0)cout<<a[i].p<<"x^"<<a[i].q;cout<<'+'<<a[i].p<<"x^"<<a[i].q;//完成运算符和其他项的输//出,然后类似于上面,对第二个多项式进行相应的操作。

21一元多项式的定义和运算

21一元多项式的定义和运算

第二章 多项式§2.1一元多项式的定义和运算1.设),(x f )(x g 和)(x h 是实数域上的多项式.证明:若是 (6) 222)()()(x xh x xg x f +=, 那么.0)()()(===x h x g x fFor personal use only in study and research; not for commercial use2.求一组满足(6)式的不全为零的复系数多项式)(),(x g x f 和).(x h 3.证明:!))...(1()1(!)1)...(1()1(!2)1(1n n x x n n x x x x x x nn---=+---+--+-Λ§2.2 多项式的整除性1.求)(x f 被)(x g 除所得的商式和余式: ( i ) ;13)(,14)(234--=--=x x x g x x x f (ii) ;23)(,13)(3235+-=-+-=x x x g x x x x f 2.证明:k x f x )(|必要且只要).(|x f x3.令()()()x g x g x f x f 2121,,),(都是数域F 上的多项式,其中()01≠x f 且()()()()()().|,|112121x g x f x f x f x g x g 证明:()().|22x f x g4.实数q p m ,,满足什么条件时多项式12++mx x 能够整除多项式.4q px x ++ 5.设F 是一个数域,.F a ∈证明:a x -整除.n n a x - 6.考虑有理数域上多项式()()()()()(),121211nkn k nk x x x x x x f ++++++=-++Λ这里k 和n 都是非负整数.证明:()()().11|1n k 1+++++-x x f x x k7.证明:1-d x 整除1-n x 必要且只要d 整除.n §2.3 多项式的最大公因式1. 计算以下各组多项式的最大公因式:( i ) ()();32103,34323234-++=---+=x x x x g x x x x x f(ii) ()().1)21(,1)21()42()22(2234i x i x x g i x i x i x i x x f -+-+=----+-+-+=2. 设()()()()()().,11x g x d x g x f x d x f == 证明:若()()(),),(x d x g x f =且()x f 和()x g 不全为零,则()();1),(11=x g x f 反之,若()(),1),(11=x g x f 则()x d 是()x f 与()x g 的一个最大公因式.3. 令()x f 与()x g 是][x F 的多项式,而d c b a ,,,是F 中的数,并且0≠-bc ad证明:()()()()()()).,(),(x g x f x dg x cf x bg x af =++4. 证明:(i )h g f ),(是fh 和gh 的最大公因式; (ii )),,,,(),)(,(212121212211g g f g g f f f g f g f = 此处h g f ,,等都是][x F 的多项式。

一元多项式相加 数据结构实验报告

一元多项式相加 数据结构实验报告

南昌航空大学实验报告课程名称:数据结构实验名称:实验二线性表的链式存储结构班级:080611 学生姓名:学号:08指导教师评定:签名:题目:设计并实现以下算法:给出用单链表存储多项式的结构,利用后接法生成多项式的单链表结构,实现两个多项式相加的运算,并就地逆置相加后的多项式链式。

一、需求分析1.用户可以根据自己的需求分别输入两个一元多项式,并且能够实现输入的一元多项式的显示。

2.能够完成两个一元多项式的相加功能,而且还能显示相加后的逆置的一元多项式。

3.程序执行的命令包括:(1)构造链表A (2)构造链表B (3)两个链表的相加(4)求链表的长度(5)打印(显示)已有的链表(6)将已相加的链表进行逆序排列二、概要设计⒈为实现上述算法,需要线性表的抽象数据类型:ADT Polynomial {数据对象:D={a i:|a i∈TermSet,i=1…n,n≥0TermSet 中的每个元素包含一个表示系数的实数和表示指数的整数} 数据关系:R1={<a i-1,a i>|a i-1,a i∈D,且a i-1中的指数值< a i中的指数值i=2,…n≥0}基本操作:initlink(& L)操作结果:构造一个空的链表L。

Creatlink(&L,n)操作结果:输入n项的系数和指数,建立一个非空的一元多项式L。

LinkLength(L)初始条件:链表L已经存在。

操作结果:返回一元多项式L中的项数。

Displaylink(L)初始条件:链表L已经存在。

操作结果:打印输出一元多项式L。

Addpolyn(A,B,&C)初始条件:一元多项式A和B已存在。

操作结果:完成多项式相加运算,即:C=A+B,并且带回C。

subtracypolyn(&La,&Lb,)初始条件:一元多项式La和Lb已存在。

操作结果:完成多项式的相减运算La=La+Lb,并且销毁多项式Lb。

一元多项式计算与链表 概述及解释说明

一元多项式计算与链表 概述及解释说明

一元多项式计算与链表概述及解释说明1. 引言1.1 概述在计算机科学和数学领域,一元多项式计算是一个重要的问题。

一元多项式是指包含一个未知数的多项式,它由各个项的系数和指数决定。

而链表作为一种常见的数据结构,具有灵活性和高效性,可以应用于各种问题的解决中。

1.2 文章结构本文将首先对一元多项式计算进行介绍,包括多项式的定义与表示方法、多项式加法运算以及多项式乘法运算。

然后,我们将详细探讨链表的概念、特点以及链表在一元多项式计算中的应用。

接下来,将通过实例演示来解释一元多项式计算,并说明链表结构在多项式计算中的优势。

最后,我们将分享解决一元多项式计算问题时相关的考虑事项与技巧,并对研究内容进行总结,并展望其可能的拓展方向。

1.3 目的本文旨在向读者介绍和解释一元多项式计算与链表之间的关系,并探讨链表在该问题中所起到的作用。

通过深入了解一元多项式及其计算方法,以及链表数据结构原理和应用场景,读者将能够更好地理解一元多项式的计算过程,并了解链表在提高计算效率和灵活性方面的重要作用。

同时,通过分享解决问题时的考虑事项与技巧,本文还有助于读者在实际应用中更好地利用链表结构来解决一元多项式计算问题。

2. 一元多项式计算:2.1 多项式定义与表示方法:一元多项式是由若干个单项式构成的代数表达式。

一个单项式由系数和指数组成,通常可以表示为a*x^b的形式,其中a为系数,x为未知数,b为指数。

而一个多项式则是由多个单项式相加得到。

在计算机中,可以用数组或链表来表示一元多项式。

使用数组时,每个元素可以存储一个单项式的系数和指数;而使用链表时,则可以将每个单项式作为节点存储在链表中。

2.2 多项式加法运算:两个多项式相加时,需要将同一个指数的单项式进行合并并对系数进行相加。

具体步骤如下:- 将两个多项式中所有的不同指数提取出来形成一个集合。

- 遍历集合中的每个指数,在两个多项式中查找该指数对应的单项式。

- 如果某个多项式不存在该指数的单项式,则该指数对应的系数为空。

数据结构一元多项式的运算-无删减范文

数据结构一元多项式的运算-无删减范文

数据结构一元多项式的运算数据结构一元多项式的运算简介一元多项式是数学中常见的概念,用于表示一个变量的多项式表达式。

在计算机科学中,经常需要对一元多项式进行各种运算,如加法、减法、乘法等。

为了实现这些运算,可以使用数据结构来存储和操作一元多项式。

本文将介绍一元多项式的数据结构和常见的运算方法,并给出相应的代码示例。

数据结构一元多项式可以用链表来表示。

每个节点包含两个部分:系数(coefficient)和指数(exponent)。

系数表示该项的权重,指数表示该项的幂次。

链表的每个节点按照指数的升序排列。

以下是一个一元多项式的链表表示的示例:```markdown1.2x^2 + 3.7x^4 - 0.5x^3 -2.1x^1 + 4.0``````markdownNode 1: coefficient=1.2, exponent=2Node 2: coefficient=3.7, exponent=4Node 3: coefficient=-0.5, exponent=3Node 4: coefficient=-2.1, exponent=1Node 5: coefficient=4.0, exponent=0```运算方法加法运算两个一元多项式相加可以按照如下步骤进行:1. 遍历两个链表的节点,分别取出当前节点的系数和指数。

2. 如果两个节点的指数相等,将系数相加,并将其作为结果链表的节点。

3. 如果两个节点的指数不相等,将指数较小的节点插入结果链表,并继续遍历指数较大的节点。

4. 当其中一个链表遍历完后,直接将另一个链表的节点插入结果链表。

以下是加法运算的代码示例:```pythondef addPolynomials(p1, p2):result = Nonetl = Nonewhile p1 is not None and p2 is not None:if p1.exponent == p2.exponent:coef_sum = p1.coefficient + p2.coefficient if coef_sum != 0:node = Node(coef_sum, p1.exponent)if result is None:result = tl = nodeelse:tl.next = nodetl = nodep1 = p1.nextp2 = p2.nextelif p1.exponent > p2.exponent:node = Node(p1.coefficient, p1.exponent) if result is None:result = tl = nodeelse:tl.next = nodetl = nodep1 = p1.nextelse:node = Node(p2.coefficient, p2.exponent) if result is None:result = tl = nodeelse:tl.next = nodetl = nodep2 = p2.nextwhile p1 is not None:node = Node(p1.coefficient, p1.exponent)if result is None:result = tl = nodeelse:tl.next = nodetl = nodep1 = p1.nextwhile p2 is not None:node = Node(p2.coefficient, p2.exponent) if result is None:result = tl = nodeelse:tl.next = nodetl = nodep2 = p2.nextreturn result```减法运算减法运算可以看作加法运算的特殊情况,即将第二个多项式的系数取负数,再进行加法运算。

一元多项式的加减求导运算算法(数据结构算法)

一元多项式的加减求导运算算法(数据结构算法)
{
if(expo1==0)
{
i=1;
cout<<coef1;
}
else if(expo1==1)
{
i=1;
if(coef1==1)
cout<<"X";
else if(coef1==-1)
cout<<"-X";
else
cout<<coef1<<"X";
}
else
{
i=1;
if(coef1==1) cout<<"XA"<<expo1;
temp=h;
h->next =NULL;〃头结点
cout<<"多项式"<<o<<"的项数:";cin»num;
for(i nt i=1;i<=nu m;i++)
{
cout<<"请输入第"<<i<<"项"<<endl; cout<<"系数:";
cin> >coef1;
cout<<"指数:";
cin> >expo1; data=new polyno de; data->coef=coef1;
(2)计算多项式A与B的和,即建立多项式A+B
(3)按照指数升序次序,输出多项式AB、A+B
(4)计算多项式A与B的差,即建立多项式A-B;
(5)计算多项式A的导函数A,。
  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

实验一-一元多项式运算实验一一元多项式的运算1.问题定义及需求分析1.1课题目的和任务问题描述:设计一个一元多项式简单计算器。

实验要求:1)采用顺序表或链表等数据结构。

2)输入并建立多项式。

3)输出运算结果的多项式。

1.2数据形式输入数据形式:通过键盘输入。

输入值的范围:多项式的项数和指数的输入数据为int型,输入值范围为-32768至32767;多项式系数的输入值范围为float型,范围为1.2e-38至3.4e+38。

输出数据形式:输出到显示器。

1.3程序功能实现两个一元多项式之间的加法、减法和乘法运算。

1.4测试数据4 //第一个多项式的项数1 4 //第一项的系数和指数3 3 //第二项的系数和指数-2 2 //第三项的系数和指数6 0 //第四项的系数和指数5 //第二个多项式的项数-3 5 //第一项的系数和指数2 2 //第二项的系数和指数-6 0 //第三项的系数和指数-1 -1 //第四项的系数和指数1.2 -2 //第五项的系数和指数2.概要设计2.1抽象数据类型需要定义一个多项式类型的数据类型,里面包含一个int型的指数和一个float型的系数,再定义一个多项式节点,里面包含一个多项式类型的数据,和一个指向下一个节点的指针。

通过对多项式节点的操作,实现对输入数据的运算。

2.2开始输入第一个多项式的项数创建多项式CreatPolyn()输入第二个多项式的项数创建多项式CreatPolyn()输出第一个多项式PrintPolyn()选择操作Menu()加法运算AddPolyn()减法运算SubtractPolyn()乘法运算MultiplyPolyn()输出运算后的多项式PrintPolyn()结束输出第一个多项式PrintPolyn()1加法运算2减法运算3乘法运算3.详细设计3.1存储结构实现多项式结构体:typedef struct{float coef;int expn;}Poly;typedef struct LNode{Poly data;struct LNode* next;}LNode,*LinkList;多项式类型的定义:typedef LinkList polynomial;3.2负责模块的伪码算法(1)int MultiplyPolyn(polynomial& a,polynomial& b){//多项式相乘 if(a,b中均没有项){return 0;}c=(polynomial)malloc(sizeof(LNode));//开辟一个c储存相乘结果 c->next=NULL;ha=a->next;//ha为a中的项hb=b->next;//hb为b中的项for(;hb不空;下一项){//将a中第一项与b中所有项相乘ha的系数*hb的系数;ha的指数*hb的指数;开辟一个新节点E,将数据存入,并把E连到c后}Sort(c);//对c中多项式排序ha=ha->next;//ha指向下一个项while(ha!=NULL){//将a中第二项与b中所有项相乘,存入d,然后将c和d相加得到新的c,再以此对a中其余各项做相同操作,最终得到乘法运算后的chb=b->next;//hb为b的第一项d=(polynomial)malloc(sizeof(LNode));//开辟一个d储存相乘结果d->next=NULL;for(;hb不空;下一项){//将a中第一项与b中所有项相乘 ha的系数*hb的系数;ha的指数*hb的指数;开辟一个新节点E,将数据存入,并把E连到d后;}Sort(d);//对d中多项式排序ha=ha->next;//ha 指向下一项AddPolyn(c,d);//将c ,d 相加得到新的c}t=a;a=c;//a 指向运算结果DestroyPolyn(b);//销毁初始的两个多项式DestroyPolyn(t);}(2)void DestroyPolyn(polynomial& L){//销毁多项式while(L!=NULL){p=L;L=L->next;//指向后一项free(p);}}(3)void Sort(polynomial& L){//对多项式的指数进行冒泡排序 for(多项式长度){for(j=L;j->next->next!=NULL;j=j->next){if(j->next 指数 <j->next->next 指数){//将大的冒到前面 p=j->next;q=j->next->next;p->next=q->next;q->next=p;j->next=q;}}}}4. 调试分析4.1问题分析与解决方法(1)多项式相乘对于多项式相乘,考虑到两个一元多项式的相乘,可以利用两个一元多项式相加的算法来实现,因为乘法运算可以分解为一系列的加法运算,所以只需循环执行加法运算,就可以完成多项式的相乘。

例如A (x )和B (x )为一元多项式,则有:()()()()()11121n ie e e n ne i i M x A x B x A x b x b x b x b A x x ==⨯⎡⎤=⨯+++⎣⎦=∑L其中,每一项都是一个一元多项式。

(2)销毁多项式销毁多项式只需要判断多项式中的项是否为空,不为空就将指针后移,然后释放刚才的储存空间,当为空时结束循环。

(3)对多项式各项进行排序通过冒泡排序实现多现实各项的指数的排序,冒泡排序的实现过程为:多项式中有多少项就进行多少次的排序,第一次排序遍历一遍所有项,进行比较大小,将最大的项调整到链表最前端,然后依次遍历,排完所有项。

4.2算法的时空分析(1)多项式相乘假设多项式a长度为m,多项式b长度为n,因为需要对两个表中的所O mn,需要建立两个临时表c,d 有元素进行操作,所以时间复杂度为()O n。

来存储运算数据,因此空间复杂度为()(2)销毁多项式O n,空间复杂度为()1O。

时间复杂度为()(3)冒泡排序时间复杂度为()2O n,空间复杂度为()1O。

4.3算法的改进设想对于多项式中项的排序,可以采用更高效的排序算法来实现,因为输入多项式中不含有指数相同的项(指数相同的项在运算中会被合并),因此可以采用时间性能更好的快速排序来实现。

4.4经验和体会在算法设计中,有很多问题是可以相互转化的,例如对于乘法运算的算法设计,因为乘法源自于加法,所以可以将求乘法的问题转化为求一系列加法的问题,从而使问题得到简化,更有利于解决。

因此,在编程过程中,应当多注意事物之间的内在联系,从而抽丝剥茧,简化问题,有利于问题的求解。

5.使用说明按照屏幕提示,通过键盘输入数据,数据与数据之间用空格隔开,一组数据输入完毕后,回车结束。

6.测试结果(截屏)(1)多项式相乘(2)多项式排序(冒泡排序)7.附录7.1个人负责模块的程序代码int MultiplyPolyn(polynomial& a,polynomial& b){//多项式相乘//将a的每项分别和b所有项相乘,再将它们相加void Sort(polynomial& L);//函数声明 void DestroyPolyn(polynomial& );polynomial ha=NULL,hb=NULL,c=NULL; Poly e;if(a->next==NULL||b->next==NULL){return 0;}//若多项式中无项,则返回c=(polynomial)malloc(sizeof(LNode));//开辟c,存储第一次运算结果c->next=NULL;ha=a->next;hb=b->next;for(;hb!=NULL;hb=hb->next){//将b中每项都与a的第一项相乘e.coef=(ha->data.coef)*(hb->data.coef);e.expn=(ha->data.expn)+(hb->data.expn); polynomial E=NULL;E=(polynomial)malloc(sizeof(LNode));E->data.coef=e.coef;E->data.expn=e.expn;E->next=c->next;c->next=E;//将每项结果保存在c 中}Sort(c);//对c中项的指数进行排序处理ha=ha->next;//指向下一项while(ha!=NULL){//将a中其余各项分别与b中各项相乘hb=b->next;polynomial d;d=(polynomial)malloc(sizeof(LNode));d->next=NULL;for(;hb!=NULL;hb=hb->next){//用d储存a 中后一项和b中所有项的乘积e.coef=(ha->data.coef)*(hb->data.coef);e.expn=(ha->data.expn)+(hb->data.expn); polynomial E=NULL;E=(polynomial)malloc(sizeof(LNode));E->data.coef=e.coef;E->data.expn=e.expn;E->next=d->next;d->next=E;}Sort(d);ha=ha->next;AddPolyn(c,d);//将c,d两项相加,得到合并后的c}polynomial t=a;a=c;DestroyPolyn(b);//销毁临时存储空间 DestroyPolyn(t);return 1;}void DestroyPolyn(polynomial& L){//销毁线性表while(L!=NULL){polynomial p;p=L;L=L->next;free(p);}}void Sort(polynomial& L){//冒泡排序polynomial i,j;for(i=L;i->next!=NULL;i=i->next){//总次数for(j=L;j->next->next!=NULL;j=j->next){ //第一趟if(j->next->data.expn<j->next->next->da ta.expn){//比较大小,将大的冒到前面 polynomial p,q;p=j->next;q=j->next->next; p->next=q->next; q->next=p;j->next=q;}}}}7.2程序全部代码#include<stdio.h>#include<iostream>#include<stdlib.h>#define TRUE 1;#define FALSE 0;using namespace std;typedef struct{float coef;int expn;}Poly;typedef struct LNode{Poly data;struct LNode* next;}LNode,*LinkList;typedef LinkList polynomial;int main(){//主函数//函数声明void CreatPolyn(polynomial& ,int ); void DestroyPolyn(polynomial& );void const PrintPolyn(polynomial ); intAddPloyn(polynomial& ,polynomial& );intSubtractPloyn(polynomial& ,polynomial& );intMultiplyPloyn(polynomial& ,polynomial& );voidMenu(polynomial& ,polynomial& );//定义int n=1;while(n>=0){polynomial a;polynomial b;system("cls");printf("请输入第一个多项式的项数(输入负数退出):");scanf("%d",&n);if(n<0)exit(0);CreatPolyn(a,n);PrintPolyn(a);printf("请输入第二个多项式的项数(输入负数退出):");scanf("%d",&n);if(n<0)exit(0);CreatPolyn(b,n);PrintPolyn(b);//菜单Menu(a,b);//销毁线性表DestroyPolyn(a);}return 0;}void Menu(polynomial& a,polynomial& b){//菜单intAddPolyn(polynomial& ,polynomial& );intSubtractPolyn(polynomial& ,polynomial& );intMultiplyPolyn(polynomial& ,polynomial& );void const PrintPolyn(polynomial ); int n=0;printf("1.多项式相加\n2.多项式相减\n3.多项式相乘\n");scanf("%d",&n);switch(n){case 1:AddPolyn(a,b);printf("Answer= ");PrintPolyn(a);system("pause");break;case 2:SubtractPolyn(a,b);printf("Answer= ");PrintPolyn(a);system("pause");break;case 3:if(MultiplyPolyn(a,b)){ printf("Answer= ");PrintPolyn(a);}else printf("Answer= 0\n");system("pause");break;default:break;}}void CreatPolyn(polynomial& L,int n){//创建多项式void Sort(polynomial& L);L=(polynomial)malloc(sizeof(LNode));L->next=NULL;Poly e;int i=1;for(;n>0;n--,i++){printf("请输入第%d",i);printf("项的系数和指数:");scanf("%f%d",&e.coef,&e.expn); polynomial E=NULL;E=(polynomial)malloc(sizeof(LNode));E->data.coef=e.coef;E->data.expn=e.expn;E->next=L->next;L->next=E;}Sort(L);}int SubtractPolyn(polynomial&Pa,polynomial &Pb){//多项式减法:Pa=Pa-Pbpolynomial ha=NULL,hb=NULL,p=NULL; ha=Pa;hb=Pb;if(ha->next==NULL){Pa=Pb;free(ha);return 0;}else{while(hb->next!=NULL){if(ha->next->data.expn<hb->next->data.e xpn){polynomial p,q;p=hb->next;q=p->next;p->data.coef=0-p->data.coef;p->next=ha->next;ha->next=p;hb->next=q;ha=ha->next;}elseif(ha->next->data.expn==hb->next->data. expn){ha->next->data.coef=ha->next->data.coef -hb->next->data.coef;p=hb->next;hb->next=hb->next->next;free(p);}else{ha=ha->next;if(ha->next==NULL){hb->next->data.coef=0-hb->next->data.co ef;ha->next=hb->next; hb->next=NULL;free(hb);}}}}return 0;}void const PrintPolyn(polynomial P) //输出多项式{polynomial a;a=P->next;//开始输出while(a->next){printf("%gx^%d+",a->data.coef,a->data.expn);a=a->next;}//输出最后一个printf("%gx^%d\n",a->data.coef,a->data. expn);}int AddPolyn(polynomial &Pa,polynomial &Pb)//多项式加法:Pa=Pa+Pb{polynomial ha=NULL,hb=NULL,p=NULL;ha=Pa;hb=Pb;if(ha->next==NULL){Pa=Pb;free(ha);return 0;}else{while(hb->next!=NULL){if(ha->next->data.expn<hb->next->data.e xpn){polynomial p,q;p=hb->next;q=p->next;p->next=ha->next;ha->next=p;hb->next=q;ha=ha->next;}elseif(ha->next->data.expn==hb->next->data. expn){ha->next->data.coef=ha->next->data.coef +hb->next->data.coef;p=hb->next;hb->next=hb->next->next;free(p);}else{ha=ha->next;if(ha->next==NULL){ha->next=hb->next;hb->next=NULL;free(hb);}}}}return 0;}int MultiplyPolyn(polynomial& a,polynomial& b){//多项式相乘void Sort(polynomial& L);void DestroyPolyn(polynomial& );polynomial ha=NULL,hb=NULL,c=NULL; Poly e;if(a->next==NULL||b->next==NULL){return 0;}c=(polynomial)malloc(sizeof(LNode));c->next=NULL;ha=a->next;hb=b->next;for(;hb!=NULL;hb=hb->next){e.coef=(ha->data.coef)*(hb->data.coef);e.expn=(ha->data.expn)+(hb->data.expn); polynomial E=NULL;E=(polynomial)malloc(sizeof(LNode));E->data.coef=e.coef;E->data.expn=e.expn;E->next=c->next;c->next=E;}Sort(c);ha=ha->next;while(ha!=NULL){hb=b->next;polynomial d;d=(polynomial)malloc(sizeof(LNode));d->next=NULL;for(;hb!=NULL;hb=hb->next){e.coef=(ha->data.coef)*(hb->data.coef);e.expn=(ha->data.expn)+(hb->data.expn); polynomial E=NULL;E=(polynomial)malloc(sizeof(LNode));E->data.coef=e.coef;E->data.expn=e.expn;E->next=d->next;d->next=E;}Sort(d);ha=ha->next;AddPolyn(c,d);}polynomial t=a;a=c;DestroyPolyn(b);DestroyPolyn(t);return 1;}void DestroyPolyn(polynomial& L){//销毁线性表while(L!=NULL){polynomial p;p=L;L=L->next;free(p);}}void Sort(polynomial& L){//冒泡排序polynomial i,j;for(i=L;i->next!=NULL;i=i->next){ for(j=L;j->next->next!=NULL;j=j->next){if(j->next->data.expn<j->next->next->da ta.expn){polynomial p,q;p=j->next;q=j->next->next; p->next=q->next; q->next=p;j->next=q;}}}}。

相关文档
最新文档