一元稀疏多项式计算器C语言课程设计

长沙学院课程设计说明书题目一元多项式计算问题系(部)计算机科学与技术系专业(班级)12软件4班姓名谢仲蛟学号2012022411指导教师邱建雄起止日期2013.12.9～2013.12.20课程设计任务书课程名称：数据结构与算法设计题目：一元多项式计算问题已知技术参数和设计要求：问题描述：设计一个稀疏多项式简单计算器基本要求：(1)输入并分别建立多项式A和B(2)输入输出多项式，输出形式为整数序列：n,c1,e1,c2,e2……，其中n是多项式的项数，ci和ei 是第i项的系数和指数，序列按指数降序排列(3)完成两个多项式的相加、相减，并将结果输出；测试数据：(1) A+B A= 3x14-8x8+6x2+2 B=2x10+4x8+-6x2(2) A-B A=11x14+3x10+2x8+10x6+5 B=2x14+3x8+5x6+7(3) A+B A=x3+x1 B=-x3-x1(4) A+B A=0 B=x7+x5+x3+x1(5) A-B A=100x100+50x50+20x20+x B=10x100+10x50+10x20+x选作内容：（1）.多项式在x=1时的运算结果（2）求多项式A和B的乘积设计工作量：40课时工作计划：指导教师签名：日期：教研室主任签名：日期：系主任签名：日期：长沙学院课程设计鉴定表摘要本次课程设计是在《数据结构》基础上设计以C语言来实现的，它的目的是帮助同学更深入的了解《数据结构》这门课程并熟练运用C语言，使同学达到熟练掌握的程度。

课程设计一个稀疏多项式简单计算器。

其基本要求有六：其一，输入建立两个多项式；其二,输出多项式，输出形式为整数序列：n，c1,e1,c2,e2……,其中n是多项式的项数，ci和ei是第i项的系数和指数，序列按指数的降序序列排列；其三，多项式排序，多项式按指数的降序序列排列；其四，多项式相加，指数相同系数相加，指数不同则把此项加进去；其五，多项式相减，指数相同系数相加，指数不同则把此项取反再加进去；其六，返回多项式的项数。

2014-2015学年第二学期《软件工程》课程设计报告题目：一元稀疏多项式计算器专业：计算机科学与技术班级：计算机科学与技术（2）班姓名：指导教师：成绩：一、问题描述错误!未定义书签。

二、需求分析错误!未定义书签。

三、概要设计错误!未定义书签。

四、详细设计错误!未定义书签。

五、源代码错误!未定义书签。

六、程序测试错误!未定义书签。

七、使用说明错误!未定义书签。

八、课设总结错误!未定义书签。

一、问题描述基本要求（1）输入并建立多项式；（2）输出多项式，输出形式为整数序列：n,c1,e1, c2,e2,,,,,,, cn,en,其中n是多项式的项数，ci,ei,分别是第i项的系数和指数，序列按指数降序排序；（3）多项式a和b相加，建立多项式a+b；（4）多项式a和b相减，建立多项式a-b；（5）计算多项式在x处的值。

（6）计算器的仿真界面。

设计目的数据结构是实践性很强的课程。

课程设计是加强学生实践能力的一个强有力手段。

课程设计要求学生在完成程序设计的同时能够写出比较规范的设计报告。

严格实施课程设计这一环节，对于学生基本程序设计素养的培养和软件工作者工作作风的训练，将起到显著的促进作用二、需求分析设计开发环境：软件方面：系统windows 7 编程软件：VC++思路分析：①一般情况下的一元n次多项式可写成pn(x)=p1xe1+p2xe2+……+pmxem其中，p1是指数为ei的项的非零系数，且满足0≦e1<e2<……<em=n ,若用一个长度为m且每个元素有两个数据项（系数项和指数项）的线性表（（p1,e1）,(p2,e2),……,(pm,em)）便可惟一确定多项式pn(x)。

②用两个带表头结点的单链表分别存储两个多项式③根据一元多项式相加的运算规则：对于两个一元多项式中所有指数相同的项，对应系数相加，若其和不为零，则构成“和多项式”中的一项；④只需要将第二个多项式的系数改为其相反数，然后根据一元多项式相加的运算规则便可以得到其相应的“差多项式”三、概要设计图3-1功能模块图为实现上述程序功能，用带表头结点的单链表存储多项式。

一个一元稀疏多项式简单计算器课程设计报告课程课课课告学院,课程名,称课课班课,学生姓名, ,学号目课1 一元稀疏多课式课算器1.1 述概课了课课任意多课式的加法～法～因此课课课课表的课～有一系～指～下减构体它个数数一指课个个元素3使用课言,课言C课课课境,VC++ 6.01.2 课课容内、课课描述1课课一一元稀疏多课式课课课算器。

个基本要求,一元稀疏多课式课课课算器的基本功能是,;,课入建立多课式～并1;,课出多课式～课出形式课整序列,数～其中是多课式2n,c1,e1,c2,e2,…cn,en,n的课～数分课是第课的系和指～序按指降序排序～数数数数c1,e1,i;,多课式和相加～建立多课式3aba+b;;,多课式和相～建立多课式减4aba-b;;,课算多课式在课的课～5x;,课算器的界面;课做,。

仿真6、需求分析2;,课入的形式和课入课的范课,1课入是课课课入的～课入的容课多课式的系和指～课任意的整～指课大于从内数数数数数等于的整数0;,课出的形式2从屏并减幕课出～课示用课课入的多课式～课示多课式加以后的多课式的课。

;,程序所能到的功能达3,课入建立多课式～并a,课出多课式～课出形式课整序列,数其中是多课式的课数～bn,c1,e1,c2,e2,……,cn,en,n和分课是第课的系和指～序列按指降序排列～数数数cieii,多课式和相加～建立多课式～caba+b,多课式和相～建立多课式减～daba-b,多课式的课出形式课课表式～数学达e,系课课数的非零课的课出形式中略去系数～而的课出形式课。

f11-1x-x1.3 要课课概、存课课构1typedef struct Polynomial { float coef; int expn; struct Polynomial *next;}*Polyn,Polynomial;课课用以存放第构体课的系和指和下一指课～以课课课基课。

数数个i、函数2Polyn CreatePolyn(Polyn head,int m)课函用于建立一课指课课数个～课课数的一元多课式headm课函用于课毁多课式数void DestroyPolyn(Polyn p)课函用于课出多课式数void PrintPolyn(Polyn P) aPolyn AddPolyn(Polyn pa,Polyn pb)课函用于求解建立多课式数并～返回其课指课a+bPolyn SubtractPolyn(Polyn pa,Polyn pb)课函用于求解建立多课式数并～返回其课指课a-bfloat ValuePolyn(Polyn head,int x)课函用于课入数课～课算返回多课式的课并x课函用于比课数和的指数int compare(Polyn a,Polyn b) ab、流程课3一元稀疏多课式课算器课入建立多课式并课出多课式课算多课式在x课的课课算a+b课算a-b课束1.4 课课分析1、课课分析2、行课果运1.5 源程序代课#include<stdio.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) free(p); else { Polynq1,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){q1->next=q2->next;free(q2);}}else{p->next=q2;q1->next=p; } } } Polyn CreatePolyn(Polyn head,int m) { int i; Polyn p;p=head=(Polyn)malloc(sizeof(struct Polynomial)); head->next=NULL;for(i=0;i<m;i++) { p=(Polyn)malloc(sizeof(struct Polynomial));课课入第课的系指数与数用空格隔课printf("%d ,:",i+1);scanf("%f %d",&p->coef,&p->expn); Insert(p,head); } return head; } 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; } while(q) { if(q->coef>0&&flag!=1) putchar('+'); if(q->coef!=1&&q->coef!=-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');else if(q->expn==1) putchar('X'); else printf("X^%d",q->expn); }if(q->coef==-1) { if(!q->expn) printf("-1"); else if(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; else if(!a||a->expn<b->expn)return -1; else return 0; } else if(!a&&b) return -1; else return1; }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); }return headc; }Polyn SubtractPolyn(Polyn pa,Polyn pb) {Polyn h=pb; Polyn p=pb->next; Polyn pd; while(p){ p->coef*=-1; p=p->next; } pd=AddPolyn(pa,h);for(p=h->next;p;p=p->next) p->coef*=-1; return pd;}float ValuePolyn(Polyn head,int x) {Polyn p; int i,t; floatsum=0;for(p=head->next;p;p=p->next){t=1;for(i=p->expn;i!=0;){if(i<0){t/=x;i++;} else{t*=x;i--;} } sum+=p->coef*t; }return sum; }Polyn MultiplyPolyn(Polyn pa,Polyn pb){ Polyn hf,pf; Polyn qa=pa->next; Polyn qb=pb->next;hf=(Polyn)malloc(sizeof(structPolynomial)); 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); } } return hf; }void main(){ int m,n,a,x,f,k=1; Polyn pa=0,pb=0,pc; while(k!=0){ 课课入的课数printf("a :"); scanf("%d",&m); pa=CreatePolyn(pa,m);课课入的课数printf("b :"); scanf("%d",&n); pb=CreatePolyn(pb,n);课出多课式课出多课式printf(" * 1:a 2:b \n");代入的课课算代入的课课算printf(" * 3:xa 4:xb\n");课出课出printf(" * 5:a+b 6:a-b\n");课出退出printf(" * 7:a*b 0:\n");课课课操作,while(a) { printf("\n "); scanf(" %d",&f); switch(f) { 多课式case 1: { printf("\na="); PrintPolyn(pa); break; }多课式case 2: { printf("\nb="); PrintPolyn(pb); break; }课入的课,case 3: { printf("xx="); scanf("%d",&x);课 printf("\n x=%da=%.3f\n",x,ValuePolyn(pa,x)); break; }课入的课,case 4: {printf("xx="); scanf("%d",&x);课 printf("\n x=%d b=%.3f\n",x,ValuePolyn(pb,x)); break; } case5:{ pc=AddPolyn(pa,pb); printf("\n a+b="); PrintPolyn(pc); break; } case 6:{ pc=SubtractPolyn(pa,pb);printf("\n a-b="); PrintPolyn(pc); break; }case 7:{ pc=MultiplyPolyn(pa,pb);printf("\na*b=");PrintPolyn(pc); break; }case 0:{ DestroyPolyn(pa); DestroyPolyn(pb); a=0; break; }您的课课课课～课重新课default: printf("\n !\n"); } } } }2 哈夫曼课/课课器2.1 述概本课程课课用于建立哈夫曼课～课其课行课课、课课以及打印。

元稀疏多项式计算器实验报告c编写,附源代码(1)实验报告：元稀疏多项式计算器引言：本次实验是运用C语言编写一个元稀疏多项式计算器，该计算器可以实现多项式的加法、减法、乘法、求导、积分、求值等操作。

本次实验旨在通过编写实践，加深对多项式计算的理解和程序设计能力。

一、设计思路及实现方法1.1 多项式的表示方式多项式可以用数组来表示，数组的下标表示多项式的幂次，数组的内容表示该幂次项的系数。

例如多项式：2x^4 + 3x^2 + 5可以表示为数组：{0,0,3,0,2,5}。

1.2 多项式的操作函数及实现方法本次实验实现了以下多项式操作函数：1）add（多项式加法）：将两个多项式相加并返回结果多项式。

2）subtract（多项式减法）：将两个多项式相减并返回结果多项式。

3）multiply（多项式乘法）：将两个多项式相乘并返回结果多项式。

4）differential（求导）：求一个多项式的导数并返回结果多项式。

5）integral（积分）：对一个多项式进行积分并返回结果多项式。

6）evaluate（求值）：给定一个值，计算多项式在该值处的值并返回结果。

以上操作函数的实现方法都是通过循环遍历数组，并运用相应的多项式计算公式来计算。

二、程序设计及实验结果2.1 程序设计本次实验采用C语言编写完成，主函数的框架如下：int main(int argc, char const *argv[]) {// 输入多项式各项系数和幂次// 调用各个多项式计算函数// 输出计算结果return 0;}2.2 实验结果本次实验的实验结果如下：1）将多项式2x^3 + 3x^2 + 5x + 2与多项式3x^3 - 2x^2 + 4相加：输入：2 3 5 2 3 -2 0 4输出：5x^3 + x^2 + 5x + 62）将多项式2x^3 + 3x^2 + 5x + 2与多项式3x^3 - 2x^2 + 4相减：输入：2 3 5 2 3 -2 0 4输出：-1x^3 + 5x^2 + 5x - 23）将多项式2x^3 + 3x^2 + 5x + 2与多项式3x^3 - 2x^2 + 4相乘：输入：2 3 5 2 3 -2 0 4输出：6x^6 + 5x^5 + 4x^4 + 4x^3 + 26x^2 + 14x + 84）求多项式2x^3 + 3x^2 + 5x + 2的导数：输入：2 3 5 2输出：6x^2 + 6x + 55）对多项式2x^3 + 3x^2 + 5x + 2进行积分：输入：2 3 5 2输出：0.5x^4 + 1x^3 + 2.5x^2 + 2x + 06）计算多项式2x^3 + 3x^2 + 5x + 2在x=3处的值：输入：2 3 5 2 3输出：59以上实验结果均能正确输出。

一个一元稀疏多项式简单计算器课程设计报告课程课课课告学院,课程名,称课课班课,学生姓名, ,学号目课1 一元稀疏多课式课算器1.1 述概课了课课任意多课式的加法～法～因此课课课课表的课～有一系～指～下减构体它个数数一指课个个元素3使用课言,课言C课课课境,VC++ 6.01.2 课课容内、课课描述1课课一一元稀疏多课式课课课算器。

个基本要求,一元稀疏多课式课课课算器的基本功能是,;,课入建立多课式～并1;,课出多课式～课出形式课整序列,数～其中是多课式2n,c1,e1,c2,e2,…cn,en,n的课～数分课是第课的系和指～序按指降序排序～数数数数c1,e1,i;,多课式和相加～建立多课式3aba+b;;,多课式和相～建立多课式减4aba-b;;,课算多课式在课的课～5x;,课算器的界面;课做,。

仿真6、需求分析2;,课入的形式和课入课的范课,1课入是课课课入的～课入的容课多课式的系和指～课任意的整～指课大于从内数数数数数等于的整数0;,课出的形式2从屏并减幕课出～课示用课课入的多课式～课示多课式加以后的多课式的课。

;,程序所能到的功能达3,课入建立多课式～并a,课出多课式～课出形式课整序列,数其中是多课式的课数～bn,c1,e1,c2,e2,……,cn,en,n和分课是第课的系和指～序列按指降序排列～数数数cieii,多课式和相加～建立多课式～caba+b,多课式和相～建立多课式减～daba-b,多课式的课出形式课课表式～数学达e,系课课数的非零课的课出形式中略去系数～而的课出形式课。

f11-1x-x1.3 要课课概、存课课构1typedef struct Polynomial { float coef; int expn; struct Polynomial *next;}*Polyn,Polynomial;课课用以存放第构体课的系和指和下一指课～以课课课基课。

数数个i、函数2Polyn CreatePolyn(Polyn head,int m)课函用于建立一课指课课数个～课课数的一元多课式headm课函用于课毁多课式数void DestroyPolyn(Polyn p)课函用于课出多课式数void PrintPolyn(Polyn P) aPolyn AddPolyn(Polyn pa,Polyn pb)课函用于求解建立多课式数并～返回其课指课a+bPolyn SubtractPolyn(Polyn pa,Polyn pb)课函用于求解建立多课式数并～返回其课指课a-bfloat ValuePolyn(Polyn head,int x)课函用于课入数课～课算返回多课式的课并x课函用于比课数和的指数int compare(Polyn a,Polyn b) ab、流程课3一元稀疏多课式课算器课入建立多课式并课出多课式课算多课式在x课的课课算a+b课算a-b课束1.4 课课分析1、课课分析2、行课果运1.5 源程序代课#include<stdio.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) free(p); else { Polynq1,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){q1->next=q2->next;free(q2);}}else{p->next=q2;q1->next=p; } } } Polyn CreatePolyn(Polyn head,int m) { int i; Polyn p;p=head=(Polyn)malloc(sizeof(struct Polynomial)); head->next=NULL;for(i=0;i<m;i++) { p=(Polyn)malloc(sizeof(struct Polynomial));课课入第课的系指数与数用空格隔课printf("%d ,:",i+1);scanf("%f %d",&p->coef,&p->expn); Insert(p,head); } return head; } 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; } while(q) { if(q->coef>0&&flag!=1) putchar('+'); if(q->coef!=1&&q->coef!=-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');else if(q->expn==1) putchar('X'); else printf("X^%d",q->expn); }if(q->coef==-1) { if(!q->expn) printf("-1"); else if(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; else if(!a||a->expn<b->expn)return -1; else return 0; } else if(!a&&b) return -1; else return1; }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); }return headc; }Polyn SubtractPolyn(Polyn pa,Polyn pb) {Polyn h=pb; Polyn p=pb->next; Polyn pd; while(p){ p->coef*=-1; p=p->next; } pd=AddPolyn(pa,h);for(p=h->next;p;p=p->next) p->coef*=-1; return pd;}float ValuePolyn(Polyn head,int x) {Polyn p; int i,t; floatsum=0;for(p=head->next;p;p=p->next){t=1;for(i=p->expn;i!=0;){if(i<0){t/=x;i++;} else{t*=x;i--;} } sum+=p->coef*t; }return sum; }Polyn MultiplyPolyn(Polyn pa,Polyn pb){ Polyn hf,pf; Polyn qa=pa->next; Polyn qb=pb->next;hf=(Polyn)malloc(sizeof(structPolynomial)); 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); } } return hf; }void main(){ int m,n,a,x,f,k=1; Polyn pa=0,pb=0,pc; while(k!=0){ 课课入的课数printf("a :"); scanf("%d",&m); pa=CreatePolyn(pa,m);课课入的课数printf("b :"); scanf("%d",&n); pb=CreatePolyn(pb,n);课出多课式课出多课式printf(" * 1:a 2:b \n");代入的课课算代入的课课算printf(" * 3:xa 4:xb\n");课出课出printf(" * 5:a+b 6:a-b\n");课出退出printf(" * 7:a*b 0:\n");课课课操作,while(a) { printf("\n "); scanf(" %d",&f); switch(f) { 多课式case 1: { printf("\na="); PrintPolyn(pa); break; }多课式case 2: { printf("\nb="); PrintPolyn(pb); break; }课入的课,case 3: { printf("xx="); scanf("%d",&x);课 printf("\n x=%da=%.3f\n",x,ValuePolyn(pa,x)); break; }课入的课,case 4: {printf("xx="); scanf("%d",&x);课 printf("\n x=%d b=%.3f\n",x,ValuePolyn(pb,x)); break; } case5:{ pc=AddPolyn(pa,pb); printf("\n a+b="); PrintPolyn(pc); break; } case 6:{ pc=SubtractPolyn(pa,pb);printf("\n a-b="); PrintPolyn(pc); break; }case 7:{ pc=MultiplyPolyn(pa,pb);printf("\na*b=");PrintPolyn(pc); break; }case 0:{ DestroyPolyn(pa); DestroyPolyn(pb); a=0; break; }您的课课课课～课重新课default: printf("\n !\n"); } } } }2 哈夫曼课/课课器2.1 述概本课程课课用于建立哈夫曼课～课其课行课课、课课以及打印。

一元稀疏多项式计算器c语言一、背景。

在计算机领域中，一元稀疏多项式是一种较为重要的数据类型，它广泛应用于科学计算、图像处理等领域。

由于传统计算方法需要大量时间和计算资源，因此研究一种高效的一元稀疏多项式计算器显得十分重要。

二、需求分析。

基于以上背景，我们需要完成以下需求：1.实现一元稀疏多项式的基本运算，如加、减、乘、除法等。

2.实现一元稀疏多项式的系数排序，可以按照任意顺序排列。

3.实现一元稀疏多项式的表示方式，可供用户输入和输出。

三、设计方案。

为了满足以上需求，我们可以采用以下设计方案：1.多项式基本结构。

为了处理一元稀疏多项式的各种运算，我们需要为多项式定义一个基本的数据结构。

这个结构需要包含多项式的各项系数、指数、项数等信息。

我们可以采用数组或链表等方式实现这个数据结构。

2.多项式运算。

为了完成多项式的加、减、乘、除法等运算，我们需要实现相应的算法。

这些算法包括基于快速傅里叶变换的多项式乘法、除法等。

3.系数排序。

为了满足用户不同的需求，我们需要实现多项式系数的排序功能。

由于用户可以选择任意的顺序，我们需要保证排序算法的稳定性和高效性。

4.多项式表示。

为了方便用户输入和输出多项式，我们需要设计一个简洁易用的多项式表示方式。

用户可以根据需要选择带有系数和指数的输入方式，也可以选择只输入系数或指数。

四、实现细节。

为了优化计算效率和减少内存占用，我们可以在实现多项式运算时采用以下方法：1.采用链表存储多项式的数据结构，可以有效减少内存占用和复制开销。

2.对于多项式的加、减、乘、除法等运算，我们可以根据具体情况选择合适的运算算法。

如多项式加减可以直接遍历链表进行计算；多项式乘法可以使用快速傅里叶变换等算法。

3.为了提高排序效率，我们可以采用基于快速排序、归并排序等的排序算法。

对于多项式系数相同时，可以使用指数作为比较因素。

五、总结。

通过以上设计方案和实现细节，我们可以实现一个高效的一元稀疏多项式计算器。

(2023)一元稀疏多项式计算器实验报告c编写,附源代码(一)实验报告：(2023)一元稀疏多项式计算器实验目的本实验旨在编写一款一元稀疏多项式计算器，实现对两个多项式的加、减、乘、求导、求值等操作。

实验环境•操作系统：Windows 10•开发工具：Visual Studio Code•编程语言：C实验过程1. 首先定义多项式的结构体typedef struct PolyTerm {int coef;// 系数unsigned int power;// 指数struct PolyTerm* next;// 下一项}PolyTerm;typedef struct Poly {int degree;// 多项式最高次项PolyTerm* head;// 首项指针}Poly;2. 实现多项式的输入与输出void inputPoly(Poly* poly);// 输入多项式void outputPoly(Poly* poly);// 输出多项式3. 实现多项式的加、减、乘操作Poly* addPoly(Poly* p1, Poly* p2);// 多项式加法Poly* subPoly(Poly* p1, Poly* p2);// 多项式减法Poly* multPoly(Poly* p1, Poly* p2);// 多项式乘法4. 实现多项式求导void derivative(Poly* poly);// 多项式求导5. 实现多项式求值int evaluate(Poly* poly,int x);// 多项式求值6. 主函数的实现主函数通过简单的菜单方式，实现用户输入选项，选择需要进行的操作。

实验结果通过对多项式加、减、乘、求导、求值等操作的实现，成功完成了一元稀疏多项式计算器的编写，实现了对多项式运算的基本掌握。

实验总结在本次实验中，我们通过C语言实现了一元稀疏多项式计算器，并体验了多项式运算的具体操作。

一、课程设计题目：一元稀疏多项式计算器二、目的与要求1、目的：通过布置具有一定难度的实际程序设计项目，使学生进一步理解和掌握课堂上所学各种基本抽象数据类型的逻辑结构、存储结构和操作实现算法，以及它们在程序中的使用方法；使学生掌握分析问题，求解问题的方法并提高学生设计编程实现的能力。

2、要求：基本要求：1.要求利用C\C++语言来完成系统的设计；2.突出C语言的函数特征（以多个函数实现每一个子功能）或者C++语言面向对象的编程思想；3.画出功能模块图；4.进行简单界面设计，能够实现友好的交互；5.具有清晰的程序流程图和数据结构的详细定义；6.熟练掌握C语言或者C++语言的各种操作。

创新要求：在基本要求达到后，可进行创新设计，如系统用户功能控制，改进算法的实现，实现友好的人机交互等等三、问题描述和求解方法：1 、问题描述功能：设计一个一元多项式加法器。

输入并建立多项式，实现两个多项式的加法运算。

要求：1) 界面友好，函数功能要划分好2) 总体设计应画出流程图3) 程序要加必要的注释4) 要提供程序测试方案5) 程序一定要经得起测试，宁可功能少一些，也要能运行起来，不能运行的程序是没有价值的。

2 、问题的解决方案：1) 多项式的表达：n, c1, e1, c2, e2, … c n , e n,其中，n是多项式项数，c i和e i分别是第i项的系数和指数，序列按指数降序或者升序排列；2）利用线性结构存储多项式的每一项。

3）多项式加法运算即转化为线性表的条件归并运算。

四、解题过程1.分析程序的功能要求，划分程序功能模块。

2.画出系统流程图。

3.代码的编写。

定义数据结构和各个功能子函数。

4.程序的功能调试。

5.完成系统总结报告以及使用说明书五、进度安排此次课程设计时间为一周，分以下几个阶段完成：1.选题与搜集资料：每人选择一题，进行课程设计课题的资料搜集。

2.分析与概要设计：根据搜集的资料，进行程序功能与数据结构分析，并选择合适的数据结构、并在此基础上进行实现程序功能的算法设计。

一、课程设计概述：本次数据结构课程设计共完成五个题：一元稀疏多项式计算器、迷宫问题、成绩分析问题、图的基本操作与实现以及背包问题的求解使用语言：C编译环境：TC3.0二、课程设计题目一[实验内容]一元稀疏多项式计算器[问题描述]设计一个一元稀疏多项式简单计算器。

[基本要求]一元稀疏多项式简单计算器的基本功能是：（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；（5）计算多项式在x处的值。

（6）计算器的仿真界面。

（选做）[概要设计]-=ADT=-Test1:主类，程序的启动Item :项，表示多项式中的某一项Ploynomial：多项式类[存储结构]Item属性：private double c;//系数private int e;//指数Item方法：public void setC(double c){//设置系数}public void setE(int e){ //设置指数}public double getC(){//获取系数}public int getE(){//获取指数}public double resultItem(double x){//在x处Item的值}private double fac(double x,int e){//求x的e次方,当e为整数时}Polynomial属性：private LinList list;//单链表Polynomial方法：public Polynomial(){}public Polynomial(Item [] item)throws Exception{ //构造函数}private void initItem(Item [] item){//初始化Item数组，使其是按降序排序}public int getItemNum(){//获取项数}public void print()throws Exception{//打印多项式不空行}public void println()throws Exception{//打印多项式空行}public LinList getLinList(){//获取单链表}public void printPolynomial()throws Exception{//只打印项数、系数和指数}public Polynomial add(Polynomial other)throws Exception{//多项式相加}}public Polynomial subtraction(Polynomial other)throws Exception{//多项式相减}public double result(double x)throws Exception{}[详细设计]Item类：public class Item {private double c;//系数private int e;//指数public Item(){}public Item(double c,int e){this.c=c;this.e=e;}public void setC(double c){this.c=c;}public void setE(int e){this.e=e;}public double getC(){return c;}public int getE(){return e;}public double resultItem(double x){return getC()*fac(x,getE());}private double fac(double x,int e){//求x的e次方,当e为整数时if(e==0) return 1;return x*fac(x,e-1);}}Polynomial类：import java.util.*;public class Polynomial{//多项式类private LinList list;//单链表public Polynomial(){list=new LinList(0,null);}public Polynomial(Item [] item)throws Exception{ //构造函数int n=item.length;list=new LinList(n,null);if(n==0){return;}initItem(item);try{for(int i=0;i<n;i++)list.insert(i,item[i]);}catch(Exception e){}}private void initItem(Item [] item){//初始化Item数组，使其是按降序排序int n=item.length;int max;for(int i=0;i<n;i++){max=i;for(int j=i+1;j<n;j++)if(item[j].getE()>item[max].getE()) max=j;if(max!=i){Item temp=item[i];item[i]=item[max];item[max]=temp;}}}public int getItemNum(){//获取项数Object temp=list.head.getElement();int n=-1;if(temp instanceof Integer){Integer i=(Integer)temp;n=i.intValue();}return n;}public void print()throws Exception{//打印多项式不空行int n=getItemNum();// System.out.println(n);if(n==-1) return ;if(n==0){System.out.print("0");return;}boolean flag=true;//是不是输出第一项的标志for(int i=0;i<n;i++){Item temp=(Item)list.getData(i);double c=temp.getC();if(c==0) continue;//系数为0时不输出if(flag && temp.getE()!=0 ){System.out.print(c+"x^"+temp.getE());}else if(flag && temp.getE()==0)System.out.print(temp.getC());else {if(c>0)System.out.print("+"+c+"x^"+temp.getE());else if(c<0)System.out.print(c+"x^"+temp.getE());}flag=false;}}public void println()throws Exception{//打印多项式空行print();System.out.println();}public LinList getLinList(){//获取单链表return list;}public void printPolynomial()throws Exception{//只打印项数、系数和指数int n=getItemNum();if(n==0) return ;System.out.print(n+",");for(int i=0;i<n;i++){Item item=(Item)this.getLinList().getData(i);if(i!=n-1){System.out.print("c"+i+"="+item.getC()+", "+"e"+i+"="+item.getE()+", ");}else{System.out.print("c"+i+"="+item.getC()+", "+"e"+i+"="+item.getE());}}System.out.println();}public Polynomial add(Polynomial other)throws Exception{//多项式相加LinList otherList=other.getLinList();int n1=getItemNum();//该多项式的项数int n2=other.getItemNum();//另一个多项式的项数if(n2==0) return this;if(n1==0) return other;Polynomial temp=new Polynomial();int i=0,j=0;while (+i<n1 && j<n2){Item item=new Item();Item item1=(Item)list.getData(i);Item item2=(Item)otherList.getData(j);double c1=item1.getC();//获得系数double c2=item2.getC();int e1=item1.getE();//获得指数int e2=item2.getE();if(e1==e2){//相等时double c=c1+c2;item.setC(c);item.setE(e1);i++;j++;}else if(e1<e2){//不相等时指数的大的增加item=item2;j++;}else {item=item1;i++;}try{if(item.getC()==0)//当得到项的系数为0时就没有必要加入continue;temp.getLinList().insert(temp.getLinList().size(),item);}catch(Exception e){}}//将没有参加比较的项加进去，注意比较之后有且只有一个有多余的项while(i<n1){Item item1=(Item)list.getData(i);try{temp.getLinList().insert(temp.getLinList().size(),item1);}catch(Exception e){}i++;}while(j<n2){Item item1=(Item)otherList.getData(j);try{temp.getLinList().insert(temp.getLinList().size(),item1);}catch(Exception e){}j++;}temp.getLinList().head.setElement(temp.getLinList().size());//设置项数return temp;}public Polynomial subtraction(Polynomial other)throws Exception{//多项式相减int n=other.getItemNum();if(n==0) return this;Polynomial temp=new Polynomial();LinList l=temp.getLinList();for(int i=0;i<n;i++){Item item =(Item)other.getLinList().getData(i);double c=-1*item.getC();//取反l.insert(i,new Item(c,item.getE()));}l.head.setElement(n);//设置项数return add(temp);}public double result(double x)throws Exception{double sum=0;int n=getItemNum();//该多项式的项数if(n==0) return 0;for(int i=0;i<n;i++){Item item=(Item)list.getData(i);sum+=item.resultItem(x);}return sum;}}T est1类：import java.io.*;import java.util.Scanner;public class T est1 {Scanner scanner =new Scanner(System.in);public static void main(String[] args)throws Exception{ T est1 test1=new T est1();Scanner scanner1 =new Scanner(System.in);while(true){System.out.println("请输入你要操作的系号：\n"+"1)输出多项式\n"+"2)多项式相加\n"+"3)多项式相减\n"+"4)计算多项式在x处的值\n"+"5)退出");String s=scanner1.next();int t=-1;try{t=Integer.parseInt(s);}catch(Exception e){}switch(t){case 1:test1.printPolynomial();break;case 2:test1.add();break;case 3:test1.subtraction();break;case 4:test1.resultOfPolynomia();break;case 5:System.exit(0);break;default:System.out.println("你输入的操作有误，请重试\n");continue;}}}private void printPolynomial()throws Exception{//选择1时System.out.println("请输入要输出的多项式的信息：");Item[] item=creatItemShuZu();Polynomial p=new Polynomial(item);p.printPolynomial();}private void add()throws Exception{//选择2时System.out.println("请输入第一个多项式的信息：");Item[] item1=creatItemShuZu();Polynomial p1=new Polynomial(item1);System.out.println("请输入第二个多项式的信息：");Item[] item2=creatItemShuZu();Polynomial p2=new Polynomial(item2);Polynomial p=p1.add(p2);System.out.print("(");p1.print();System.out.print(")+(");p2.print();System.out.print(")=");p.print();System.out.println();}private void subtraction()throws Exception{//选择3时System.out.println("请输入第一个多项式的信息：");Item[] item1=creatItemShuZu();Polynomial p1=new Polynomial(item1);System.out.println("请输入第二个多项式的信息：");Item[] item2=creatItemShuZu();Polynomial p2=new Polynomial(item2);Polynomial p=p1.subtraction(p2);System.out.print("(");p1.print();System.out.print(")-(");p2.print();System.out.print(")=");p.print();System.out.println();}private void resultOfPolynomia()throws Exception{//选择4时System.out.println("请输入要输出的多项式的信息：");Item[] item=creatItemShuZu();Polynomial p=new Polynomial(item);System.out.println("请输入x=");double x=scanner.nextDouble();System.out.println(p.result(x));}private Item[] creatItemShuZu()throws Exception{//构造多项式数组System.out.print("项数n=");int n=scanner.nextInt();double []c=new double[n];int [] e=new int[n];Item[] item=new Item[n];System.out.print("请输入各项的系数：");for(int i=0;i<n;i++)c[i]=scanner.nextDouble();System.out.print("请输入各项的指数：");for(int i=0;i<n;i++)e[i]=scanner.nextInt();for(int i=0;i<n;i++){item[i]=new Item(c[i],e[i]);}return item;}}[调试分析]本程序主要的操作对象是记录数组，使用的存储结构是结构体数组。

一元稀疏多项式计算器实验报告—级_班_年—月—日姓名______ 学号_________________1 •实验题目设计一个一元稀疏多项式简单计算器。

2 •需求分析本程序用VC编写，实现一元浮点系数，整数指数稀疏多项式的创建、两个一元多项式相加、两个一元多项式相减、输出一元多项式。

①输入的形式和输入值的范围：A. 输入指定的数字，以此选择两个多项式的运算方式，运算方式有两个一元多项式相加、两个一元多项式相减。

B. 创建多项式时，需要输入此多项式，每一项的系数和指数。

②输出的形式：每次输入一个完整的多项式后、每次得出多项式运算结果时，会以指定的方式输出多项式。

③程序所能达到的功能：实现一元稀疏多项式的创建、两个一元多项式相加、两个一元多项式相减、输出一元多项式。

④测试数据：输入数据：A. 出现选择两个多项式的运算方式菜单时，输入1 （即使两个多项式相加）；B. 首先输入多项式p的每一项系数和指数，当输入的指数为-5000时，表示该多项式输入完毕，输入的数据依次为：3, 3, 0, -5000 ;C. 其次输入多项式q的每一项系数和指数，输入数据依次为：2, 2, 0, -5000。

输出结果：多项式q+p的结果为：多项式为：3 23x +2x3 •概要设计1）为了实现上述程序功能，需要定义多项式结点的抽象数据类型:2）class Term{数据对象：float coef; int exp; Term* link; 该数据对象为多项式一项中的系数。

该数据对象为多项式一项中的指数。

该数据对象为指向下一个多项式结点的指针。

基本操作:A. Term ( float c, int e)初始条件：无操作结果：初始化多项式结点对象，将c赋值给该结点的数据成员coef (表示系数)，将e赋值给该结点的数据成员exp (表示指数)，将该结点的数据成员link赋值为0。

(float c, int e, Term* next)初始条件：无操作结果：初始化多项式结点对象，将c赋值给该结点的数据成员coef (表示系数)，将e赋值给该结点的数据成员exp (表示指数)，将next赋值给该结点的数据成员link ( link 表示指向下一个多项式结点的指针)。

一元稀疏多项式计算器 C语言编写悬赏分：120 | 提问时间：2008-6-23 20:33 | 提问者：骑着单车的熊一元稀疏多项式计算器：用C语言编写程序，实现一元稀疏多项式计算器。

具体要求如下：(1) 演示程序以用户与计算机对话的形式输入输出数据；(2) 实现两个一元稀疏多项式的加、减、乘运算；(3) 求一个多项式a的导函数a’；(4) 结果以类数学表达式的形式输出。

看清题目的要求我只要C语言的不要其他语言的还有解释一下编程的思路和过程谢谢了大家请大家传给我能够使用的程序谢谢了推荐答案datastruct.htypedef struct list{int c; //多项式的项数int e; //多项式的指数struct list *next; //下一结点};typedef struct list *LinkList;typedef struct list Node;下面是线性表的操作相关函数声明，对应文件ListOper.h: //File: ListOper.h#ifndef DATASTRUCT#define DATASTRUCT#include "datastruct.h"#endif//some functions declaretioinbool CreateList(LinkList &L);Node *CreateNode(int e, int c);void FreeList(LinkList &L);void SortList(LinkList &L);void DeleteNextNode(Node *d);void SweepNextNode(Node *s);void OutPutList(LinkList &L);相关函数的实现，对应文件ListOper.cpp: //File: ListOper.cpp#include <stdlib.h>#include <iostream>#ifndef DATASTRUCT#define DATASTRUCT#include "datastruct.h"#endif#include "ListOper.h"using namespace std;bool CreateList(LinkList &L){//TODO: 创建线性链表Node *head;head=(Node *)malloc(sizeof(Node));if(head==NULL){cout << "内存分配错误" << endl; return false;}head->next=NULL;head->c=0;head->e=0;L=head;return true;}Node *CreateNode(int e, int c) {//TODO: 创建结点Node * pos;pos=(Node *)malloc(sizeof(Node)); if(pos==NULL){cout << "内存分配错误" << endl;exit(1);}pos->e=e;pos->c=c;pos->next=NULL;return pos;}void FreeList(LinkList &L){//TODO: 释放整个线性表所占用的内存空间Node *pos;Node *next;pos=L;while(pos!=NULL){next=pos->next;free(pos);pos=next;}}void SortList(LinkList &L){bool flag=true; //是否需要排序标志Node *head=L->next;Node *pos;Node *last;Node *temp;if(head->next==NULL){return;}while(flag){flag=true;last=head;pos=last->next;if(last==NULL||last->next==NULL){break;}while(last!=NULL && last->next!=NULL){flag=false;pos=last->next;if(last->e<pos->e) //哈哈哈哈哈，HTML代码{SweepNextNode(last);flag=true;}if(last->e==pos->e){last->c+=pos->c; DeleteNextNode(last);flag=true;/*last=last->next;pos=last->next;*/}last=last->next;}}}void DeleteNextNode(Node *d) {Node *temp;temp=d->next;d->next=temp->next;free(temp);}void SweepNextNode(Node *s)//一点偷懒的办法，只交换值，不修改指针{int c,e;c=s->c;e=s->e;s->c=s->next->c;s->e=s->next->e;s->next->c=c;s->next->e=e;}void OutPutList(LinkList &L){Node *pos;pos=L->next;cout << "输出表达式：";while(pos!=NULL){if(pos->c>0){cout << "+";}if(pos->c!=1){cout << pos->c;}if(pos->e!=0){cout << "x^";cout << pos->e;}pos=pos->next;}cout << endl;}主单元文件main.cpp:#include <iostream>#include <stdlib.h>#include <ctype.h>#include "ListOper.h"using namespace std;LinkList AnayString(char aString[], int aLength);int main(int argc, char *argv[]) //-------------------------------{LinkList L;char InStr[1024];int len;cout << "一元稀疏多项式计算器" << endl;cout << "Copyright@1999-2004, Gashero Liu." << endl;cout << "作者：刘晓明" << endl << endl;cout << "请输入一个1024个字符以内的稀疏多项式：";cin >> InStr;len=strlen(InStr);L=AnayString(InStr,len);SortList(L);OutPutList(L);FreeList(L);system("PAUSE");return 0;}LinkList AnayString(char aString[], int aLength) //---------------//TODO: 字符串分析函数{LinkList L=NULL;Node *pos=NULL;Node *last;Node *head;CreateList(L);head=L;last=head;int c=0;int e=0;char temp[1];char tp;bool plus=true;char status='n'; //状态指示符,我省略了系数为负的情况/*n: 非运算状态c: 正在计算系数e: 正在计算指数p: 指数为0f: 完成了一个项目的输入*/for(int i=0;i<aLength;i++){temp[0]=aString[i]; tp=temp[0];switch(status){case 'n':{c=0;e=0;status='c';if(tp=='-'){plus=false; continue;}if(isdigit(tp)) {c=atoi(temp); continue;}if(tp=='x')//多项式以x开头{c=1;status='e';continue;}}case 'c':{if(isdigit(aString[i])) {if(plus){c=c*10+atoi(temp);}else{c=c*10-atoi(temp);}continue;}if(tp=='x'){if(c==0){c=1;}status='e';e=0;continue;}//此处考虑了常数项出现在其他位置的可能if(tp=='+'){plus=true;status='p';continue;}if(tp=='-'){plus=false;status='p';continue;}/*if(temp[0]=='^'){status='e';e=0;continue;}*/ //此种情况不可能出现continue;} //正在解析系数case 'e':{if(tp=='^'){continue;}if(isdigit(tp)){e=e*10+atoi(temp); continue;}if(tp=='+'){plus=true;status='f';continue;}if(tp=='-'){plus=false;status='f';continue;}} //正在解析系数case 'p':{e=0;status='f';continue;}case 'f':{pos=CreateNode(e,c);last->next=pos;last=pos;c=0;e=0;status='c';i--;continue;}}}pos=CreateNode(e,c);last->next=pos;return L;设计一个一元多项式简单的计算器(C语言)悬赏分：80 | 解决时间：2008-11-11 19:19 | 提问者：匿名要求：（1）用带头节点的单链表表示多项式，表中每一个节点表示多项式的一项(2)一元多项式简单计算器的基本功能为：输入并建立多项式，输出多项式，2个多项式相减最佳答案#include<stdio.h>#include<stdlib.h>typedef struct Node{int data;struct Node *next;}Node;//链表结点typedef struct LinkList//定义链表数据类型{Node *head;//表头结点void PrintMform()//输出多项式{Node *p=head->next;int exp = head->data-1;while(p!=NULL){if(exp==head->data-1)printf("%dX^%d",p->data,exp);else{if(p->data>0)printf("+%dX^%d",p->data,exp);if(p->data==0)printf("+0");if(p->data<0)printf("%dX^%d",p->data,exp);}exp--;p=p->next;}printf("\n");}void CreateByInput(int length)//通过输入元素建立链表{head=(Node *)malloc(sizeof(Node));head->data=0;//表头节点存储链表真实长度head->next=NULL;int i,temp;Node *p,*cur = head;for(i=1;i<=length;i++){printf("structing LinkList,Please input the value:\n"); scanf("%d",&temp);p = (Node *)malloc(sizeof(Node));p->data=temp;p->next=cur->next;cur->next=p;cur = cur->next;head->data++;}}}LinkList;void main(){LinkList L1,L2;int length;//就是多项式的项数printf("Please input the first LinkList's length:\n");scanf("%d",&length);printf("begin to struct the first LinkList\n");//开始构造第一个多项式L1.CreateByInput(length);printf("begin to struct the second LinkList\n");//开始构造第二个多项式L2.CreateByInput(length);printf("the first duoxiangshi is:\n");L1.PrintMform();//输出第一个多项式printf("the second duoxiangshi is:\n");L2.PrintMform();//输出第二个多项式Node *p = L1.head->next;/////////////////从这里开始Node *q = L2.head->next;//是计算多项式L1-L2,结果存入L1 while(p!=NULL){p->data-=q->data;p=p->next;q=q->next;}/////////////////////////////////////到这里结束printf("the substract is:\n");L1.PrintMform();system("pause");}。

一元稀疏多项式计算器c语言下面是一个使用C语言编写的一元稀疏多项式计算器的示例代码。

```c#include<stdio.h>#include<stdlib.h>//定义多项式的一个节点typedef struct Nodeint coefficient; // 系数int exponent; // 指数struct Node* next; // 下一个节点} Node;//创建一个节点Node* createNode(int coefficient, int exponent)Node* newNode = (Node*)malloc(sizeof(Node));newNode->coefficient = coefficient;newNode->exponent = exponent;newNode->next = NULL;return newNode;//插入节点到多项式中Node* insertNode(Node* head, int coefficient, int exponent) Node* newNode = createNode(coefficient, exponent);if(head == NULL)return newNode;} elseNode* temp = head;while(temp->next != NULL)temp = temp->next;}temp->next = newNode;return head;}//打印多项式void printPolynomial(Node* head)Node* temp = head;while(temp != NULL)printf("%dx^%d ", temp->coefficient, temp->exponent);temp = temp->next;if(temp != NULL)printf("+ ");}}printf("\n");//计算两个多项式的和Node* addPolynomials(Node* polynomial1, Node* polynomial2) Node* result = NULL;while(polynomial1 != NULL && polynomial2 != NULL)if(polynomial1->exponent > polynomial2->exponent)result = insertNode(result, polynomial1->coefficient, polynomial1->exponent);polynomial1 = polynomial1->next;} else if(polynomial1->exponent < polynomial2->exponent) result = insertNode(result, polynomial2->coefficient, polynomial2->exponent);polynomial2 = polynomial2->next;} elseresult = insertNode(result, polynomial1->coefficient + polynomial2->coefficient, polynomial1->exponent);polynomial1 = polynomial1->next;polynomial2 = polynomial2->next;}}//将剩余的节点加入结果中while(polynomial1 != NULL)result = insertNode(result, polynomial1->coefficient, polynomial1->exponent);polynomial1 = polynomial1->next;}while(polynomial2 != NULL)result = insertNode(result, polynomial2->coefficient, polynomial2->exponent);polynomial2 = polynomial2->next;}return result;//主函数int maiNode* polynomial1 = NULL;Node* polynomial2 = NULL;Node* result = NULL;//输入第一个多项式int numTerms1;printf("Enter the number of terms in polynomial 1: ");scanf("%d", &numTerms1);printf("Enter each term of polynomial 1 (coefficient exponent):\n");for(int i=0; i<numTerms1; i++)int coefficient, exponent;scanf("%d %d", &coefficient, &exponent);polynomial1 = insertNode(polynomial1, coefficient, exponent);}//输入第二个多项式int numTerms2;printf("Enter the number of terms in polynomial 2: ");scanf("%d", &numTerms2);printf("Enter each term of polynomial 2 (coefficient exponent):\n");for(int i=0; i<numTerms2; i++)int coefficient, exponent;scanf("%d %d", &coefficient, &exponent);polynomial2 = insertNode(polynomial2, coefficient, exponent);}//打印两个多项式printf("\nPolynomial 1: ");printPolynomial(polynomial1);printf("Polynomial 2: ");printPolynomial(polynomial2);//计算两个多项式的和result = addPolynomials(polynomial1, polynomial2);//打印结果多项式printf("\nSum of polynomials: ");printPolynomial(result);return 0;```这个计算器使用了链表来表示多项式，每个节点包含一个系数和一个指数。

目录一、课程题目 (3)二、设计目的 (3)三、需求分析 (3)四、总体设计 (3)五、详细设计 (2)六、实现部分 (3)七、程序测试 (3)八、设计总结 (12)一、课程题目一元稀疏多项式计算器二、设计目的掌握稀疏矩阵的相关运算。

掌握广义表的操作。

三、需求分析一元稀疏多项式简单计算器的基本功能是：输入并建立多项式；输出多项式,输出形式为整数序列：n,c1,e1,,c2,e2 ……cn,en,其中n是多项式的项数,ci和ei分别是第i项的系数和指数,序列按指数降序排列。

多项式a和b相加,建立多项式a+b多项式a和b相减,建立多项式a-b四、总体设计创建两个类，把一个作为另一个的友元类！两个类分别是listnode和polynomial！创建一个链表，包括指数，次数以及下一个结点信息，然后利用冒泡排序法进行排序，排完之后输出多项式！最后一个环节就是进行多项式的最原始运算，即加减运算！其中运用的内容包括链表知识，冒泡排序的知识！五、详细设计类listnode中包含friend class polynomial、double coef、int exp、listnode *next！类polynomial包含poly(); void printpoly();void bubblesort();polynomial operator+(polynomial &p1); polynomial operator-(polynomial &p1);在这个程序设计中，为了实现多项式的运算必须首先创建两个多项式，存储多项式的存储结构是链表，其结构如下：else if(p->exp<q->exp){double m;int n;m=p->coef;p->coef=q->coef;q->coef=m;n=p->exp;p->exp=q->exp;q->exp=n;s=q;q=q->next;｝再就是实现多项式的加减法运算，在加减法运算中为了实现处理，设p、q分别指向单链表的两个多项式，比较p、q结点的指数项，由此得到下列运算规则：①若p->exp<q->exp，则结点p所指的结点应是“和多项式”中的一项，令指针p后移。