一元多项式计算-数据结构设计报告
一元多项式相加 数据结构实验报告
南昌航空大学实验报告课程名称:数据结构实验名称:实验二线性表的链式存储结构班级: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设计要求 (1)1.2设计内容 (1)2 概要设计 (1)2.1程序主要流程 (1)3 详细设计 (3)3.1源程序 (3)4 调试分析 (8)5 总结 (9)6 致谢 (10)参考文献 (11)1 设计内容和要求1.1 设计要求编写一个实现多项式相加和相减的程序。
1、首先,根据键盘输入的一元实系数多项式的系数与指数序列,对多项式进行初始化,并按未知数x的降幂形式输出多项式的合理表示。
2、对于从键盘输入的任意两个一元多项式,正确计算它们的和以及差的多项式,并输出结果。
1.2 设计内容利用单链表表示一元多项式,然后实现各个项的系数和指数的输入,并且进行建立和输出,以及实现各个一元多项式之间的相加和相乘的操作。
2 概要设计实现的方法是先定义多项式结点的结构,该多项式每个结点由三个元素:输入的系数、输入的指数、以及指向下一个结点的指针构成。
该链表采用链式存储结构。
然后通过多次的输入,依次得到两个一元多项式的各个项的系数与指数。
该输入以零结尾。
然后通过对结点的判断是否为零后,进行相加或者终止的操作。
再初始化一个链表LC,将LC的各项系数和指数的指针指向LA+LB所得的结果的值,完成了最后的输出。
2.1程序主要流程建立链表,将多项式的系数与数指数作为链表节点的数据;指示输入两个多项式的数据,分别存在LA与LB中;利用Getlength(PotyNode *L)函数计算出LA与LB的表长;使用循环语句进行两链表的相应数据相加,并将所得到的新链表存放到LC中;打印输出。
如图2-1就是程序主流程图。
在上交资料中请写明:存储结构、多项式相加的基本过程的算法(可以使用程序流程图)、源程序、测试数据和结果、算法的时间复杂度、另外可以提出算法的改进方法。
要求可以按照降指数次序进行排列,结合数据结构中排序的相关知识,运用相应函数实现,实现两个多项式的加减运算。
在此要建立多项式运算的相关规则。
数据结构课程设计报告一元多项式的计算
一元多项式的计算一、 需求分析建立一元多项式并按照指数降序排列输出多项式,将一元多项式输入并存储在内存中,能够完成两个多项式的加减运算并输出结果二、 概要设计存储结构:一元多项式的表示在计算机内可以用链表来表示,为了节省存储空间,只存储多项式中系数非零的项。
链表中的每一个结点存放多项式的一个系数非零项,它包含三个域,分别存放该项的系数、指数以及指向下一个多项式项结点的指针。
创建一元多项式链表,对一元多项式的运算中会出现的各种可能情况进行分析,实现一元多项式的相加、相减操作。
基本算法: 1、输入输出(1)功能:将要进行运算的多项式输入输出。
(2)数据流入:要输入的多项式的系数与指数。
(3)数据流出:合并同类项后的多项式。
(4)程序流程图:多项式输入流程图如图1所示。
(5)测试要点:输入的多项式是否正确,若输入错误则重新输入开始 申请结点空间输入多项式各项的系数 x, 指数 y输出已输入的多项式合并同类项结束否是是否输入正确图表 12、多项式的加法(1)功能:将两多项式相加。
(2)数据流入:输入函数。
(3)数据流出:多项式相加后的结果。
(4)程序流程图:多项式的加法流程图如图2所示。
(5)测试要点:两多项式是否为空,为空则提示重新输入,否则,进行运算。
图表 2开始 定义存储结果的空链 r是否输出存储多项式的和的链r结束 是 否同指数项系数相加后存入r 直接把p 中各项存入r直接把q 中各项存入r存储多项式2的空链Q 是否为空存储多项式1的空链P 是否为空合并同类项3、多项式的减法(1)功能:将两多项式相减。
(2)数据流入:调用输入函数。
(3)数据流出:多项式相减后的结果。
(4)程序流程图:多项式的减法流程图如图3所示。
(5)测试要点:两多项式是否为空,为空则提示重新输入,否则,进行运算。
开始定义存储结果的空链是否合并同类项结束是 否同指数项系数相加后存入r把p 中各项系数改变符号后存入直接把q 中各项存入r存储多项式2的空链Q 是否为空 存储多项式1的空链P 是否为空输出存储多项式图表 3三、详细设计#include<stdio.h>#include<malloc.h>#include<stdlib.h>typedef struct Polynomial{float coef;int expn;struct Polynomial *next;}*Polyn,Polynomial;/**************合并同类项********************/ void Insert(Polyn p,Polyn h){if(p->coef==0) //系数为0的话释放结点free(p);else //如果系数不为0{Polyn q1,q2;q1=h;q2=h->next;while(q2&&p->expn<q2->expn)//查找插入位置{q1=q2;q2=q2->next;}if(q2&&p->expn==q2->expn)//将指数相同相合并{q2->coef+=p->coef;free(p);if(!q2->coef) //系数为0的话释放结点{q1->next=q2->next;free(q2);}}else{ //指数为新时将结点插入p->next=q2;q1->next=p;}}}/*****************合并同类项,并按升幂排序*****************/ Polyn HeBing(Polyn &L){Polyn p1,p2,p3,p4,p5,p6;float t1;int t2;p1=L->next;while(p1!=NULL) //非递减顺序排列{p2=p1->next;while(p2!=NULL){if(p1->expn>p2->expn){t1=p1->coef;t2=p1->expn;p1->coef=p2->coef;p1->expn=p2->expn;p2->coef=t1;p2->expn=t2;}p2=p2->next;}p1=p1->next;}p3=L->next;while(p3!=NULL) //合并同类项{p4=p3->next;while(p4!=NULL){if(p3->expn==p4->expn){p3->coef=p3->coef+p4->coef;p3->next=p4->next;free(p4);p4=p3->next;}elsep4=p4->next;}p3=p3->next;}p5=L;while(p5->next!=NULL) //删除零项{p6=p5->next;if(p6->coef==0){p5->next=p6->next;free(p6);}p5=p5->next;}return L;}/*****************建立一个多项式****************/ Polyn CreatPolyn(Polyn &p){Polyn h,s;p=(Polyn)malloc(sizeof(struct Polynomial));if(!p)exit(1);p->coef=0;p->expn=-1;p->next=NULL;h=p;scanf("%f%d",&p->coef,&p->expn);while(p->coef!=0||p->expn!=0)//输入数据{s=(Polyn)malloc(sizeof(struct Polynomial));if(!s)exit(1);s->coef=p->coef;s->expn=p->expn;h->next=s;h=s;scanf("%f%d",&p->coef,&p->expn);}h->next=NULL;HeBing(p);return p;}/******************多项式的销毁***************/ void DestroyPolyn(Polyn p){Polyn q1,q2;q1=p->next;q2=q1->next;while(q1->next){free(q1);q1=q2;q2=q2->next;}}/*************输出多项式**************/void PrintPolyn(Polyn P){Polyn q=P->next;int flag=1;if(!q){putchar('0');printf("\n");return;} //若多项式为空,输出0while (q){if(q->coef>0&&flag!=1) putchar('+'); //系数大于0且不是第一项if(q->coef!=1&&q->coef!=-1)//系数非1或-1的普通情况{printf("%g",q->coef);if(q->expn==1) putchar('X');else if(q->expn) printf("X^%d",q->expn);}else{if(q->coef==1){if(!q->expn) putchar('1');elseif(q->expn==1) putchar('X');else printf("X^%d",q->expn);}if(q->coef==-1){if(!q->expn) printf("-1");elseif(q->expn==1) printf("-X");else printf("-X^%d",q->expn);}}q=q->next;flag++;}printf("\n");}/************辅助乘法和加法运算*************/int compare(Polyn a,Polyn b){if(a&&b){if(!b||a->expn>b->expn)return 1;elseif(!a||a->expn<b->expn)return -1;elsereturn 0;}elseif(!a&&b)return -1;//a多项式已空,但b多项式非空elsereturn 1;//b多项式已空,但a多项式非空}/*************多项式的加法*********************/ Polyn AddPolyn(Polyn pa,Polyn pb){Polyn qa=pa->next;Polyn qb=pb->next;Polyn headc,hc,qc;hc=(Polyn)malloc(sizeof(struct Polynomial));hc->next=NULL;headc=hc;while(qa||qb){qc=(Polyn)malloc(sizeof(struct Polynomial));switch(compare(qa,qb)){case 1:{qc->coef=qa->coef;qc->expn=qa->expn;qa=qa->next;break;}case 0:{qc->coef=qa->coef+qb->coef;qc->expn=qa->expn;qa=qa->next;qb=qb->next;break;}case -1:{qc->coef=qb->coef;qc->expn=qb->expn;qb=qb->next;break;}}if(qc->coef!=0){qc->next=hc->next;hc->next=qc;hc=qc;}else free(qc);//当相加系数为0时,释放该结点}HeBing(headc);return headc;}/************多项式的减法*****************/Polyn SubstractPolyn(Polyn pa,Polyn pb){Polyn h=pb;Polyn p=pb->next;Polyn pd;while(p) //将pb的系数取反{p->coef*=-1;p=p->next;}pd=AddPolyn(pa,h);for(p=h->next;p;p=p->next) //恢复pb的系数p->coef*=-1;HeBing(pd);return pd;}/*****************多项式的乘法*********************/Polyn MultiplyPolyn(Polyn pa,Polyn pb){Polyn hf,pf;Polyn qa=pa->next;Polyn qb=pb->next;hf=(Polyn)malloc(sizeof(struct Polynomial));hf->next=NULL;for(;qa;qa=qa->next){for(qb=pb->next;qb;qb=qb->next){pf=(Polyn)malloc(sizeof(struct Polynomial));pf->coef=qa->coef*qb->coef;pf->expn=qa->expn+qb->expn;Insert(pf,hf);//调用Insert函数以合并指数相同的项}}HeBing(hf);return hf;}/*******************主函数*******************/void main(){Polyn p1, p2, p3, p4, p5;CreatPolyn(p1);CreatPolyn(p2);PrintPolyn(p1);PrintPolyn(p2);p3=AddPolyn(p1, p2);PrintPolyn(p3);p4=SubstractPolyn(p1, p2);PrintPolyn(p4);p5=MultiplyPolyn(p1, p2);PrintPolyn(p5);DestroyPolyn(p1);DestroyPolyn(p2);DestroyPolyn(p3);DestroyPolyn(p4);DestroyPolyn(p5);}四、调试结果1.测试的数据及结果2.算法的时间复杂度及改进算法的时间复杂度:一元多项式的加法运算的时间复杂度为O(m+n),减法运算的时间复杂度为O(m-n),其中m,n分别表示二个一元多项式的项数。
一元多项式的计算问题-数据结构与算法课程设计报告
合肥学院计算机科学与技术系课程设计报告2009 ~2010 学年第 2 学期课程数据结构与算法课程设计名称一元多项式的计算问题学生姓名周维学号**********专业班级08计科(2)指导教师王昆仑教授2010年6月题目:(一元多项式的计算问题)要求能够按照指数降序排列建立并输出一元多项式;能够完成两个一元多项式的相加、相减,并将结果输入。
一、问题分析和任务定义1.问题分析本程序关键点是如何将输入的两个多项式相加、相减操作。
①如何将输入的一元多项式按指数的降序排列②如何确定要输入的多项式的项数;③如何将输入的两个一元多项式显示出来。
④如何将输入的两个一元多项式进行相加操作。
⑤如何将输入的两个一元多项式进行相减操作。
本程序是通过链表实现一元多项式的相加减操作。
2、任务定义此程序需要完成如下的要求:将多项式按照指数降序排列建立并输出,将两个一元多项式进行相加、相减操作,并将结果输入。
a:输入多项式的项数并建立多项式;b:输出多项式,输出形式分别为浮点和整数序列,序列按指数升序排列;c:多项式a和b相加,建立多项式a+b;d:多项式a和b相减,建立多项式a-b。
e:多项式的输出。
二、数据结构的选择和概要设计:(1)数据结构的选用A:基于链表中的节点可以动态生成的特点,以及链表可以灵活的添加或删除节点的数据结构,为了实现任意多项式的加法,减法,因此选择单链表的结构体,它有一个系数,指数,下一个指针3个元属;例如,图1中的两个线性链表分别表示一元多项式和一元多项式。
从图中可见,每个结点表示多项式中的一项。
图1 多项式表的单链存储结构B:本设计使用了以下数据结构:t ypedef struct {float coef; //系数int expn; //指数} ElemType;typedef struct LNode{ElemType data;struct LNode *next;}LNode;C:设计本程序需用到九个模块,用到以下九个子函数如下:1、void Menu()//建立菜单2、LNode *InitList() // 创建链表3、void ChaLNode(LNode *L,ElemType x)//插入链表4、LNode *AddPolyn(LNode *A,LNode *B)//多项式相加5、void Invert(LNode *L)//逆序输出链表6、void Print(LNode *L)//输出多项式7、main()//主程序模块调用链一元多项式的各种基本操作模块。
数据结构课程设计报告一元稀疏多项式计算器
课程设计报告1.需求分析【问题描述】设计一个一元稀疏多项式简单计算器.【基本要求】一元稀疏多项式基本功能包括:1)输入并建立多项式;2)输出多项式,输出形式为整数序列:n, c1, e1, c2, e2, … , c n, e n,其中n是多项式的项数,c i和e i分别是第i项的系数和指数,序列按指数降序排列;3)多项式a和b相加,建立多项式a+b;4)多项式a和b相减,建立多项式a-b;【测试数据】1)(2x+5x8-3.1x11)+(11x9-5x8+7)=(-3.1x11+11x8+2x+7)2)(-1.2x9+6x-3+4.4x2-x)-(7.8x15+4.4x2-6x-3)=(-7.8x15-1.2x9+12x-3-x)3)(x5+x4+x3+x2+x+1)-(-x4-x3)=(x5+x2+x+1)4)(x3+x)-(-x3-x)=05)(x100+x)+(x200+x100)=(x200+2x100+x)6)(x3+x2+x)+0=x3+x2+x7)互换上述测试数据中的前后两个多项式.2.概要设计ADT Polynomial{数据对象: D={a i|a i∈TermSet, i=1,2,…,m,m≥0,TermS et中的每个元素包含一个表示系数的实数和表示指数的整数}数据对象: R1={<a i,a i-1>|a i,a i-1∈D,且a i-1中的指数值小于ai中的指数,i=2,…,m}基本操作:CreatePolyn(void)Result: 指数由大到小输入m项的系数和指数,建立一元多项式pPrintPoly(LNode Head)Result: 输出一元多项式AddPoly(LNode H1,LNode H2)Condition: 一元多项式pa,pb已存在Result: 完成多项式相加运算,即pa=pa+pb,并销毁一元多项式pb.SubtractPoly(LNode H1,LNode H2)Condition: 一元多项式pa,pb已存在Result: 完成多项式相减运算,即pa=pa-pb,并销毁一元多项式pb.}ADT Polynomial3.详细设计【数据类型定义】typedef struct node{int expn,coef;struct node *next;}Nodetype,*LNode; //定义结点类型【函数原型定义】LNode CreatePolyn(void);Void PrintPoly(LNode Head);LNode AddPolyn(LNode H1,LNode H2);LNode SubPolyn(LNode H1,LNode H2);【核心算法描述】CreatePolyn()LNode CreatePolyn(void) //创建表达式{LNode Head,p,pre,pree;int x,z;Head=(LNode)malloc(sizeof(Nodetype));Head->next=NULL;printf("当你输入的系数为0时,输入将结束!\n");printf("请输入第一项系数:");scanf("%d",&x);if(x==0){p=(LNode)malloc(sizeof(LNode));p->coef=0;p->expn=0;Head->next=p;p->next=NULL;}while(x!=0){printf("请输入指数:");scanf("%d",&z);p=(LNode)malloc(sizeof(Nodetype));p->coef=x;p->expn=z;pre=Head;while(pre->next&&pre->next->expn>=z)//原有项指数大于插入项{pree=pre;pre=pre->next;}p->next=pre->next;//插入项pre->next=p;if(pre->expn==p->expn)//原有项指数等于插入项{pre->coef+=p->coef;pre->next=p->next;free(p);}if(pre->coef==0)//系数为0{pree->next=pre->next;free(pre);}printf("请输入系数:");scanf("%d",&x);}if(Head->next==NULL)//多项式空{pre=(LNode)malloc(sizeof(LNode));pre->coef=0;pre->expn=0;pre->next=Head->next;Head->next=pre;}return Head;}PrintPolyn()void PrintPolyn(LNode Head) //输出表达式{LNode pre;pre=Head->next;if(pre->expn==0)//指数为0printf("%d",pre->coef);elseprintf("%d*X(%d)",pre->coef,pre->expn);pre=pre->next;while(pre)//系数不为0{if(pre->expn==0)//指数为0{if(pre->coef>0)printf("+%d",pre->coef);else if(pre->coef<0)printf("%d",pre->coef);}else//指数不为0{if(pre->coef>0)printf("+%d*X(%d)",pre->coef,pre->expn);else if(pre->coef<0)printf("%d*X(%d)",pre->coef,pre->expn);}pre=pre->next;//遍历每一项}printf("\n");}AddPolyn()LNode AddPolyn(LNode H1,LNode H2) //表达式相加{LNode H3,p1,p2,p3,pre;//p1第一个多项式的项,pre p的前一项H3=(LNode)malloc(sizeof(LNode));H3->next=NULL; //建立一个空的多项式p1=H1->next; //第一个多项式的第一项p2=H2->next;pre=H3; //while(p1&&p2){if(p1->expn>p2->expn)//第一个多项式的项的指数大于第二个的{p3=(LNode)malloc(sizeof(LNode));p3->expn=p1->expn;p3->coef=p1->coef;p3->next=pre->next;pre->next=p3;pre=p3;p1=p1->next;}else if(p1->expn<p2->expn)//第一个多项式的项的指数小于第二个的{p3=(LNode)malloc(sizeof(LNode));p3->expn=p2->expn;p3->coef=p2->coef;p3->next=pre->next;pre->next=p3;pre=p3;p2=p2->next;else if(p1->coef+p2->coef!=0)//相加为不0,指数相同系数相加{p3=(LNode)malloc(sizeof(LNode));p3->expn=p1->expn;p3->coef=p1->coef+p2->coef;p3->next=pre->next;pre->next=p3;pre=p3;p1=p1->next;p2=p2->next;}else//相加为0{p1=p1->next;p2=p2->next;}}while(p2){p3=(LNode)malloc(sizeof(LNode));p3->expn=p2->expn;p3->coef=p2->coef;p3->next=pre->next;pre->next=p3;pre=p3;p2=p2->next;}while(p1){p3=(LNode)malloc(sizeof(LNode));p3->expn=p1->expn;p3->coef=p1->coef;p3->next=pre->next;pre->next=p3;pre=p3;p1=p1->next;}return H3;}LNode SubstractPolyn(LNode H1,LNode H2) //表达式相减{//让系数变负,代入加法LNode H3,pre;pre=H2->next;while(pre){pre->coef=-pre->coef;pre=pre->next;}H3=AddPolyn(H1,H2);pre=H2->next;while(pre){pre->coef=-pre->coef;pre=pre->next;}return H3;}【函数调用关系】main()调用CreatePoly(),PrintPoly(),AddPoly(),scanf()函数输入,printf()函数输出。
数据结构实验报告-一元多项式
数据结构实验报告-一元多项式
实验目的
1.使用C语言编写一元多项式运算的程序
2.理解和掌握链表的基本概念和操作
3.熟悉链表在实际问题中的应用
实验内容
1.设计一元多项式数据结构,支持多项式的输入、输出、加、减、乘、求导等计算。
2.使用链表来实现多项式数据结构。
3.编写测试程序,测试多项式数据结构的正确性和效率。
实验步骤
1.设计一元多项式数据结构,包括多项式中的每一项所包含的系数和指数,以及链表节点结构体定义。
typedef struct node
{
float coef; // 系数
int expn; // 指数
struct node *next; // 指向下一个节点的指针
} Node, *pNode;
2.按照上述定义的结构体,实现多项式的输入函数。
3.利用链表实现多项式的加法函数。
6.编写测试程序,测试多项式数据结构的正确性和效率。
实验结果
1.输入第一个多项式为 3x^3+2x^2+3 第二个多项式为 2x^3+x^2+4x+1
2.经过程序的处理,两个多项式的加法结果为 5.00x^3+
3.00x^2+
4.00x+4.00
两个多项式的乘法结果为
6.00x^6+10.00x^5+5.00x^4+10.00x^3+14.00x^2+19.00x+3.00
第一个多项式求导结果为 9.00x^2+4.00x
1.链表可以有效地实现多项式数据结构的存储和操作,具有较好的效率和灵活性。
2.通过本次实验,能够更加深入地理解数据结构中链表的应用,有助于提高编程能力和实际问题解决能力。
一元多项式计算(数据结构课程设计)
一元多项式计算(数据结构课程设计)一、系统设计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环境中调试运行。
一元多项式实验报告
数据结构实验报告实验名称:实验一一元多项式学生姓名:叶远锋班级:2010211111班内序号:18学号:10210328日期:2011年11月9日1.实验要求实验目的●熟悉C++语言的基本编程方法,掌握继承编译环境的调试方法;●学习指针、模板类、异常处理的使用;●掌握线性表的操作实现方法;●培养使用线性表解决实际问题的能力。
实验内容利用线性表实现一个一元多项式Polynomial:f(x)=a0+a1X+a2X^2+……+anX^n具体要求如下:①能够实现一元多项式的输入和输出;②能够进行一元多项式相加;③能够进行一元多项式相减;④能够计算一元多项式在x处的值;⑤能够计算一元多项式的导数(选作);⑥能够进行一元多项式相乘(选作);⑦编写main()函数测试算法的正确性。
2. 程序分析2.1 存储结构存储结构:顺序表a[0]a[1]a[2]……a[n].2 关键算法分析1、关键算法:加法、减法、求导、乘法、求值✧加法时间复杂度O(n)输出参数:返回一个新一元多项式c输入参数:两个一元多项式PolyList类对象的引用a、b[1] 从第一项开始,比较a和b 的指数,直到其中一个多项式比较到最后一项[1.1] 如果a对应项的指数小于b对应项的指数,把a的对应项复制给C的对应项,再把a的下一项和b的当前项比较[1.2] 如果a对应项的指数大于b对应项的指数,把b的对应项复制给C的对应项,再把b的下一项和a的当前项比较[1.3] 如果a的对应项指数等于b的对应项指数,则c的对应项的系数等于a的对应项系数和b的对应项系数相加,c的对应项的指数等于a或b的对应项指数,再把a的下一项和b的下一项比较[2] 如果a或b其中有一个没有比较完,就把没有比较的项都复制到c中[3] 返回c✧减法时间复杂度O(n)输出参数:返回一个新一元多项式c输入参数:两个一元多项式PolyList类对象的引用a、b[1] 将多项式b的每一项系数都乘以-1[2] 调用加法,把a+b的值赋给c[3] 返回c✧求导时间复杂度O(n)输出参数:返回一个新一元多项式a输入参数:无[1] 从第一项开始,直到最后一项,如果指数不等于零,则a的对应项系数等于现有项系数乘以现有项指数,a的对应项指数等于现有项指数减一[2] 返回a✧乘法时间复杂度O(mn)输出参数:返回一个新一元多项式 c输入参数:两个一元多项式PolyList类对象的引用a、b[1] 从a的第一项开始,直至最后一项,逐项和b相乘[2] 将每一次相乘得到的多项式相加,并把相加的结果赋给c[3] 返回c✧求值时间复杂度O(n)输出参数:返回一个float型数输入参数:输入一个float型数[1] 从第一项开始,直至最后一项,依次计算每一项的值[2] 将每次计算得到的结果相加,并把相加结果赋给value[3] 返回value3. 程序运行结果1、测试主函数流程:流程图如图所示2、测试条件1)输入项数应少于100项2)输入多项式项数是大于零的整数3)输入多项式时,要从低次项到高次项依次逐项输入,先输入系数,再输入指数4)按屏幕提示输入3、测试结论1)程序可以实现多项式的输入输出操作2)程序可以进行多项式的加减乘及求导和求值运算4. 总结1.调试时出现的问题及解决方法1)问题:main函数中,在定义term结构数组时使用整型n,m变量作为数组的长度遇到系统报错解决方法:为数组申请动态内存2)问题:main函数中,当输入多项式项数小于1时无法报错解决方法:在用户输入完毕后增加if判断语句来实现报错3)问题:用户无法循环输入多项式解决方法:在程序末尾增加按键判断语句,如果用户选择要重新输入多项式则返回程序开头重新执行,否则程序结束2.心得体会1)通过这次编程练习,我加深了对顺序表的理解与运用。
一元多项式数据结构课程设计报告
一元多项式计算摘要一元多项式计算是用C语言设计一个一元多项式简单计算器。
它能够实现按指数降序排列建立并输出多项式,并且能够完成两个多项式的相加,想减的运算和将其结果输入的功能。
体会链式存存储结构的优缺点和适用性.了解并掌握数据结构与算法的设计方法,具备初步的独立分析和设计能力;初步掌握软件开发过程的问题分析、系统设计、程序编码、测试等基本方法和技提高综合运用所学的理论知识和方法独立分析和解决问题的能力;加深对常用数据结构的理解,强化学生的逻辑思维能力和动手能力,巩固良好的编程习惯,掌握工程软件设计的基本方法,为后续课程的学习打下坚实基础。
关键词:C语言;一元多项式;链式存存储结构;指数降序排列;目录1. 引言--------------------------------------------32.需求分析----------------------------------------33.概要设计----------------------------------------3 3.1功能模块图-------------------------------33.2流程图------------------------------------44.详细设计----------------------------------------54.1一元多项式的建立---------------------------54.2显示一元多项式---------------------------------------64.3一元多项式的加法运算--------------------------------7 4.4一元多项式的减法运算----------------------94.5 帮助------------------------------------12 5测试结果----------------------------------------126.调试分析-----------------------------------------137.设计体会-----------------------------------------138.结束语--------------------------------------------149.参考文献-----------------------------------------1510.附录---------------------------------------------151.引言此程序的数据结构是选择用带头结点的单链表存储多项式。
数据结构一元多项式报告
一元多项式计算:程序要求:1)、能够按照指数降序排列建立并输出多项式;2)、能够完成两个多项式的相加、相减,并将结果输入。
概要设计:1.功能:将要进行运算的多项式输入输出。
2.数据流入:要输入的多项式的系数与指数。
3.数据流出:合并同类项后的多项式。
4.程序流程图:多项式输入流程图如图3.2.1所示。
5.测试要点:输入的多项式是否正确,若输入错误则重新输入2、多项式的加法(1)功能:将两多项式相加。
(2)数据流入:输入函数。
(3)数据流出:多项式相加后的结果。
(4)程序流程图:多项式的加法流程图如图3.2.2所示。
(5)测试要点:两多项式是否为空,为空则提示重新输入,否则,进行运算。
3、多项式的减法(1)功能:将两多项式相减。
(2)数据流入:调用输入函数。
(3)数据流出:多项式相减后的结果。
(4)程序流程图:多项式的减法流程图如图3.2.3所示。
(5)测试要点:两多项式是否为空,为空则提示重新输入,否则,进行运算。
详细代码:#include<iostream>#include<conio.h>#include<stdlib.h>using namespace std; struct Node{float coef;//结点类型int exp;};typedef Node polynomial;struct LNode{polynomial data;//链表类型LNode *next;};typedef LNode* Link;void CreateLink(Link &L,int n);void PrintList(Link L);void PolyAdd(Link &pc,Link pa,Link pb);void PolySubstract(Link &pc,Link pa,Link pb); void CopyLink(Link &pc,Link pa);void PolyMultiply(Link &pc,Link pa,Link pb);int JudgeIfExpSame(Link pa,Link e);void DestroyLink(Link &L);int CompareIfNum(int i);void DestroyLink(Link &L){Link p;p=L->next;while(p){L->next=p->next;delete p;p=L->next;}delete L;L=NULL;}//创建含有n个链表类型结点的项,即创建一个n项多项式void CreateLink(Link &L,int n){if(L!=NULL){DestroyLink(L);}Link p,newp;L=new LNode;L->next=NULL;(L->data).exp=-1;//创建头结点p=L;for(int i=1;i<=n;i++){newp=new LNode;cout<<"请输入第"<<i<<"项的系数和指数:"<<endl;cout<<"系数:";cin>>(newp->data).coef;cout<<"指数:";cin>>(newp->data).exp;if(newp->data.exp<0){cout<<"您输入有误,指数不允许为负值!"<<endl;delete newp;i--;continue;}newp->next=NULL;p=L;if(newp->data.coef==0){cout<<"系数为零,重新输入!"<<endl;delete newp;i--;continue;}while((p->next!=NULL)&&((p->next->data).exp<(newp->data).exp)){p=p->next; //p指向指数最小的那一个}if(!JudgeIfExpSame( L, newp)){newp->next=p->next;p->next=newp;}else{cout<<"输入的该项指数与多项式中已存在的某项相同,请重新创建一个正确的多项式"<<endl;delete newp;DestroyLink(L);CreateLink(L,n); //创建多项式没有成功,递归调用重新创建break;}}}/*判断指数是否与多项式中已存在的某项相同*/int JudgeIfExpSame(Link L,Link e){Link p;p=L->next;while(p!=NULL&&(e->data.exp!=p->data.exp))p=p->next;if(p==NULL)return 0;else return 1;}/*输出链表*/void PrintList(Link L){Link p;if(L==NULL||L->next==NULL)cout<<"该一元多项式为空!"<<endl;else{p=L->next;//项的系数大于的种情况if((p->data).coef>0){if((p->data).exp==0)cout<<(p->data).coef;else if((p->data).coef==1&&(p->data).exp==1)cout<<"x";else if((p->data).coef==1&&(p->data).exp!=1)cout<<"x^"<<(p->data).exp;else if((p->data).exp==1&&(p->data).coef!=1)cout<<(p->data).coef<<"x";else cout<<(p->data).coef<<"x^"<<(p->data).exp; }//项的系数小于的种情况if((p->data).coef<0){if((p->data).exp==0)cout<<(p->data).coef;else if(p->data.coef==-1&&p->data.exp==1)cout<<"-x";else if(p->data.coef==-1&&p->data.exp!=1)cout<<"-x^"<<p->data.exp;else if(p->data.exp==1)cout<<p->data.coef<<"x";else cout<<(p->data).coef<<"x^"<<(p->data).exp; }p=p->next;while(p!=NULL){if((p->data).coef>0){if((p->data).exp==0)cout<<"+"<<(p->data).coef;else if((p->data).exp==1&&(p->data).coef!=1)cout<<"+"<<(p->data).coef<<"x";else if((p->data).exp==1&&(p->data).coef==1)cout<<"+"<<"x";else if((p->data).coef==1&&(p->data).exp!=1)cout<<"+"<<"x^"<<(p->data).exp;else cout<<"+"<<(p->data).coef<<"x^"<<(p->data).exp; }if((p->data).coef<0){if((p->data).exp==0)cout<<(p->data).coef;else if(p->data.coef==-1&&p->data.exp==1)cout<<"-x";else if(p->data.coef==-1&&p->data.exp!=1)cout<<"-x^"<<p->data.exp;else if(p->data.exp==1)cout<<p->data.coef<<"x";else cout<<(p->data).coef<<"x^"<<(p->data).exp;}p=p->next;}}cout<<endl;}/*把一个链表的内容复制给另一个链表*/void CopyLink(Link &pc,Link pa){Link p,q,r;pc=new LNode;pc->next=NULL;r=pc;p=pa;while(p->next!=NULL){q=new LNode;q->data.coef=p->next->data.coef;q->data.exp=p->next->data.exp;r->next=q;q->next=NULL;r=q;p=p->next;}}/*将两个一元多项式相加*/void PolyAdd(Link &pc,Link pa,Link pb){Link p1,p2,p,pd;CopyLink(p1,pa);CopyLink(p2,pb);pc=new LNode;pc->next=NULL;p=pc;p1=p1->next;p2=p2->next;while(p1!=NULL&&p2!=NULL){if(p1->data.exp<p2->data.exp){p->next=p1;p=p->next;p1=p1->next;}else if(p1->data.exp>p2->data.exp){p->next=p2;p=p->next;p2=p2->next;}else{p1->data.coef=p1->data.coef+p2->data.coef;if(p1->data.coef!=0){p->next=p1;p=p->next;p1=p1->next;p2=p2->next;}else{pd=p1;p1=p1->next;p2=p2->next;delete pd;}}}if(p1!=NULL){p->next=p1;}if(p2!=NULL){p->next=p2;}}/*将两个多项式相减*/void PolySubstract(Link &pc,Link pa,Link pb) {Link p,pt;CopyLink(pt,pb);p=pt;while(p!=NULL){(p->data).coef=(-(p->data).coef);p=p->next;}PolyAdd(pc,pa,pt);DestroyLink(pt);}//清屏函数void Clear(){system("pause");system("cls");}/*将两个一元多项式相乘*/void PolyMultiply(Link &pc,Link pa,Link pb) {Link p1,p2,p,pd,newp,t;pc=new LNode;pc->next=NULL;p1=pa->next;p2=pb->next;while(p1!=NULL){pd=new LNode;pd->next=NULL;p=new LNode;p->next=NULL;t=p;while(p2){newp=new LNode;newp->next=NULL;newp->data.coef=p1->data.coef*p2->data.coef;newp->data.exp=p1->data.exp+p2->data.exp;t->next=newp;t=t->next;p2=p2->next;}PolyAdd(pd,pc,p);CopyLink(pc,pd);p1=p1->next;p2=pb->next;DestroyLink(p);DestroyLink(pd);}}//菜单函数void Menu(){cout<<""<<endl;cout<<endl;cout<<"\t=========================一元多项式的简单运算========================="<<endl;cout<<"\t\t\t\t\t\t\t\t "<<endl;cout<<"\t\t\t [1] 创建要运算的两个一元多项式\t\t "<<endl; cout<<"\t\t\t [2] 将两个一元多项式相加\t\t\t "<<endl; cout<<"\t\t\t [3] 将两个一元多项式相减\t\t\t "<<endl; cout<<"\t\t\t [4] 将两个一元多项式相乘\t\t\t "<<endl; cout<<"\t\t\t [5] 显示两个一元多项式\t\t\t "<<endl;cout<<"\t\t\t [6] 销毁所创建的二个多项式\t\t "<<endl; cout<<"\t\t\t [7] 退出\t\t\t\t\t "<<endl;cout<<"\t\t\t\t\t\t\t\t "<<endl;cout<<"\t=========================一元多项式的简单运算========================="<<endl;cout<<endl;cout<<"\t\t 请选择:";}//判断输入的整数是不是为到的数字int CompareIfNum(int i){if(i>0&&i<8)return 0;else return 1;}void main(){{system("color b");//system("pause");system("color a");//system("pause");}int n;Link L,La=NULL,Lb=NULL;//La,Lb分别为创建的两个多项式int choose;while(1){Menu(); //调用菜单函数cin>>choose;switch(choose){case 1:cout<<"请输入你要运算的第一个一元多项式的项数:"<<endl; cin>>n;if(CompareIfNum(n)==1){cout<<"您的输入有误,请重新输入……"<<endl;Clear();break;}CreateLink(La,n);cout<<"请输入你要运算的第二个一元多项式的项数:"<<endl; cin>>n;if(CompareIfNum(n)==1){cout<<"您的输入有误,请重新输入……"<<endl;Clear();break;}CreateLink(Lb,n);Clear();break;case 2:if(La==NULL||Lb==NULL){cout<<"您的多项式创建有误,请重新选择……"<<endl; Clear();break;}PolyAdd(L,La,Lb);cout<<""<<endl;cout<<"待相加的两个一元多项式为:"<<endl;cout<<""<<endl;cout<<"A的多项式为:";PrintList(La);cout<<""<<endl;cout<<"B的多项式为:";PrintList(Lb);cout<<""<<endl;cout<<"相加后的结果为:";PrintList(L);cout<<""<<endl;Clear();DestroyLink(L);break;case 3:if(La==NULL||Lb==NULL){cout<<"您的多项式创建有误,请重新选择……"<<endl; Clear();break;}PolySubstract(L,La,Lb);cout<<"相减的两个一元多项式为:"<<endl;cout<<""<<endl;cout<<"A的多项式为:";PrintList(La);cout<<""<<endl;cout<<"B的多项式为:";PrintList(Lb);cout<<""<<endl;cout<<"相减后的结果为:";PrintList(L);cout<<""<<endl;Clear();DestroyLink(L);break;case 4:if(La==NULL||Lb==NULL){cout<<"您的多项式创建有误,请重新选择……"<<endl; Clear();break;}PolyMultiply(L,La,Lb);cout<<"相乘的两个一元多项式为:"<<endl;cout<<""<<endl;cout<<"A的多项式为:";PrintList(La);cout<<""<<endl;cout<<"B的多项式为:";PrintList(Lb);cout<<""<<endl;cout<<"相乘后的结果为:";PrintList(L);DestroyLink(L);cout<<""<<endl;Clear();break;case 5:if(La==NULL||Lb==NULL){cout<<"您的多项式创建有误,请重新选择……"<<endl; Clear();break;}cout<<"一元多项式A为:"<<endl;PrintList(La);cout<<""<<endl;cout<<"一元多项式B为:"<<endl;PrintList(Lb);cout<<""<<endl;Clear();break;case 6:if(La&&Lb){DestroyLink(La);DestroyLink(Lb);cout<<"多项式销毁成功!"<<endl;Clear();}else{cout<<"多项式不存在,请重新选择^^^"<<endl;Clear();}break;case 7:exit(0); //exit(0)强制终止程序,返回状态码表示正常结束default:cout<<"您的输入有误,请重新选择操作……"<<endl;Clear();break;}}}。
数据结构《一元多项式》
一元多项式相加问题实验报告本实验的目的是进一步熟练掌握应用链表处理实际问题的能力。
一、问题描述通过键盘输入两个形如Po+P₁X¹+P₂X²+…+PX的多项式,经过程序运算后在屏幕上输出它们的相加和。
二、数据结构设计分析任意一元多项式的描述方法可知,一个一元多项式的每一个子项都由“系数-指数”两部份组成,因此可将其抽象为包含系数coef、指数 exp、指针域next 构成的链式线性表。
对多项式中系数为0的子项可以不记录它的指数值,将两个多项式分别存放在两个线性表中,然后经过相加后将所得多项式存放在一个新的线性表中,但是不用再开辟新的存储空间,只依靠结点的挪移来构成新的线性表,期间可以将某些不需要的空间回收。
基于这样的分析,可以采用不带头结点的单链表来表示一个一元多项式。
具体数据类型定义为:struct nodefloat coef;//系数域int exp; //指数域struct node *next;};三、功能函数设计1、输入并建立多项式的功能模块具体函数为node *in f un()此函数的处理较为全面,要求用户按照指数递增的顺序和一定的输入格式输入各个系数不为0的子项,输入一个子项建立一个相关结点,当遇到输入结束标志时住手输入。
关键步骤具体如下:(1)控制用户按照指数递增的顺序输入r=a;while(r!=q->next)if(y<=r->exp)cout<<"请按照指数递增顺序输入,请重新输入";cin>>x>>y;break;r=r->next;从头开始遍历,若遇到目前输入的指数不是最大时,就跳出循环,让用户重新输入。
(2)当输入的系数为零时,不为其分配存储空间存储while(x==0){cin>>x>>y;continue;}即若系数为0,再也不进行动态分配并新建结点,而是重新提取用户输入的下一个子项的系数和指数,利用continue 进入下一次循环。
数据结构实验报告-一元多项式
数据结构实验报告-一元多项式数据结构课程设计报告课题: 一元多项式姓名:XX学号:201417030218专业班级:XXXX指导教师:XXXX设计时间:2015年12月30日星期三评阅意见:评定成绩:指导老师签名:年月日目录一、任务目标 (3)二、概要设计 (4)三、详细设计 (6)四、调试分析 (8)五、源程序代码 (8)六、程序运行效果图与说明 (15)七、本次实验小结 (16)八、参考文献 (16)一丶任务目标分析 (1) a.能够按照指数降序排列建立并输出多项式b.能够完成两个多项式的相加,相减,并将结果输入要求:程序所能达到的功能:a.实现一元多项式的输入;b.实现一元多项式的输出;c.计算两个一元多项式的和并输出结果;d.计算两个一元多项式的差并输出结果;除任务要求外新增乘法:计算两个一元多项式的乘积并输出结果(2)输入的形式和输入值的范围:输入要求:分行输入,每行输入一项,先输入多项式的指数,再输入多项式的系数,以0 0为结束标志,结束一个多项式的输入。
输入形式:2 3-1 23 01 20 0输入值的范围:系数为int型,指数为float型(3)输出的形式:第一行输出多项式1;第二行输出多项式2;第三行输出多项式1与多项式2相加的结果多项式;第四行输出多项式1与多项式2相减的结果多项式;第五行输出多项式1与多项式2相乘的结果多项式二、概要设计程序实现a. 功能:将要进行运算的二项式输入输出;b. 数据流入:要输入的二项式的系数与指数;c. 数据流出:合并同类项后的二项式;d. 程序流程图:二项式输入流程图;e. 测试要点:输入的二项式是否正确,若输入错误则重新输入。
流程图:三、详细设计(1):存储结构一元多项式的表示在计算机内可以用链表来表示,为了节省存储空间,只存储多项式中系数非零的项。
链表中的每一个结点存放多项式的一个系数非零项,它包含三个域,分别存放该项的系数、指数以及指向下一个多项式项结点的指针。
数据结构实验报告-一元多项式的加法运算
问题描述:设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;//完成运算符和其他项的输//出,然后类似于上面,对第二个多项式进行相应的操作。
数据结构课程设计——一元多项式计算
数据结构课程设计——一元多项式计算一、课程设计题目及要求二、设计思路和方法三、程序流程图四、程序代码及注释五、测试结果及分析六、结论七、参考文献本次课程设计的题目为“一元多项式计算”,要求设计一个程序,能够实现一元多项式的加、减、乘、求导和求值等操作。
在设计思路和方法上,我们采用了链表的数据结构来存储多项式,同时设计了相应的函数来实现各种操作。
程序的流程图如下所示:插入流程图)程序的代码及注释如下所示:插入代码及注释)在测试结果及分析方面,我们对程序进行了多组测试,并对其进行了详细的分析和比较。
结果表明,我们的程序能够正确地实现各种操作,并且具有较高的效率和稳定性。
综上所述,本次课程设计的目标已经得到了圆满地实现,我们对于所取得的成果感到非常满意。
同时,我们也希望能够通过这次课程设计,加深对于数据结构及其应用的理解和掌握,为今后的研究和工作打下坚实的基础。
设计目标:本课程设计旨在结合理论与实际应用,提高学生组织数据及编写大型程序的能力。
通过掌握数据组织、算法设计和算法性能分析的方法,培养学生良好的程序设计能力。
具体实现是利用单链表表示一元多项式,实现多项式的输入、建立、输出、相加、相减和相乘。
总体设计:2.1 数据结构描述与定义:一元多项式定义系数和指数结构如下:coef,expn和next。
定义多项式的结构为线性链表的存储结构,每个结点包含三个元素:系数coef,指数expn和指向下一个结点的指针*next。
多个单项式通过指针连接起来,形成一个多项式。
2.2 模块设计:从实现多项式运算过程的角度来分析,至少需要以下子功能模块:多项式创建、销毁、输出、相加、相减和相乘。
定义并调用的函数有:Insert、CreatePolyn、DestroyPolyn、PrintPolyn、AddPolyn、SubtractPolyn、XXX和main函数。
注:该文章中没有明显的格式错误和需要删除的段落,因此没有进行小幅度改写。
数据结构课程设计报告一元多项式加减乘计算
《数据结构》课程设计多项式计算班级:学号:姓名:指导老师:多项式计算1、问题描述能够按照指数降序排列建立多项式;能够完成两个多项式的相加、相减和相乘,并将结果输出。
2、设计思路这个程序的关键是多项式的创建和排列,以及相乘时系数相乘和指数相加、相加时相同指数的系数相加、相减时相同指数的系数相减。
由于多项式拥有指数和系数(假设基数已定),所以可以定义一个包含指数系数的结构体,用单链表存储多项式的数据,所以结构体包含next指针。
数据插入时比较两数的指数,按照降序排序,从表头的next开始,直至找到合适的位置,然后开始链表中数值的插入,如果相等则直接将指数相加,如果大于就将新数据插入到当前指向的前面,否则将新数据插入到最后。
输入完数据后选择计算方式(相乘、相加、相减),多项式运算时要循环遍历整个多项式,多项式的每一组数据都要和另一个多项式整组数据相运算(每一个运算值都存储到新建的“多项式”链表中),直到两个多项式都遍历完结束。
3、数据结构设计在模拟多项式对象时,为了简化处理,只取最核心的两个数据:多项式的系数和指数。
前面提到,要用单链表操作,所以要加上个next指针,再由该结构体定义一个结点类型和指针类型。
具体数据结构定义如下:typedef struct node{int xs; /*系数*/int zs; /*指数*/struct node * next; /*next指针*/}Dnode,* Dnodelist;4、功能函数设计(1)链表初始化函数Creat_node()带有头结点的头指针指向空(NULL)。
(2)多项式数据的创建函数Creat_Dmeth()当链表初始化成功后,开始创建多项式。
分别循环输入两个多项式的系数和指数,其中要用到插入函数。
(3)数据的插入函数Insert_node()当创建多项式时,要用到此函数,即利用插入的方式将多项式的数据连接起来。
再输入一组数据后,程序自动调用此函数,插入时也进行着排序,从表头的next开始,一一比较指数大小,直到大于或等于当前指向的数据或遍历完所有数据时停止,然后开始链表中数值的插入,如果相等则直接将指数相加,如果大于就将新数据插入到当前指向的前面,否则将新数据插入到最后。
数据结构实验-一元多项式的加法运算
一元多项式加法一、实验目的通过实现多项式加法,对链表有更深入的了解二、实验内容问题描述:设计一个一元稀疏多项式简单的加法计算器实现要求:一元稀疏多项式简单计算器的基本功能是:(1)输入并建立多项式:1785937)(x x x x A +++=;879228)(x x x x B -+=(2)输出多项式(3)多项式A 和B 相加,建立多项式C =A +B ,并输出相加的结果多项式C(4)选作:多项式A 和B 相减,建立多项式C =A -B ,并输出相减的结果多项式D 方法说明:(1)多项式的输入与存储用带表头结点的单链表存储多项式,链表中的每个节点分别存储多项式各项的系数和指数,即每从键盘输入多项式的一对数(系数,指数),可对应建立链表的一个结点。
每个节点的结构为:建立两个链表,其中pa 和pb 分别为它们的头指针:pb结果链表Pa(或者是Pc)Pc(2)多项式数据类型的定义struct tagNode{float coef;int exp;struct tagNode *next;typedef struct tagNode Node;typedef struct tagNode* pNode;(3)主要算法①创建两个链表,分别存放多项式1和多项式2,这两个链表中的节点是按指数降序或者升序排列的②多项式相加,下面给出多项式相加的部分实现/*下面的函数实现两个多项式的相加,要相加的链表分别由pa和pb指向(其中,pa,pb都是分配了空间的头结点)。
相加的结果直接由pa指向的链表保存,即是在pa链表中添加或删除(当系数因为相加为0的情况下)一些结点,构成结果。
相加的链表中指数按从小到大的顺序排列好的,是升序链表。
*/void add_poly(Node *pa,Node *pb){Node *p=pa->pNext;//链表1,将来的结果也放在此Node *q=pb->pNext;//链表2Node *pre=pa;Node *u;//临时用float x;while (p!=NULL && q!=NULL)//当两个链表都不为空{if (p->exp<q->exp)//比较链表1跟链表2当前节点的指数大小,链表1也是存放结果的地方{pre=p;p=p->pNext;//p指向要比较的下一个结点。
数据结构课程设计报告一元多项式相加
数据结构课程设计报告题目:一元多项式相加学号:姓名:指导老师:时间: 2011年10月18日星期二程序建立的过程及步骤:1首先建立一个定义多项式的结构体duoxiangshi,其中包括一个指数(int型),一个系数(float型),还有一个指向下一项的指针,具体编译代码如下:typedef struct duoxiangshi//定义一个多项式{float coef;//多项式系数int exp;//多项式指数struct duoxiangshi *next;};2在定义一个函数(1),用来指导用户输入程序运行时所需要的必须得数据,两个一元多项式的项数、系数、指数。
具体的代码如下:void creatDuoX(Polynomial &Px,int n)//定义一个多项式函数{initDuoX(Px);duoxiangshi *p,*q;p=Px;for(int i=1;i<=n;i++){q=new duoxiangshi;cout<<"第"<<i<<"项的系数:";cin>>q->coef;//输入系数cout<<"第"<<i<<"项的指数:";cin>>q->exp;//输入指数q->next=NULL;p->next=q;p=q;}}3定义一个计算合并后的多项式的项数的函数(2),此函数的主要作用是用来最后输出合并后的多项式的时候起到作用。
具体代码如下:int lengthDuoX(Polynomial &Px)//计算多项式项数的函数,返回值是这个合并后的多项式的项数{duoxiangshi *p;int count;//定义一个变量,用来计算多项式的长度p=Px->next;count=0;while(p!=NULL){p=p->next;count++;//自加最后得出总项数并返回}return count;}4定义一个输出合并后的多项式的函数(3),主要作用为主函数调用后可以输出一元多项式,具体代码如下:void outputDuoX(Polynomial &Px)//输出合并后的多项式{ duoxiangshi *p;p=Px->next;int i;for(i=0;i<lengthDuoX(Px);i++)//调用上一个计算项数的函数,逐项的输出合并后的项{cout<<p->coef<<"*X^ "<<p->exp<<" +";p=p->next;}cout<<"0"<<endl;}5, 最重要的核心部分,程序的逻辑中心,让两个多项式相加,其中要考虑的情况如下一:两个多项式A、B 都为0二:其中一个多项式A 为0,B不为0三:其中一个多项式B为0,A不为0四:A与B 都不为0而在程序中我将二与三这两种情况,通过IF语句将其嵌到四的情况中,这样可以节省代码的复杂度。
数据结构课程设计报告-一元多项式加减运算
山东理工大学计算机学院课程设计(数据结构)班级计科1102姓名张汝全学号1111051010指导教师肖爱梅2013年1 月7 日课程设计任务书及成绩评定课题名称动态链表结构下的一元多项式的加法、减法和乘法的实现。
Ⅰ、题目的目的和要求:1.巩固和加深对数据结构的理解,通过上机实验、调试程序,加深对课本知识的理解,最终使学生能够熟练应用数据结构的知识写程序。
(1)通过本课程的学习,能熟练掌握几种基本数据结构的基本操作。
(2)能针对给定题目,选择相应的数据结构,分析并设计算法,进而给出问题的正确求解过程并编写代码实现。
2.设计题目要求:1)首先判定一元多项式是否稀疏2)分别采用顺序和链式结构实现;3)结果在M(x)中无重复阶项和无零系数项;4)要求结果以升幂排列输出Ⅱ、设计进度及完成情况Ⅲ、主要参考文献及资料[1] 严蔚敏数据结构(C语言版)清华大学出版社 1999[2] 严蔚敏数据结构题集(C语言版)清华大学出版社 1999[3] 谭浩强 C语言程序设计清华大学出版社[4] 与所用编程环境相配套的C语言或C++相关的资料Ⅳ、成绩评定:设计成绩:(教师填写)指导老师:(签字)二年月日目录第一章概述 (1)第二章系统分析 (2)第三章概要设计 (3)第四章详细设计 (4)第五章运行与测试 (18)第六章总结与心得 (20)参考文献 (21)第一章概述课程设计是实践性教学中的一个重要环节,它以某一课程为基础,可以涉及和课程相关的各个方面,是一门独立于课程之外的特殊课程。
课程设计是让同学们对所学的课程更全面的学习和应用,理解和掌握课程的相关知识。
《数据结构》是一门重要的专业基础课,是计算机理论和应用的核心基础课程。
数据结构课程设计,要求学生在数据结构的逻辑特性和物理表示、数据结构的选择和应用、算法的设计及其实现等方面,加深对课程基本内容的理解。
同时,在程序设计方法以及上机操作等基本技能和科学作风方面受到比较系统和严格的训练。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
题目:一元多项式计算
1需求和规格说明.................................................................... 错误!未定义书签。
1.1输入两个一元多项式。
............................................... 错误!未定义书签。
1.2两个多项式相加相乘。
............................................... 错误!未定义书签。
2设计 (1)
2.1设计思想 (1)
2.2设计表示 (2)
2.2.1存储结构 (2)
2.2.2涉及操作 (2)
2.3实现注释 (2)
2.4详细解释 (3)
2.4.1功能示意图 (3)
2.4.2流程示意图 (3)
3用户手册 (4)
4调试报告................................................................................ 错误!未定义书签。
5源代码及运行结构截图 (4)
5.1源代码 (4)
5.2运行截图 (10)
6课程设计总结
1需求和规格说明
1.1输入两个一元多项式。
1.2两个多项式相加相乘。
2.设计
2.1设计思想
利用顺序表存储一元多项式的各项系数和指数,进行运算2.2设计表示
2.2.1存储结构
typedef struct node{
int x[100];//系数
} node,*Node;
2.2.2涉及操作
void Creat(Node p,int n)//构造一元多项式
void add(Node a,Node b,Node s)//加
void mul(Node a,Node b,Node s)//乘
void display(Node s)//升幂显示
void display2(Node s)//降幂显示
1.1实现注释
此部分内容详细参见源代码。
1.2详细解释
1.2.1功能示意图
1.2.2流程示意图
3用户手册
输入两个一元多项式。
两个多项式相加相乘。
2源代码及运行结构截图
2.1源代码
#include <iostream>
using namespace std;
typedef struct node{
int x[100];//系数
} node,*Node;
void Creat(Node p,int n)//构造一元多项式{
int i;
int xs;
int zs;
cout<<"请输入多项式各项系数和指数:";
for(i=0;i<n;i++)
{
cin>>xs>>zs;
p->x[zs]=xs;
}
}
void add(Node a,Node b,Node s)//加{
int i;
for(i=0;i<100;i++)
{
s->x[i]=a->x[i]+b->x[i];
}
}
void mul(Node a,Node b,Node s)//乘{
int i,j;
int sz,sx;
for(i=0;i<100;i++)
{
for(j=0;j<100;j++)
{
sz=a->x[i]+b->x[j];
sx=a->x[i]*b->x[j];
s->x[sz]+=sx;
}
}
}
void display(Node s)//升幂显示
{
cout<<"结果为:(升幂)"<<endl;
int i;
for(i=0;i<100;i++)
{
if(s->x[i]!=0)
cout<<"系数:"<<s->x[i]<<" "<<"指数:"<<i<<endl;
}
}
void display2(Node s)//降幂显示
{
cout<<"结果为:(降幂)"<<endl;
int i;
for(i=99;i>=0;i--)
{
if(s->x[i]!=0)
cout<<"系数:"<<s->x[i]<<" "<<"指数:"<<i<<endl;
}
}
int main()
{
Node am,bn,s1,s2;
am=new node();
bn=new node();
s1=new node();
s2=new node();
int a,b,i;
cout<<"请输入两个多项式的项数:"; cin>>a>>b;
for(i=0;i<100;i++)
{
am->x[i]=0;
bn->x[i]=0;
s1->x[i]=0;
s2->x[i]=0;
}
cout<<"多项式一:"<<endl;
Creat(am,a);
cout<<"多项式二:"<<endl;
Creat(bn,b);
add(am,bn,s1);
cout<<"两个多项式相加";
display(s1);
display2(s1);
mul(am,bn,s2);
cout<<"两个多项式相乘";
display(s2);
display2(s2);
return 0;
}
2.2运行截图。