一元多项式的加减求导运算算法(数据结构算法)
一元多项式的加法数据结构
一元多项式的加法数据结构一元多项式是数学中常见的一种代数表达式形式，由多个单项式按照一定的规则相加而成。
在计算机科学中，为了方便对一元多项式进行处理，需要定义一种合适的数据结构来表示和操作一元多项式的加法运算。
一元多项式的加法数据结构可以使用链表来实现。
每个节点表示一个单项式，包含两个成员变量：系数和指数。
系数表示单项式的系数，指数表示单项式的指数。
通过将多个单项式的系数和指数组织成一个链表，即可表示一个一元多项式。
在链表中，每个节点按照指数从小到大的顺序排列。
这样可以方便进行多项式的加法运算。
当两个一元多项式相加时，只需按照指数的大小依次比较两个链表中的节点，并根据指数的大小关系进行相应的操作。
具体的加法算法如下：1. 创建一个新的链表作为结果链表。
2. 初始化两个指针分别指向两个原始链表的头节点。
3. 循环比较两个链表中的节点，直到其中一个链表遍历完为止。
4. 比较当前节点的指数大小关系：- 如果两个节点的指数相等，将它们的系数相加，并将结果添加到结果链表中。
- 如果第一个链表中的节点指数较小，将第一个链表的节点添加到结果链表中，并将指针指向下一个节点。
- 如果第二个链表中的节点指数较小，将第二个链表的节点添加到结果链表中，并将指针指向下一个节点。
5. 当其中一个链表遍历完后，将另一个链表中剩余的节点依次添加到结果链表中。
6. 返回结果链表作为两个一元多项式相加的结果。
通过上述算法，可以实现对一元多项式的加法运算。
这种链表结构的一元多项式加法数据结构具有以下优点：- 灵活性：可以表示任意长度的一元多项式，不受固定数组长度的限制。
- 高效性：在添加节点和遍历节点时，时间复杂度为O(n)，其中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、算法思想根据一元多项式相加的运算规则：对于两个一元多项式中所有指数相同的项，对应指数相加（减），若其和（差）不为零，则构成“和（差）多项式”中的一项；对于两个一元多项式中所有指数不相同的项，则分别写到“和（差）多项式”中去。
因为多项式指数最高项以及项数是不确定的，因此采用线性链表的存储结构便于实现一元多项式的运算。
为了节省空间，我采用两个链表分别存放多项式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环境中调试运行。
数据结构C语言实现之一元多项式的表示及相加(2)
数据结构 C 语言实现之一元多项式的表示及相加（2）
一元多项式的表示及相加 对于符号多项式的各种操作，实际上都可以利用线性表来处理。比较典型的是关于一元多项式的处理。在
} } e>next; /*将 q 结点加入到和多项式中*/ q =q->next; } }
} if(p!=NULL)/*多项式 A 中还有剩余，则将剩余的结点加入到和多项式中*/
pre->next=p;
else /*否则，将 B 中的结点加入到和多项式中*/ pre->next=q; }
算法 2.24 多项式相加 假设 A 多项式有 M 项，B 多项式有 N 项，则上述算法的时间复杂度为 O(M+N) 图 2.20 所示为图 2.19 中两个多项式的和，其中孤立的结点代表被释放的结点。
通过对多项式加法的介绍，我们可以将其推广到实现两个多项式的相乘，因为乘法可以分解为一系列的加 法运算。
“中的结点无需另生成，则可看成是将多项式 B 加到多项式 A 中，由此得到下列运算规则（设 p、q 分别 指向多项式 A，B 的一项，比较结点的指数项）
若 p->exp< q->exp，则结点 p 所指的结点应 是“和多项式”中的一项，令指针 p 后移；若 p>exp>q->exp，则结点 q 所指的结点应是“和多项式”中的一项，将结点 q 插入在结点 p 之前， 且令指针 q 在原来的链表上后移；
（1）用单链表存储多项式的结点结构如下： struct Polynode { int coef; int exp; Polynode *next; } Polynode , * Polylist;
数据结构 线性结 一元多项式的加法乘法实现
求解思路
1.多项式表示 2. 程序框架 3. 读多项式 4. 加法实现 5. 乘法实现 6. 多项式输出
多项式的表示
仅表示非零项
数组： 编程简单、调试容易
需要事先确定数组大小
一种比较好的实现方法是: 动态数组
链表：
动态性强 编程略为复杂、调试比较困难
while (t1 && t2) {
if (t1->expon == t2->expon) {
…..
}
else if (t1->expon > t2->expon) {
……
}
else {
……
}
}
while (t1) {
return 0; }
如何读入多项式
Polynomial ReadPoly() {
…… scanf("%d", &N); …… while ( N-- ) {
scanf("%d %d", &c, &e); Attach(c, e, &Rear); } ….. return P; }
4 3 4 -5 2 6 1 -2 0
两种处理方法： 1. Rear初值为NULL
在Attach函数中根据Rear是 否为NULL做不同处理
Attach
ce
Rear (当前结果表达式尾项指针)
Rear
如何读入多项式
Polynomial ReadPoly() {
…… scanf("%d", &N); …… while ( N-- ) {
多项式的乘积: (a+b)(c+d) = ac+ad+bc+bd
数据结构链式表实现一元多项式加减乘运算课程方案实验报告
数据结构课程设计设计题目：基于链式表实现一元多项式的加减乘运算目录问题分析11.1 问题描述设计一个n元多项式程序，并完成多项式的乘法运算。
从实际的角度出发，这里设计的程序是基于一元n次多项式的数学模型。
1.2 问题的数学模型在数学上，一个一元多项式Pn(x>可按升幂写成：Pn(x>=a 0+a1 x+a2 x^2 +…+a n x^n-1.它由n+1个系数惟一确定，因此，在计算机里，它可用一个线性表P来表示：Pn=(a0,a1,a2,…,an>每一项的指数i隐含在其系数ai的序号里。
多项式的乘法规则：多次运用单项式与多项式相乘的法则得到的．计算时(a+b>(m+n>，先把(m+n>看成一个单项式，(a+b>是一个多项式，运用单项式与多项式相乘的法则，得到(a+b>(m+n>=a(m+n>+b(m+n>,然后再次运用单项式与多项式相乘的法则。
1.3 构造数据结构通过分析多项式的特征，不难看出多项式是由单项式构成的，而每个单项式都具有系数和指数，当系数为0时，该项就失去了意义，在计算机内要表示一个多项式，至少以下数据信息：系数信息、指数信息和指向下一个单项式的指针。
通过指针，我们就可以把多个单项式连接起来，形式一个多项式，需要说明的是从广义的角度讲，单项式也是一个多项式。
基于以上的分析，我们定义多项式的数据结构为如下结构体形式：typedef struct Polynomial{float coef。
//系数int expn。
//指数struct Polynomial *next。
//指向下一个结点}*Polyn,Polynomial。
//Polyn为结点指针类型2 系统分析2.1 可行性研究该程序主要从技术的角度来分析可行性。
技术上的可行性研究主要分析技术条件能否顺利完成开发工作，硬、软件能否满足开发者的需要等。
该系统采用了Windows XP操作系统结合Visual C++ 6.0,TC 2.0等软件开发平台已成熟可行。
数据结构一元多项式的运算
数据结构一元多项式的运算正文：1. 引言本文档旨在介绍数据结构中一元多项式的运算方法。
一元多项式是指在一个变量上的多项式，其中每一项由一个系数和一个指数组成。
我们将会讨论一元多项式的表示、存储和基本运算，包括多项式的加法、减法、乘法和求导等操作。
2. 一元多项式的表示和存储2.1 一元多项式的定义一元多项式是指在一个变量x上的多项式，每一项由一个系数和一个指数组成，例如：2x^3 - 5x^2 + 3x + 1.其中，2、-5、3和1分别是系数，3、2、1和0分别是指数。
2.2 一元多项式的表示方法一元多项式可以使用数组、链表或其他数据结构来表示。
在本文中，我们选择使用数组来表示一元多项式。
数组的索引代表指数，数组的元素代表系数。
例如，多项式 2x^3 - 5x^2 + 3x + 1 可以表示为 [1, 3, -5, 2]。
2.3 一元多项式的存储结构为了表示一元多项式，我们可以使用一个数组来存储多项式的系数。
数组的长度应该比多项式的最高指数大1.数组的索引代表指数，数组的元素代表系数。
例如，数组 [1, 3, -5, 2] 表示的多项式 2x^3 - 5x^2 + 3x + 1 中，索引0对应指数为3的项，索引1对应指数为2的项，以此类推。
3. 一元多项式的基本运算3.1 一元多项式的加法一元多项式的加法是指将两个多项式相加，并合并同类项。
具体操作如下：- 将两个多项式的系数相加，并将结果存储在一个新的多项式中。
- 遍历新的多项式，将相邻的相同指数的项合并。
3.2 一元多项式的减法一元多项式的减法是指将一个多项式减去另一个多项式，并合并同类项。
具体操作如下：- 将两个多项式的系数相减，并将结果存储在一个新的多项式中。
- 遍历新的多项式，将相邻的相同指数的项合并。
3.3 一元多项式的乘法一元多项式的乘法是指将两个多项式相乘，并合并同类项。
具体操作如下：- 遍历一个多项式的每一项，与另一个多项式的每一项相乘。
一元多项式的相加(数据结构)
实验报告课程名称：数据结构实验名称：一元多项式的相加班级： 1333 学生姓名：蔡景旺学号： 37一、需求分析1.用户可以根据自己的需求分别输入两个一元多项式（输入必须按指数递增顺序），并且能够实现输入的一元多项式的显示。
2.能够完成两个一元多项式的相加功能并显示结果。
3.程序执行的命令包括：（1）构造链表A （2）构造链表B （3）两个链表的相加（4）求链表的长度（5）打印（显示）已有的链表二、概要设计⒈为实现上述算法，需要线性表的抽象数据类型：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}基本操作:CreatPolyn(&p,m)操作结果：输入m项的系数和指数，建立一个一元多项式P。
DestroyPolyn(&p)初始条件：一元多项式P已存在。
操作结果：销毁一元多项式P。
PrintPolyn(P)初始条件：一元多项式P已存在。
操作结果：打印输出一元多项式P。
PolynLength(P)初始条件：一元多项式P已存在。
操作结果：返回一元多项式中P的项数。
AddPolyn(&Pa,&Pb)初始条件：一元多项式Pa和Pb已存在。
操作结果：完成一元多项式相加运算，即：Pa=Pa+Pb,销毁一元多项式Pb.}ADT Polynomailtypedef struct{ // 项的表示，多项式为linklist的数据元素float coef; //系数int evpn; //指数}term,ElemType; //两个类型名：term用于本ADT,ElemType为Linklist的数据对象名Typedef Linklist polynomial; //用带表头结点的有序链表表示多项式；Int cmp(term a,term b)；void CreatPolyn (polynomial &P,int m){//输入m项的系数和指数，建立表示一元多项式的有序链表PInitList (P); h = GetHead (P);e.coef = 0.0;e.expn = -1;SetCurElem (h,e); //设置头结点的数据元素for （i = 1;i<=m;++i）{//依次输入m项非零项scanf(e.coef,e.expn);if (! LocateElem(P,e,q,(*cmp)){ //当链表不存在指数项if(MakeNode (s,e)) InsFirst(q,s);//生成结点并插入链表}}}//CreatPolynvoid AddPolyn(polynomial &Pa, polynomial &Pb){//多项式加法：Pa=Pa+Pb，利用两个多项式的结点构成“和多项式”ha=Gethead(Pa); hb=Gethead(Pb);//ha和hb分别指向Pa和Pb的头结点qa=NextPos(Pa,ha); qb=NextPos(Pb,hb);// /ha和hb分别指向Pa和Pb的当前结点while(qa&&qb){//qa和qb均非空a=GetCurElem(qa); b=GetCurElem(qb);switch(*cmp(a,b)){case -1: //多项式PA中当前结点的指数值小ha=qa;qa= NextPos(Pa,ha);break;case 0://l两者的指数相等sum=a.cofe+b.cofe;if(sum!=0.0){//修改多项式PA中当前结点的系数值SetCurELem(qa,sum);ha=qa;}else {//删除当前结点Delfirst(ha,qa);FreeNode(qa);}Delfirst(ha,qa);FreeNode(qa); qb=NextPos(Pb,hb); qa=NextPos(Pa,ha);break;Case1://多项式PB中当前结点的指数值小DelFirst(hb,qb); InsFirst(ha,qb);qb=NextPos(Pb,hb); qa=NextPos(Pa,ha);break;}//swtich}//whileIf(!ListEmpty(Pb)) Append(Pa,qb);FreeNode(hb)://释放Pb头结点}//AddPolyn2. 数据结构分析：逻辑结构为线性表，采用链式存储结构。
数据结构课程设计一元多项式的加减法运算
武汉理工大学华夏学院课程设计报告书课程名称：数据结构与算法分析题目：用C语言实现一元多项式的加减法运算系名：信息工程系专业班级：物联网工程1122班姓名：隋明超学号： 10213312201 指导教师:司晓梅2014年 1 月 3 日武汉理工大学华夏学院信息工程系课程设计任务书课程名称：数据结构与算法分析指导教师：司晓梅班级名称：物联网1121-2 开课系、教研室：信息系计算机一、课程设计目的与任务《数据结构》课程设计是为训练学生的数据组织能力和提高程序设计能力而设置的增强实践能力的课程。
目的：学习数据结构课程，旨在使学生学会分析研究数据对象的特性，学会数据的组织方法，以便选择合适的数据的逻辑结构和存储结构以及相应操作，把现实世界中的问题转换为计算机内部的表示和处理，这就是一个良好的程序设计技能训练的过程。
提高学生的程序设计能力、掌握基本知识、基本技能，提高算法设计质量与程序设计素质的培养就是本门课程的课程设计的目的。
任务：根据题目要求，完成算法设计与程序实现，并按规定写出课程设计报告。
二、课程设计的内容与基本要求设计题目：用C语言实现一元多项式的加减法计算〔问题描述〕输入并建立两个多项式并输出多项式设计一个程序：对两个多项式进行加、减法运算，建立一个新多项式并输出。
〔实现提示〕：选择单链表存储多项式具体要完成的任务是：A. 编制完成上述问题的C语言程序、进行程序调试并能得出正确的运行结果。
B. 写出规范的课程设计报告书；三、课程设计步骤及时间进度和场地安排时间：本课程设计安排在第18周地点：现代教育中心具体时间安排如下：第一天：布置题目，确定任务、查找相关资料第二天～第四天：功能分析，编写程序，调试程序、运行系统；第五天上午：撰写设计报告；第五天下午：程序验收、答辩。
四、课程设计考核及评分标准课程设计考核将综合考虑学生的系统设计方案、运行结果、课程设计报告书的质量、态度、考勤、答辩情况等各因素。
数据结构课程设计-一元多项式的加法、减法、乘法的实现
一、设计题目一元多项式的加法、减法、乘法的实现。
二、主要内容设有一元多项式A m(x)和B n(x).A m(x)=A0+A1x1+A2x2+A3x3+… +A m x mB n(x)=B0+B1x1+B2x2+B3x3+… +B n x n请实现求M(x)= A m(x)+B n(x)、M(x)= A m(x)-B n(x)和M(x)= A m(x)×B n(x)。
要求：1) 首先判定多项式是否稀疏2) 采用动态存储结构实现；3) 结果M(x)中无重复阶项和无零系数项；4) 要求输出结果的升幂和降幂两种排列情况三、具体要求及应提交的材料1．每个同学以自己的学号和姓名建一个文件夹，如：“312009*********张三”。
里面应包括：学生按照课程设计的具体要求所开发的所有源程序（应该放到一个文件夹中）、任务书和课程设计说明书的电子文档。
2．打印的课程设计说明书（注意：在封面后夹入打印的“任务书”以后再装订）。
四、主要技术路线提示为把多个小功能结合成一个完整的小软件，需使用“菜单设计”技术（可以是控制台方式下的命令行形式，若能做成图形方式则更好）。
五、进度安排共计两周时间，建议进度安排如下：选题，应该在上机实验之前完成需求分析、概要设计可分配4学时完成详细设计可分配4学时调试和分析可分配10学时。
2学时的机动，可用于答辩及按教师要求修改课程设计说明书。
注：只用课内上机时间一般不能完成设计任务，所以需要学生自行安排时间做补充。
六、推荐参考资料(不少于3篇)［1］苏仕华等编著，数据结构课程设计，机械工业出版社，2007［2］严蔚敏等编著，数据结构（C语言版），清华大学出版社，2003［3］严蔚敏等编著，数据结构题集（C语言版），清华大学出版社，2003指导教师签名日期年月日系主任审核日期年月日摘要分析了matlab，mathmatic，maple等数学软件对一元多项式的计算过程，步骤后。
由于这些软件比较大功能齐全，但是实用性不强。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验题目：一元多项式运算班级：13级数学一班姓名：张保昌学号：2013433037 日期：2014—10—09一、需求分析1．问题描述；设计一个简单的一元稀疏多项式加减及求导运算器。
2．基本要求的功能要求；（1）输入多项式时可以按任意次序输入各项的数据（输入并建立多项式A与B），不必按指数有序；在算法中实现建立按指数有序的多项式。
（2）计算多项式A与B的和，即建立多项式A+B。
（3）按照指数升序次序，输出多项式A、B、A+B。
（4）计算多项式A与B的差，即建立多项式A－B；（5）计算多项式A的导函数Aˊ。
3．测试数据。
（1）(x+3x6－8.6x11)+(6－3x6+21x9)=6+x+21x9－8.6x11（2）(3x－3－x+4.1x2－1.2x9)＋(―3x―3－5.1x2 +7.8x12)=－x－x2－1.2x9+7.8x12（3）(x+x3)+(―x―x3)=0（4）(x+x2+x3)+0=x+x2+x3（5）(x+x2+x3)—(x+x2+x3)=0(6) (x+x2+x3)ˊ=1+2x+3x2二、概要设计1．本程序所用的抽象数据类型的定义；typedef struct pnode{double coef; /*系数域*/int exp; /*指数域*/struct pnode *next; /*指针域，*/}polynode, *polylink;polylink insert_list(polylink h,char o); //输入多项式。
polylink order_list(polylink h); //按指数升序排列polylink simply_list(polylink h); //初步整理（合并多项式，并删除系数为零的式子）polylink add(polylink a,polylink b); //加法运算polylink opposite(polylink b); //将减法统归为加法polylink derivative(polylink a); //求导函数void list_display(polylink h,char o); //输出显示void index(); //菜单函数2．模块划分。
1）主函数模块。
2）加法运算模块3）减法运算模块4）导数模块。
3．主模块的流程及各子模块的主要功能；三、详细设计1．采用c++语言定义相关的数据类型；typedef struct pnode{double coef; /*系数域*/int exp; /*指数域*/struct pnode *next; /*指针域}polynode, *polylink;2．写出各模块的伪码算法；void index() //菜单函数。
{cout<<" 一元多项式运算"<<endl<<endl;cout<<" 1.一元多项式加法"<<endl;cout<<" 2.一元多项式减法"<<endl;cout<<" 3.一元多项式导数"<<endl;cout<<" 0. 结束"<<endl<<endl<<endl; }polylink insert_list(polylink h,char o) //输入多项式{h=new polynode;double coef1;int num,expo1;polylink temp;polynode *data;temp=h;h->next =NULL;//头结点cout<<"多项式"<<o<<"的项数: ";cin>>num;for(int i=1;i<=num;i++){cout<<"请输入第"<<i<<"项"<<endl;cout<<"系数:";cin>>coef1;cout<<"指数:";cin>>expo1;data=new polynode;data->coef=coef1;data->exp =expo1;data->next =NULL;temp->next =data;temp=data;}return h;}polylink simply_list(polylink h) //初步化简，系数无0，无重复指数{polylink p,q,r,k;p=h->next ;if(!p)return h; //空表while(p){k=p;q=k->next ;while(q){if(q->exp==p->exp ){r=q;q=q->next ;p->coef +=r->coef ;k->next =r->next ;delete r;}else{q=q->next ;k=k->next;}}p=p->next ;}k=h;q=h->next ;while(q){if( q ->coef==0){r=q;q=q->next ;k->next =r->next ;delete r;}else{q=q->next ;k=k->next ;}}}void list_display(polylink h,char o) //显示多项式{polylink p;double coef1;int expo1,i=0;p=h->next ;if(!p){cout<<"多项式"<<o<<" : 0 "<<endl;}elsecout<<"多项式"<<o<<" : ";while(p){coef1=p->coef ;expo1=p->exp ;if(i==0){if(expo1==0){i=1;cout<<coef1;}else if(expo1==1){i=1;if(coef1==1)cout<<"X";else if(coef1==-1)cout<<"-X";elsecout<<coef1<<"X";}else{i=1;if(coef1==1)cout<<"X^"<<expo1;else if(coef1==-1)cout<<"-X^"<<expo1;elsecout<<coef1<<"X^"<<expo1;}else{if(expo1==1){if(coef1==1)cout<<"+X";else if(coef1==-1)cout<<"-X";else if(coef1>0)cout<<"+"<<coef1<<"X";elsecout<<coef1<<"X";}else{if(coef1==-1)cout<<"-X^"<<expo1;else if(coef1==1)cout<<"+X^"<<expo1;else if(coef1>0)cout<<"+"<<coef1<<"X^"<<expo1;elsecout<<coef1<<"X^"<<expo1;}}p=p->next ;}cout<<endl;}polylink order_list(polylink h) //升序排列{polynode temp;polylink p,q,r;p=h->next;if(!p)return h;while(p->next){q=p->next ;r=p;while(q){if(q->exp <r->exp )r=q;q=q->next ;}temp.coef =r->coef ;temp.exp =r->exp ;r->coef =p->coef ;r->exp =p->exp ;p->coef =temp.coef ;p->exp =temp.exp ;p=p->next ;}return h;}polylink add(polylink ha,polylink hb)//加法{polylink a;a=ha;while(a->next )a=a->next ;a->next =hb->next ;delete hb;ha=simply_list(ha);ha=order_list(ha);return ha;}polylink opposite(polylink b){polylink hb;hb=b->next;while(hb){hb->coef =(-1)*hb->coef;hb=hb->next ;}return b;}polylink derivative(polylink a)//求导{polylink ha;ha=a->next ;while(ha){ha->coef *=ha->exp ;ha->exp --;ha=ha->next ;}return a;}四、调试分析1．调试中遇到的问题及对问题的解决方法；指针指向的错误。
导致程序无法正常运行，经过逐步调试，发现了问题，认真分析指针指向的内存空间。