实验一一元多项式运算.docx
- 文档编号:23880810
- 上传时间:2023-05-21
- 格式:DOCX
- 页数:21
- 大小:118.85KB
实验一一元多项式运算.docx
《实验一一元多项式运算.docx》由会员分享,可在线阅读,更多相关《实验一一元多项式运算.docx(21页珍藏版)》请在冰豆网上搜索。
实验一一元多项式运算
实验一一元多项式的运算
1.问题定义及需求分析
1.1课题目的和任务
问题描述:
设计一个一元多项式简单计算器。
实验要求:
1)采用顺序表或链表等数据结构。
2)输入并建立多项式。
3)输出运算结果的多项式。
1.2数据形式
输入数据形式:
通过键盘输入。
输入值的围:
多项式的项数和指数的输入数据为int型,输入值围为-32768至32767;多项式系数的输入值围为float型,围为1.2e-38至3.4e+38。
输出数据形式:
输出到显示器。
1.3程序功能
实现两个一元多项式之间的加法、减法和乘法运算。
1.4测试数据
4//第一个多项式的项数
14//第一项的系数和指数
33//第二项的系数和指数
-22//第三项的系数和指数
60//第四项的系数和指数
5//第二个多项式的项数
-35//第一项的系数和指数
22//第二项的系数和指数
-60//第三项的系数和指数
-1-1//第四项的系数和指数
1.2-2//第五项的系数和指数
2.概要设计
2.1抽象数据类型
需要定义一个多项式类型的数据类型,里面包含一个int型的指数和一个float型的系数,再定义一个多项式节点,里面包含一个多项式类型的数据,和一个指向下一个节点的指针。
通过对多项式节点的操作,实现对输入数据的运算。
2.2主程序流程及各模块之间的调用关系
3.详细设计
3.1存储结构实现
多项式结构体:
typedefstruct{
floatcoef;
intexpn;
}Poly;
typedefstructLNode{
Polydata;
structLNode*next;
}LNode,*LinkList;
多项式类型的定义:
typedefLinkListpolynomial;
3.2负责模块的伪码算法
(1)intMultiplyPolyn(polynomial&a,polynomial&b){//多项式相乘
if(a,b中均没有项){return0;}
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中其余各项做相同操作,最终得到乘法运算后的c
hb=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)voidDestroyPolyn(polynomial&L){//销毁多项式
while(L!
=NULL){
p=L;
L=L->next;//指向后一项
free(p);
}
}
(3)voidSort(polynomial&L){//对多项式的指数进行冒泡排序
for(多项式长度){
for(j=L;j->next->next!
=NULL;j=j->next){
if(j->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)为一元多项式,则有:
其中,每一项都是一个一元多项式。
(2)销毁多项式
销毁多项式只需要判断多项式中的项是否为空,不为空就将指针后移,然后释放刚才的储存空间,当为空时结束循环。
(3)对多项式各项进行排序
通过冒泡排序实现多现实各项的指数的排序,冒泡排序的实现过程为:
多项式中有多少项就进行多少次的排序,第一次排序遍历一遍所有项,进行比较大小,将最大的项调整到链表最前端,然后依次遍历,排完所有项。
4.2算法的时空分析
(1)多项式相乘
假设多项式a长度为m,多项式b长度为n,因为需要对两个表中的所有元素进行操作,所以时间复杂度为
,需要建立两个临时表c,d来存储运算数据,因此空间复杂度为
。
(2)销毁多项式
时间复杂度为
,空间复杂度为
。
(3)冒泡排序
时间复杂度为
,空间复杂度为
。
4.3算法的改进设想
对于多项式中项的排序,可以采用更高效的排序算法来实现,因为输入多项式中不含有指数相同的项(指数相同的项在运算中会被合并),因此可以采用时间性能更好的快速排序来实现。
4.4经验和体会
在算法设计中,有很多问题是可以相互转化的,例如对于乘法运算的算法设计,因为乘法源自于加法,所以可以将求乘法的问题转化为求一系列加法的问题,从而使问题得到简化,更有利于解决。
因此,在编程过程中,应当多注意事物之间的在联系,从而抽丝剥茧,简化问题,有利于问题的求解。
5.使用说明
按照屏幕提示,通过键盘输入数据,数据与数据之间用空格隔开,一组数据输入完毕后,回车结束。
6.测试结果(截屏)
(1)多项式相乘
(2)多项式排序(冒泡排序)
7.附录
7.1个人负责模块的程序代码
intMultiplyPolyn(polynomial&a,polynomial&b){//多项式相乘
//将a的每项分别和b所有项相乘,再将它们相加
voidSort(polynomial&L);//函数声明
voidDestroyPolyn(polynomial&);
polynomialha=NULL,hb=NULL,c=NULL;
Polye;
if(a->next==NULL||b->next==NULL){return0;}//若多项式中无项,则返回
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);
polynomialE=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;
polynomiald;
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);
polynomialE=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
}
polynomialt=a;
a=c;
DestroyPolyn(b);//销毁临时存储空间
DestroyPolyn(t);
return1;
}
voidDestroyPolyn(polynomial&L){//销毁线性表
while(L!
=NULL){
polynomialp;
p=L;
L=L->next;
free(p);
}
}
voidSort(polynomial&L){//冒泡排序
polynomiali,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
//比较大小,将大的冒到前面
polynomialp,q;
p=j->next;
q=j->next->next;
p->next=q->next;
q->next=p;
j->next=q;
}
}
}
}
7.2程序全部代码
#include
#include
#include
#defineTRUE1;
#defineFALSE0;
usingnamespacestd;
typedefstruct{
floatcoef;
intexpn;
}Poly;
typedefstructLNode{
Polydata;
structLNode*next;
}LNode,*LinkList;
typedefLinkListpolynomial;
intmain(){//主函数
//函数声明
voidCreatPolyn(polynomial&,int);
voidDestroyPolyn(polynomial&);
voidconstPrintPolyn(polynomial);
intAddPloyn(polynomial&,polynomial&);
intSubtractPloyn(polynomial&,polynomial&);
intMultiplyPloyn(polynomial&,polynomial&);
voidMenu(polynomial&,polynomial&);
//定义
intn=1;
while(n>=0){
polynomiala;
polynomialb;
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);
}
return0;
}
voidMenu(polynomial&a,polynomial&b){//菜单
intAddPolyn(polynomial&,polynomial&);
intSubtractPolyn(polynomial&,polynomial&);
intMultiplyPolyn(polynomial&,polynomial&);
voidconstPrintPolyn(polynomial);
intn=0;
printf("1.多项式相加\n2.多项式相减\n3.多项式相乘\n");
scanf("%d",&n);
switch(n){
case1:
AddPolyn(a,b);
printf("Answer=");
PrintPolyn(a);
system("pause");
break;
case2:
SubtractPolyn(a,b);
printf("Answer=");
PrintPolyn(a);
system("pause");
break;
case3:
if(MultiplyPolyn(a,b)){
printf("Answer=");
PrintPolyn(a);
}
elseprintf("Answer=0\n");
system("pause");
break;
default:
break;
}
}
voidCreatPolyn(polynomial&L,intn){//创建多项式
voidSort(polynomial&L);
L=(polynomial)malloc(sizeof(LNode));
L->next=NULL;
Polye;
inti=1;
for(;n>0;n--,i++){
printf("请输入第%d",i);
printf("项的系数和指数:
");
scanf("%f%d",&e.coef,&e.expn);
polynomialE=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);
}
intSubtractPolyn(polynomial&Pa,polynomial&Pb){//多项式减法:
Pa=Pa-Pb
polynomialha=NULL,hb=NULL,p=NULL;
ha=Pa;
hb=Pb;
if(ha->next==NULL){
Pa=Pb;
free(ha);
return0;
}
else{
while(hb->next!
=NULL)
{
if(ha->next->data.expn
polynomialp,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.coef;
ha->next=hb->next;
hb->next=NULL;
free(hb);
}
}
}
}
return0;
}
voidconstPrintPolyn(polynomialP)
//输出多项式
{
polynomiala;
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);
}
intAddPolyn(polynomial&Pa,polynomial&Pb)
//多项式加法:
Pa=Pa+Pb
{
polynomialha=NULL,hb=NULL,p=NULL;
ha=Pa;
hb=Pb;
if(ha->next==NULL){
Pa=Pb;
free(ha);
return0;
}
else{
while(hb->next!
=NULL)
{
if(ha->next->data.expn
polynomialp,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);
}
}
}
}
return0;
}
intMultiplyPolyn(polynomial&a,polynomial&b){//多项式相乘
voidSort(polynomial&L);
voidDestroyPolyn(polynomial&);
polynomialha=NULL,hb=NULL,c=NULL;
Polye;
if(a->next==NULL||b->next==NULL){return0;}
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);
polynomialE=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;
polynomiald;
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);
polynomialE=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);
}
polynomialt=a;
a=c;
DestroyPolyn(b);
DestroyPolyn(t);
return1;
}
voidDestroyPolyn(polynomial&L){//销毁线性表
while(L!
=NULL){
polynomialp;
p=L;
L=L->next;
free(p);
}
}
voidSort(polynomial&L){//冒泡排序
polynomiali,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
polynomialp,q;
p=j->next;
q=j->next->next;
p->next=q->next;
q->next=p;
j->next=q;
}
}
}
}
- 配套讲稿:
如PPT文件的首页显示word图标,表示该PPT已包含配套word讲稿。双击word图标可打开word文档。
- 特殊限制:
部分文档作品中含有的国旗、国徽等图片,仅作为作品整体效果示例展示,禁止商用。设计者仅对作品中独创性部分享有著作权。
- 关 键 词:
- 实验 一一 多项式 运算