多项式运算(数据结构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环境中调试运行。

数据结构 多项式乘法

数据结构 多项式乘法

实习报告一、实习题:请写出计算两个以单链接表表示的多项式相乘的程序。

1.需求分析和说明两个多项式相乘,可以利用两个多项式的加法来实现,因为乘法运算可以分解为一系列的加法运算:C(x)=A(x)*B(x)=A(x)*(b1x+b2x2+…+b n x n)=∑=niii xbxA1)(先用其中一个多项式去乘以另一个多项式的每一项,得出的若干个多项式按照一定的顺序相加,即幂不同的按照升幂排列,幂相同的将系数相加。

例如:对于(X->1+2X->2)*(2X->2+4X->3).X->1*(2X->2+4X->3)=2X->3+4X->4;2X->2*(2X->2+4X->3)=4X->4+8X->5;排列结果:2X->3+8X-4+8X->52.设计用两个单链表的存储两个多项式,每个结点包含单项式的系数,幂和指向下一个元素地址的指针。

用其中的一个多项式乘以另一个多项式的每一项,随后将所得结果按照升幂顺序排列,最后得到结果。

存储结构://单项式结构struct Term {float coef; // 系数。

int exp; // 幂指数。

Term( float c, int e) { coef = c; exp = e;}Term( ) { }friend int operator == (const Term & L, const Term & T ) { return L.exp == T.exp; }friend int operator > (const Term & L, const Term & T ) { return L.exp > T.exp; }friend int operator < (const Term & L, const Term & T ) { return L.exp < T.exp; }friend Term & operator += ( Term & L, const Term & T ){ L.coef += T.coef; return L; } //幂指数相同,则系数相加。

数据结构C语言实现多项式源代码

数据结构C语言实现多项式源代码

一、一元稀疏多项式计算器#include<stdio.h>#include<stdlib.h>#include<malloc.h>#define OK 1#define ERROR 0#define OVERFLOW -1typedef int Status;#define LIST_INIT_SIZE 51 //假设次数不超过50typedef struct{//coef表示系数,expo表示指数。

float coef;int expo;}ElemType;typedef struct LNode{ //结点类型ElemType data;struct LNode *next;}LNode,*LinkList;//记:Link与Position均为指向LNode的指针类型typedef LinkList Polynomail;//在单链表的基础上定义并实现//多项式用链表存储Status CreateList_L(LinkList &L){int n;printf("请输入需创建的多项式的长度:\n");scanf("%d",&n);LNode *CurPtr,*PrePtr;//创建递增链表L=(LinkList) malloc(sizeof(LNode));L->next=NULL;if(!L) exit(OVERFLOW);PrePtr=L;for(int i=1;i<=n;++i){CurPtr=(LNode *)malloc(sizeof(LNode));printf("请输入不同的多项式的非0系数:");scanf("%f",&(CurPtr->data).coef );printf("请输入不同的多项式的指数:");scanf("%d",&(CurPtr->data).expo );CurPtr->next=NULL;PrePtr->next=CurPtr;PrePtr=PrePtr->next;//插入到表头}CurPtr->next =L;//冒泡排序法对多项式按指数由大到小排列。

数据结构一元多项式的运算

数据结构一元多项式的运算

数据结构一元多项式的运算正文: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 一元多项式的乘法一元多项式的乘法是指将两个多项式相乘,并合并同类项。

具体操作如下:- 遍历一个多项式的每一项,与另一个多项式的每一项相乘。

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

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

数据结构-c语言描述(第二版)答案耿国华编著

数据结构-c语言描述(第二版)答案耿国华编著

第 3 章 限定性线性表 — 栈和队列
第三章答案
1 按 3.1(b)所示铁道(两侧铁道均为单向行驶道)进行车厢调度,回答: (1) 如进站的车厢序列为 123,则可能得到的出站车厢序列是什么? (2) 如进站的车厢序列为 123456,能否得到 435612 和 135426 的出站序列,并说 明原因(即写出以“S”表示进栈、 “X ”表示出栈的栈序列操作) 。 【解答】 (1)可能得到的出站车厢序列是:123、132、213、231、321。 (2)不能得到 435612 的出站序列。 因为有 S(1)S(2)S(3)S(4)X(4)X(3)S(5)X(5)S(6)S(6),此时按照“后进先出”的原 则,出栈的顺序必须为 X(2)X(1)。 能得到 135426 的出站序列。 因为有 S(1)X(1)S(2)S(3)X(3)S(4)S(5)X(5)X(4)X(2)X(1)。 3 给出栈的两种存储结构形式名称,在这两种栈的存储结构中如何判别栈空与栈满? 【解答】 (1)顺序栈 (top 用来存放栈顶元素的下标) 判断栈 S 空:如果 S->top==-1 表示栈空。 判断栈 S 满:如果 S->top==Stack_Size-1 表示栈满。 (2) 链栈(top 为栈顶指针,指向当前栈顶元素前面的头结点) 判断栈空:如果 top->next==NULL 表示栈空。 判断栈满:当系统没有可用空间时,申请不到空间存放要进栈的元素,此时栈满。
2.选择题
(1) A (2) 已知 L 是无表头结点的单链表,且 P 结点既不是首元素结点,也不是尾元素结点。按要 求从下列语句中选择合适的语句序列。 a. 在 P 结点后插入 S 结点的语句序列是:E 、A。 b. 在 P 结点前插入 S 结点的语句序列是:H、L、I 、E、A 。 c. 在表首插入 S 结点的语句序列是:F 、M。 d. 在表尾插入 S 结点的语句序列是:L、J 、A、G。 供选择的语句有: A P->next=S; B P->next= P->next->next; C P->next= S->next; D S->next= P->next; E S->next= L; F S->next= NULL; G Q= P; H while (P->next!=Q) P=P->next; I while (P->next!=NULL) P=P->next; J P= Q; K P= L; L L= S;第1章Fra bibliotek绪 论

c语言编写程序求多项式的方法

c语言编写程序求多项式的方法

c语言编写程序求多项式的方法多项式是数学中常见的表达式形式,由一系列项组成。

每个项包含一个系数和一个指数,其中系数是常数,指数是变量的幂。

在C语言中,我们可以编写程序来求解多项式,并计算其值。

首先,我们需要定义一个结构体来表示多项式的每个项,包含两个成员:系数和指数。

```ctypedef struct {float coefficient;int exponent;} Term;```接下来,我们可以编写一个函数来输入多项式,用户可以通过输入系数和指数来构建多项式。

函数将返回一个包含多项式的数组。

```cTerm* inputPolynomial(int termCount) {Term* polynomial = malloc(termCount * sizeof(Term));printf("请输入每个项的系数和指数:\n");for (int i = 0; i < termCount; i++) {printf("第 %d 项的系数:", i + 1);scanf("%f", &polynomial[i].coefficient);printf("第 %d 项的指数:", i + 1);scanf("%d", &polynomial[i].exponent);}return polynomial;}```然后,我们可以编写一个函数来计算多项式的值,在该函数中,我们将多项式的每一项与给定的变量值相乘,并将所有项的结果相加。

```cfloat calculatePolynomialValue(Term* polynomial, int termCount, float x) {float result = 0;for (int i = 0; i < termCount; i++) {float termResult = polynomial[i].coefficient * pow(x, polynomial[i].exponent);result += termResult;}return result;}```最后,我们还可以编写一个函数来输出多项式的表达式。

c语言求解多项式

c语言求解多项式

c语言求解多项式多项式是数学中的一个重要概念,也是计算机科学中常用的数据结构之一。

在C语言中,我们可以使用数组来表示多项式,并通过相应的算法来求解多项式。

我们来了解一下什么是多项式。

多项式是由一系列项构成的代数表达式,每个项由一个系数和一个指数组成。

例如,2x^3 + 3x^2 - 4x + 1就是一个多项式,其中的项分别是2x^3、3x^2、-4x和1。

在C语言中,我们可以使用数组来表示多项式。

假设我们要表示一个3次多项式,可以使用一个长度为4的数组来存储多项式的系数,数组的下标对应着项的指数。

例如,数组poly[4]可以表示一个3次多项式,其中poly[0]表示常数项的系数,poly[1]表示x的系数,poly[2]表示x^2的系数,poly[3]表示x^3的系数。

接下来,我们来看一下如何求解多项式。

常见的求解多项式的方法有两种:代入法和霍纳法。

代入法是将多项式中的每一项代入给定的值,然后将所有项的结果相加。

例如,对于多项式2x^3 + 3x^2 - 4x + 1,如果要求解x=2时的值,可以将2代入多项式中的每一项,然后将结果相加,即2*2^3 + 3*2^2 - 4*2 + 1 = 17。

代入法的思路比较直观,但对于高次多项式来说,计算量较大。

霍纳法是一种更高效的求解多项式的方法。

它利用了多项式的等价变形,将多项式从左到右递推求解。

对于多项式a0 + a1x +a2x^2 + ... + anx^n,霍纳法的求解过程如下:1. 从右到左遍历多项式的系数,将当前系数乘以给定的值x,并加上前一个结果;2. 重复上述步骤,直到遍历完所有系数,得到最终结果。

例如,对于多项式2x^3 + 3x^2 - 4x + 1,如果要求解x=2时的值,可以按照霍纳法的步骤进行计算:1. 先将最高次项系数2与给定的值2相乘,得到4;2. 将上一步的结果4与次高次项系数3相加,得到7;3. 将上一步的结果7与次次高次项系数-4相乘,得到-28;4. 将上一步的结果-28与最低次项系数1相加,得到-27。

数据结构一元多项式的运算

数据结构一元多项式的运算

数据结构一元多项式的运算第一章引言在计算机科学中,数据结构是研究非原子数据对象的组织、存储和管理的科学和技术。

一元多项式是代数中的基本概念之一,它在计算机科学中有着广泛的应用。

本文将介绍一元多项式的运算,包括多项式的表示、加法、减法、乘法等操作。

第二章多项式的表示1.稀疏数组表示法稀疏数组表示法是一种常用的多项式表示方法。

它通过一个数组来存储多项式中非零项的指数和系数。

数组的下标表示项的指数,数组元素表示项的系数。

对于没有出现的指数,数组元素为零。

2.链表表示法链表表示法是另一种常用的多项式表示方法。

每个节点包含项的指数和系数,并通过指针串接成链表。

链表的节点可以按照指数的升序或降序排列。

第三章多项式的加法多项式的加法是指将两个多项式相加得到一个新的多项式。

具体操作如下:1.根据多项式的表示方法,分别遍历两个多项式的非零项。

2.比较当前项的指数大小,如果两个指数相等,则将系数相加得到新的系数,并将结果加入结果多项式中。

3.如果一个多项式的指数大于另一个多项式的指数,则将该项加入结果多项式中。

4.重复以上操作,直到遍历完所有的非零项。

第四章多项式的减法多项式的减法是指将两个多项式相减得到一个新的多项式。

具体操作如下:1.根据多项式的表示方法,分别遍历被减数和减数的非零项。

2.比较当前项的指数大小,如果两个指数相等,则将被减数的系数减去减数的系数得到新的系数,并将结果加入结果多项式中。

3.如果被减数的指数大于减数的指数,则将该项加入结果多项式中,并将被减数的系数变为相反数。

4.重复以上操作,直到遍历完所有的非零项。

第五章多项式的乘法多项式的乘法是指将两个多项式相乘得到一个新的多项式。

具体操作如下:1.创建一个结果多项式,将其初始化为零多项式。

2.根据多项式的表示方法,分别遍历两个多项式的非零项。

3.将两个项的系数相乘得到新的系数,并将两个项的指数相加得到新的指数。

4.将新的系数和指数合并为一个项,并将该项加入结果多项式中。

多项式的四则运算

多项式的四则运算

摘要在算法程序的设计与编写过程中,根据对本题的要求分析,结合设计对象的特点,实现一元多项式的加、减、乘、除以及对多项式求导、求值的相关计算。

根据一元多项式的结构特点和运算规则。

本程序中采用了链表的存储与实现,采用链表可以很方便的对其中的结点进行插入、删除等操作。

通过链表的合并即可完成多项式的四则运算。

1 引言:1.1 待处理问题的问题背景:本题要求对从键盘上输入的任意两个一元多项式,能够分别对每个多项式进行降幂排序并输出,实现对这两个多项式的加、减、乘、除等相关运算。

在具体实现时,可采用链式存储结构将多项式中的每一项连接起来,从而表达出整个多项式,其中每一项是一个一元多项式,通过每一项系数与指数的输入设定,可以实现对整个多项式的设定,再通过建立单链表,结点来存储每一项的系数与指数,通过链表完成多项式的存储,对每个多项式分别建立一个链表,通过链表的加减乘除运算规则实现连标的合并,最终得到计算结果。

2需要完成的任务:根据题目要求,本程序需要实现对两个一元多项式的四则运算以及对多项式进行赋值求值运算、求导运算等相关计算,要求正确输出运算结果,对不满足输入要求的数据有一定的反应。

3设计:3.1核心算法的设计与说明:3.1.1 一元多项式的定义:有多个单项式的代数和就构成了多项式,一元多项式就是只含有一个变元的多项式。

所以由定义可知有n个单项式组成的一元多项式来说,它的运算是满足交换率的,所以可进行降幂排序,只需将它的所有指数相比较,然后将指数大的放前面,小的放后面即可完成排序。

3.1.2本题的核心算法:首先调用建表函数,CreatePolyn建立两个一元多项式,然后对两个一元多项式进行降幂排序,该过程的实现主要由insert()函数实现,然后调用相应的计算函数: 加(AddPolyn)、减(SubtractPolyn)、(MultiplyPolyn)、除(DevicePolyn)、导数(Derivative)、求值(ValuePolyn)。

C语言多项式运算

C语言多项式运算

C语⾔多项式运算#include#include#includetypedef struct PolyNode{float coef; //系数int expn; //指数struct PolyNode *next;}LNode,*LinkList;LNode *MakeNode(float coef, int expn){ LNode *p;p=(LNode*)malloc(sizeof(LNode));p->coef=coef; p->expn=expn; p->next=NULL; return p;}void InitList(LinkList &L){L=MakeNode(0,-1);return;}void PrintPolyn(LinkList L){LNode *p;if(!L)printf("NULL\n");else if(L->next==NULL)printf("0\n");else{p=L->next;while(p){printf("%gX^%d",p->coef,p->expn);p=p->next;if(p&&p->coef>0)printf("+");}printf("\n");}}void OrderInsert(LinkList L, LNode *s){LNode *p,*q;p=L;while(p->next && p->next->expnexpn) p=p->next; if(p->next && p->next->expn==s->expn){p->next->coef+=s->coef;if(p->next->coef==0){q=p->next;p->next=q->next;free(q);}free(s);}else{s->next=p->next;p->next=s;}}LinkList creatlist(void){LinkList head;LNode *p;float c; int e;InitList(head);printf("输⼊系数指数,系数为0时结束:");while(1){scanf("%f",&c);if(c==0)break;scanf("%d",&e);p=MakeNode(c,e);OrderInsert(head,p);}return head;}void DestroyPolyn(LinkList &L){LNode *p=L,*q;while(p){q=p->next;free(p); p=q;}L=NULL;}void ClearPolyn(LinkList &L){LNode *p,*q;if(L==NULL) return;p=L->next; L->next=NULL;while(p){q=p->next;free(p); p=q;}}void CopyPolyn(LinkList La, LinkList &Lb){LNode *p,*r;if(!La) return;InitList(Lb);r=Lb;p=La->next;while(p){r->next=MakeNode(p->coef,p->expn);r=r->next;p=p->next;}r->next=NULL;}void AddPolyn(LinkList La,LinkList Lb,LinkList &Lc){ LNode *p,*q,*r; InitList(Lc);if(!Lc) return;p=La->next;q=Lb->next;r=Lc;while(p!=NULL&&q!=NULL){r->next=(LNode*)malloc(sizeof(LNode)); if(p->expn==q->expn){r->next->coef=p->coef+q->coef;r->next->expn=p->expn;r=r->next;p=p->next;q=q->next;}else if(p->expn>q->expn){r->next->coef=q->coef;r->next->expn=q->expn;q=q->next;r=r->next;}else{r->next->coef=p->coef;r->next->expn=p->expn;p=p->next;r=r->next;}}if(q==NULL){while(p!=NULL){printf("4\n");r->next=(LNode*)malloc(sizeof(LNode)); r->next->coef=p->coef;r->next->expn=p->expn;r=r->next;p=p->next;}}if(p==NULL){while(q!=NULL){printf("5\n");r->next=(LNode*)malloc(sizeof(LNode));q=q->next;}}r->next=NULL;}void SubPolyn(LinkList La,LinkList Lb,LinkList &Lc){ LNode *p,*q,*r,*h; float min;InitList(Lc);if(!Lc) return;p=La->next;q=Lb->next;r=Lc;while(p!=NULL&&q!=NULL){r->next=(LNode*)malloc(sizeof(LNode));if(p->expn==q->expn){min=p->coef-q->coef;if(min!=0){r->next->coef=min;r->next->expn=p->expn;r=r->next;p=p->next;q=q->next;}else {h=r->next;free(h);p=p->next;q=q->next;}}else if(p->expn>q->expn){printf("2\n");r=r->next;}else{printf("3\n");r->next->coef=p->coef;r->next->expn=p->expn;p=p->next;r=r->next;}}if(q==NULL){while(p!=NULL){printf("4\n");r->next=(LNode*)malloc(sizeof(LNode)); r->next->coef=p->coef;r->next->expn=p->expn;r=r->next;p=p->next;}}if(p==NULL){while(q!=NULL){r->next=(LNode*)malloc(sizeof(LNode)); r->next->coef=-q->coef;r->next->expn=q->expn;r=r->next;q=q->next;}r->next=NULL;}double SumPolyn(LinkList La,double &x){ double Sum=0;if(!La) printf("error");p=La->next;while(p){Sum+=p->coef*pow(x,p->expn);p=p->next;}return Sum;}void DaoShuPolyn(LinkList La,LinkList &Lb,int &x){ LNode *p,*q,*k; int i;CopyPolyn(La,Lb);if(!La||!Lb) printf("error");p=La;q=Lb;for(i=0;iwhile(q){if(q->next&&q->next->expn>0){q->next->coef=q->next->coef*q->next->expn;q->next->expn=q->next->expn-1;q=q->next;}else {if(q->next&&q->next->expn==0){k=q->next;q->next=k->next;free(k);}else q=q->next;}}q=Lb;}}void JifenPolyn(LinkList La,LinkList &Lb,int &x){int i;CopyPolyn(La,Lb);if(!La||!Lb) printf("error");p=La;q=Lb;for(i=0;iwhile(q->next){q->next->expn=q->next->expn+1;q->next->coef=q->next->coef/q->next->expn;q=q->next;}q=Lb;}}double DingJifenPolyn(LinkList La,int &w,double &a,double &b){ LinkList Lb; double A;JifenPolyn(La,Lb,w);A=SumPolyn(Lb,a)-SumPolyn(Lb,b);return A;}void MulityPolyn(LinkList La,LinkList Lb,LinkList &Lc){LNode *p,*q,*r;LinkList Lr;InitList(Lr);InitList(Lc);r=Lr;p=La;q=Lb;if(!La||!Lb||!Lc) printf("error");while(p->next){while(q->next){r=(LNode*)malloc(sizeof(LNode));r->coef=p->next->coef*q->next->coef;r->expn=p->next->expn+q->next->expn;OrderInsert(Lc,r);q=q->next;}p=p->next;q=Lb;}}void PowPolyn(LinkList La,LinkList &Lb,int v){ CopyPolyn(La,Lb);int i=0;for(i=0;iMulityPolyn(La,Lb,Lb);}}#define N 15void main(){LinkList P[N]={NULL};int i,j,k,menu;while(1){printf("\n");printf(" 0 -- Exit\n");printf(" 1 -- Create\n");printf(" 2 -- Print\n");printf(" 3 -- Copy\n");printf(" 4 -- Add\n");printf(" 5 -- Sub\n");printf(" 6 -- Destroy\n");printf(" 7 -- Clear\n");printf(" 8 -- Sum\n");printf(" 9 -- DaoShu\n");printf(" 10 -- Mulity\n");printf(" 11 -- Jifen\n");printf(" 12 -- DingJifen\n");printf(" 13 -- Pow\n");printf("\n Please Choose: ");scanf("%d",&menu);switch(menu){case 0: return;case 1:printf("输⼊新多项式的下标(0--%d): ",N-1);scanf("%d",&i);P[i]=creatlist();break;case 2:for(i=0;iprintf(" P[%d] = ",i);PrintPolyn(P[i]);}break;case 3:printf("输⼊被复制的多项式和新多项式的下标(0--%d): ",N-1); scanf("%d%d",&i,&j);CopyPolyn(P[i],P[j]);break;case 4:printf("输⼊两相加的多项式的和⽣成多项式的下标(0--%d)",N-1); scanf("%d%d%d",&i,&j,&k);AddPolyn(P[i],P[j],P[k]);break;case 5:printf("输⼊两相减的多项式和⽣成多项式的下标(0--%d)",N-1); scanf("%d%d%d",&i,&j,&k);SubPolyn(P[i],P[j],P[k]);break;case 6:printf("输⼊被销毁多项式的下标(0--%d): ",N-1);scanf("%d",&i);DestroyPolyn(P[i]);break;case 7:printf("输⼊被清空多项式的下标(0--%d): ",N-1);scanf("%d",&i);ClearPolyn(P[i]);break;case 8:double Sum,x;printf("输⼊要求多项式的下标(0--%d)和x的值",N-1);scanf("%d%lf",&i,&x);Sum=SumPolyn(P[i],x);printf("Sum=%lf",Sum);break;case 9:int y;printf("输⼊要求导的多项式下标和求导后多项式下标(0--%d)以及求导次数y\n",N-1);scanf("%d%d%d",&i,&j,&y);DaoShuPolyn(P[i],P[j],y);break;case 10:printf("输⼊两个相乘多项式的下标和⽣成多项式的下标(0--%d)",N-1);scanf("%d%d%d",&i,&j,&k);MulityPolyn(P[i],P[j],P[k]);break;case 11:int z;printf("输⼊要积分的多项式下标和积分后的多项式下标(0--%d)以及积分的次数z\n",N-1); scanf("%d%d%d",&i,&j,&z);JifenPolyn(P[i],P[j],z);break;case 12:int w;double a,b,S;printf("输⼊要积分的多项式下标(0--%d)以及积分的次数w,以及上下限a,b\n",N-1); scanf("%d%d%lf%lf",&i,&w,&a,&b);S=DingJifenPolyn(P[i],w,a,b);printf("积分后的值S=%lf",S);break;case 13:int v;printf("输⼊要乘⽅的多项式下标和乘⽅后的多项式下标(0--%d)以及乘⽅次数v\n",N-1); scanf("%d%d%d",&i,&j,&v);PowPolyn(P[i],P[j],v);break;default: ;}}}。

数据结构 多项式的表示和实现方法

数据结构 多项式的表示和实现方法

数据结构多项式的表示和实现方法摘要:1.多项式的基本概念2.多项式的表示方法a.系数矩阵表示b.字符串表示c.列表表示3.多项式的基本操作a.加法b.减法c.乘法d.除法4.多项式的实现方法a.递归实现b.循环实现c.迭代实现5.多项式的应用场景a.数值计算b.符号计算c.算法设计分析6.多项式的优缺点分析7.总结与展望正文:一、多项式的基本概念多项式作为数学中的重要概念,广泛应用于各个领域。

它是由一系列项组成的代数式,其中每个项包含一个常数系数和一个或多个变量,这些变量之间的运算符为加法或减法。

多项式的项按照幂次从高到低排列,同一幂次的项按照系数从大到小排列。

二、多项式的表示方法1.系数矩阵表示:将多项式的系数组成一个矩阵,其中行表示多项式的次数,列表示多项式的项数。

例如,二次多项式f(x)=ax+bx+c可以表示为:| a b c || 0 1 0 |2.字符串表示:将多项式的各项用字符串表示,如f(x)=ax+bx+c可以表示为"a*x+b*x+c"。

3.列表表示:将多项式的各项用列表表示,如[a, b, c, 0]。

三、多项式的基本操作1.加法:将两个多项式对应的项相加,保持幂次不变,系数相加。

2.减法:将两个多项式对应的项相减,保持幂次不变,系数相减。

3.乘法:将两个多项式按照乘法法则相乘,得到一个新的多项式。

4.除法:将一个多项式除以另一个多项式,得到一个新的多项式。

四、多项式的实现方法1.递归实现:利用多项式的定义,将多项式分解为单项式,然后通过递归实现加法、减法、乘法和除法。

2.循环实现:利用循环结构,如for循环或while循环,遍历多项式的各项,实现加法、减法、乘法和除法。

3.迭代实现:利用迭代器,如ListIterator,遍历多项式的各项,实现加法、减法、乘法和除法。

五、多项式的应用场景1.数值计算:多项式在数值计算中具有重要作用,如求解线性方程组、非线性方程组和微分方程等。

数据结构_c语言描述(第二版)答案_耿国华_西安电子科技大学(完整资料).doc

数据结构_c语言描述(第二版)答案_耿国华_西安电子科技大学(完整资料).doc

【最新整理,下载后即可编辑】第1章 绪 论2.(1)×(2)×(3)√3.(1)A (2)C (3)C5.计算下列程序中x=x+1的语句频度for(i=1;i<=n;i++)for(j=1;j<=i;j++)for(k=1;k<=j;k++) x=x+1;【解答】x=x+1的语句频度为:T(n)=1+(1+2)+(1+2+3)+……+(1+2+……+n )=n(n+1)(n+2)/66.编写算法,求 一元多项式p n (x)=a 0+a 1x+a 2x 2+…….+a n x n 的值p n (x 0),并确定算法中每一语句的执行次数和整个算法的时间复杂度,要求时间复杂度尽可能小,规定算法中不能使用求幂函数。

注意:本题中的输入为a i (i=0,1,…n)、x 和n,输出为P n (x 0)。

算法的输入和输出采用下列方法(1)通过参数表中的参数显式传递(2)通过全局变量隐式传递。

讨论两种方法的优缺点,并在算法中以你认为较好的一种实现输入输出。

【解答】(1)通过参数表中的参数显式传递优点:当没有调用函数时,不占用内存,调用结束后形参被释放,实参维持,函数通用性强,移置性强。

缺点:形参须与实参对应,且返回值数量有限。

(2)通过全局变量隐式传递优点:减少实参与形参的个数,从而减少内存空间以及传递数据时的时间消耗缺点:函数通用性降低,移植性差算法如下:通过全局变量隐式传递参数PolyValue(){ int i,n;float x,a[],p;printf(“\nn=”);scanf(“%f”,&n);printf(“\nx=”);scanf(“%f”,&x);for(i=0;i<n;i++)scanf(“%f ”,&a[i]); /*执行次数:n次*/p=a[0];for(i=1;i<=n;i++){ p=p+a[i]*x; /*执行次数:n次*/x=x*x;}printf(“%f”,p);}算法的时间复杂度:T(n)=O(n)通过参数表中的参数显式传递float PolyValue(float a[ ], float x, int n){float p,s;int i;p=x;s=a[0];for(i=1;i<=n;i++){s=s+a[i]*p; /*执行次数:n次*/p=p*x;}return(p);}算法的时间复杂度:T(n)=O(n)第2章线性表习题1.填空:(1)在顺序表中插入或删除一个元素,需要平均移动一半元素,具体移动的元素个数与插入或删除的位置有关。

数据结构C语言版 抽象数据类型Polynomial一元多项式的实现文库

数据结构C语言版 抽象数据类型Polynomial一元多项式的实现文库

/*数据结构C语言版抽象数据类型Polynomial一元多项式的实现P42-43编译环境:Dev-C++ 4.9.9.2日期:2011年2月10日*/#include <stdio.h>#include <malloc.h>#include <stdlib.h>// 抽象数据类型Polynomial一元多项式的实现typedef struct // 项的表示,多项式的项作为LinkList的数据元素{float coef; // 系数int expn; // 指数}term, ElemType;// 两个类型名:term用于本ADT,ElemType为LinkList的数据对象名typedef struct LNode // 结点类型{ElemType data;struct LNode *next;}LNode,*Link,*Position;typedef struct _LinkList // 链表类型{Link head,tail; // 分别指向线性链表中的头结点和最后一个结点int len; // 指示当前线性链表中数据元素的个数}LinkList;typedef LinkList polynomial;#define DestroyPolyn DestroyList#define PolynLength ListLength// 已知p指向线性链表L中的一个结点,返回p所指结点的直接前驱的位置// 若无前驱,则返回NULLPosition PriorPos(LinkList L,Link p){Link q;q=L.head->next;if(q==p) // 无前驱return NULL;else{while(q->next!=p) // q不是p的直接前驱q=q->next;return q;}}// 若升序链表L中存在与e满足判定函数compare()取值为0的元素,则q指示L中// 第一个值为e的结点的位置,并返回1;否则q指示第一个与e满足判定函数// compare()取值>0的元素的前驱的位置。

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

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

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

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

多项式相加数据结构

多项式相加数据结构

多项式相加数据结构1. 引言在数学中,多项式是一种重要的代数表达式,由若干项的和组成。

每一项包含一个系数和一个指数,并且可以是变量的多项式。

在计算机科学中,我们需要设计一种有效的数据结构来表示和计算多项式的相加运算。

本文将介绍一种用于多项式相加的数据结构,通过分析其设计原理和实现方法,展示了该数据结构的优势。

2. 问题描述多项式相加是指将两个或多个多项式相加得到一个新的多项式。

每个多项式由一系列项组成,每项包含一个系数和一个指数。

例如,多项式 P = 2x^2 + 3x + 1 和多项式 Q = 4x^3 + 2x^2 + 5 可以相加得到多项式 R = 4x^3 + 4x^2 + 3x + 6。

我们需要一个数据结构来高效地表示和计算多项式相加的运算结果。

3. 设计思路为了实现多项式相加的功能,我们可以设计一个多项式类,其中每个多项式都由一组项组成,每个项包含一个系数和一个指数。

以下是该数据结构的设计思路:3.1 多项式类多项式类由一组项组成,我们可以使用数组或链表来存储这些项。

每个项包含一个系数和一个指数,我们可以使用一个结构体或类来表示每个项。

多项式类可以包含以下方法:•addTerm(coefficient, exponent): 向多项式中添加一个新的项,参数为系数和指数。

•removeTerm(exponent): 从多项式中移除指定指数的项。

•getTerm(exponent): 获取多项式中指定指数的项。

•getDegree(): 获取多项式的最高次数。

•add(other): 将另一个多项式加到当前多项式中。

•multiply(other): 将另一个多项式乘以当前多项式。

3.2 项类项类由一个系数和一个指数组成。

我们可以使用一个结构体或类来表示每个项,具体实现可以根据需要进行选择。

4. 数据结构实现基于上述设计思路,我们可以实现多项式相加的数据结构。

以下是该数据结构的详细实现步骤:4.1 多项式类的实现1.使用一个数组或链表来存储多项式的项。

数据结构-C语言描述(第二版)(耿国华)章 (2)

数据结构-C语言描述(第二版)(耿国华)章 (2)
第2章 线 性 表 第2章 线性表
2.1 线性表的概念及运算 2.2 线性表的顺序存储 2.3 线性表的链式存储 2.4 一元多项式的表示及相加
第2章 线 性 表 2.1 线性表的概念及运算
2.1.1 线性表的逻辑结构 线性表是n个类型相同的数据元素的有限序列,数据元素之
间是一对一的关系,即每个数据元素最多有一个直接前驱和一 个直接后继,如图2.1所示。例如:英文字母表(A,B,…, Z)就是一个简单的线性表,表中的每一个英文字母是一个数据 元素,每个元素之间存在唯一的顺序关系,如在英文字母表字 母B的前面是字母A,而字母B的后面是字母C。在较为复杂的线 性表中,数据元素(data elements)可由若干数据项组成,如 学生成绩表中,每个学生及其各科成绩是一个数据元素,它由 学号、姓名、各科成绩及平均成绩等数据项(item组成,常被称 为一个记录(record) ,含有大量记录的线性表称为文件(file)。 数据对象(dataobject)是性质相同的数据元素集合。
第2章 线 性 表
假设线性表中有n个元素,每个元素占k个单元,第 一个元素的地址为loc(a1),则可以通过如下公式计算出第i 个元素的地址loc(a -i):
loc(ai) =loc(a1)+(i-1)×k 其中loc(a -2.2 顺序表存储示意图
第2章 线 性 表
操作前提: 1≤i≤ListLength(L)。
表L已存在且非空,
操作结果: 删除L的第i个数据元素, 并用e返回其值, L的长度减1。
} ADT LinearList
第2章 线 性 表 2.2 线性表的顺序存储
2.2.1 线性表的顺序存储结构
线性表的顺序存储是指用一组地址连续的存储单元依 次存储线性表中的各个元素,使得线性表中在逻辑结构 上相邻的数据元素存储在相邻的物理存储单元中,即通过数据元 素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系。 采用顺序存储结构的线性表通常称为顺序表。

数据结构C语言版讲义

数据结构C语言版讲义

第一章绪论第一节什么是数据结构?估猜以下软件的共性:学生信息管理、图书信息管理、人事档案管理。

数学模型:用符号、表达式组成的数学结构,其表达的内容与所研究对象的行为、特性基本一致。

信息模型:信息处理领域中的数学模型。

数据结构:在程序设计领域,研究操作对象及其之间的关系和操作。

忽略数据的具体含义,研究信息模型的结构特性、处理方法。

第二节概念、术语一、有关数据结构的概念数据:对客观事物的符号表示。

例:生活中还有什么信息没有被数字化?身份证,汽车牌号,电话号码,条形代码……数据元素:数据的基本单位。

相当于"记录"。

一个数据元素由若干个数据项组成,相当于"域"。

数据对象:性质相同的数据元素的集合。

数据结构:相互之间存在特定关系的数据集合。

四种结构形式:集合、线性、树形、图(网)状形式定义:(D,S,P)D:数据元素的集合(数据对象)S:D上关系的有限集P:D上的基本操作集逻辑结构:关系S描述的是数据元素之间的逻辑关系。

存储结构:数据结构在计算机中的存储形式。

顺序映象、非顺序映象、索引存储、哈希存储逻辑结构与存储结构的关系:逻辑结构:描述、理解问题,面向问题。

存储结构:便于机器运算,面向机器。

程序设计中的基本问题:逻辑结构如何转换为存储结构?二、有关数据类型的概念数据类型:值的集合和定义在该值集上的一组操作的总称。

包括:原子类型、结构类型。

抽象数据类型(ADT):一个数学模型及该模型上的一组操作。

核心:是逻辑特性,而非具体表示、实现。

课程任务:学习ADT、实践ADT。

如:线性表类型、栈类型、队列类型、数组类型、广义表类型、树类型、图类型、查找表类型……实践指导:为了代码的复用性,采用模块结构。

如:C中的头文件、C++中的类第三节 ADT的表示与实现本教材中,算法书写习惯的约定。

数据元素类型ElemType:int,float,char, char[] ……引用参数 &算法:void add(int a,int b,int &c) { c=a+b; }程序:void add(int a,int b,int *p_c){ *p_c=a+b; }第四节算法的描述及分析一、有关算法的概念算法:特定问题求解步骤的一种描述。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
else
{
now = pre->next;
while(signal == 0)
{
if(inpt->expn < now->expn)//当新链节小于现在的连接时向后移一个链节
{
if(now->next == NULL)
{
now->next = inpt;
insert(res,inpt);//把当前"g(x)"的链节插入到"y(x)"中
}
return res;
}
node *list::diffnode(node *head) //多项式微分
{
node *pre;
int flag = 0;
pre = head->next;
#include<iostream>
using namespace std;
struct node //定义节点类型
{
float coef;
int expn;
node * next;
};
class list
{
public:
list();
{
node *inpt,*res,*pre;
int flag = 0;
res = new node;//创建链表头
res->next = NULL;
head1 = head1->next;
pre = head2;
while(flag == 0)
{
if(pre->next == NULL)
{
inpt = new node;//创建新链节
inpt->coef = x;
inpt->expn = y;
inpt->next = NULL;
insert(head,inpt);//不然就查找位置并且插入新链节
cout<<"请输入一元多项式"<<ch<<"的下一项:(以0 0 结束!)\n";
{
if(printing->coef>0 && fun->next!=printing)
cout<<"+";//为正数时打印"+"号
if(printing->coef == 1);//如果为"1"就不用打印系数了
else if(printing->coef == -1)
}
cout<<"\n";
}
int main()
{
list A;
node *f,*g;
int sign = -1;//设置标志
A.start();
while(sign != 0)
{
cin>>sign;
switch(sign)
{
cin>>x>>y;
}
return head;
}
node *list::addnode(node *head,node *pre)//多项式相加
{
node *inpt;
int flag = 0;
while(flag == 0)
{
if(pre->next == NULL)
signal = 1;
}
else
{
pre = now;
now = pre->next;
}
}
else
if(inpt->expn > now->expn)//如果发现比现在的链节大了就插入到这个连接的前面
{
inpt->next = now;
pre->next = inpt;
signal = 1;
}
else
{
now->coef = now->coef + inpt->coef;
signal = 1;
{
pre->coef = pre->coef/(pre->expn+1);
pre->expn++;
if (pre->next == NULL)
flag = 1;
else
pre = pre->next;
}
return head;
}
void list::print(node *fun)//输出多项式
}
void list::insert(node *head, node *inpt)//查找位置插入新链节程序
{
node *pre,*now;
int signal = 0;
pre = head;//pre定义为现在的前一个链节
if(pre->next == NULL) {pre->next = inpt;}
float x;
int y;
head = new node;//创建链表头
head->next = NULL;
cout<<"请输入一元多项式"<<ch<<":(格式是:系数 指数;以0 0 结束!)\n";
cin>>x>>y;
while(x!=0 || y!=0)
}
void list::start()//用户选择界面
{
cout<<"************************************\n";
cout<<" 两个一元多项式的相加,相减,相乘,微分,积分:\n";
cout<<"************************************\n";
cout<<"请选择操作:\n";
cout<<"0.退出\n";
cout<<"1.两个一元多项式相加\n";
cout<<"2.两个一元多项式相减\n";
cout<<"3.两个一元多项式相乘\n";
cout<<"4.一个一元多项式微分\n";
cout<<"5.一个一元多项式积分\n";
while(flag == 0)
{
if(pre->expn != 0)
{
pre->coef = pre->coef * pre->expn;
pre->expn -- ;
}
else
pre->coef = 0;
if (pre->next == NULL)
else if((printing->coef == 1)||(printing->coef == -1))
cout<<"1";
if(printing->next == NULL)
flag = 1;//如果现在的链节没有下一个就结束
else
printing = printing->next;
flag = 1;
else
pre = pre->next;
}
return head;
}
node *list::intnode(node *head)
{
node *pre;
int flag = 0;
pre = head->next;
while (flag == 0)
pre = pre->next;
inpt = new node;//创建新链节
inpt->coef = pre->coef * head1->coef;
inpt->expn = pre->expn + head1->expn;
inpt->next = NULL;
inpt->expn = pre->expn;
inpt->next = NULL;
insert(head,inpt);
}//否则把当前"g(x)"的链节插入到"y(x)"中
}
return head;
}
node *list::bynode(node *head1,node *head2)//多项式相乘
flag = 1;//当现在指向空时跳出循环
else
{
pre = pre->next;
inpt = new node;//创建新链节
inpt->coef = pre->coef;
inpt->expn = pre->expn;
inpt->next = NULL;
{
node *printing;
int flag = 0;
printing = fun->next;//正在被打印的链节
if(fun->next == NULL)//如果函数为空打印0
相关文档
最新文档