一元多项式计算器开发

合集下载

《程序语言课程设计_一元多项式简单的计算器》

西安文理学院软件学院课程设计报告设计名称：程序语言课程设计设计题目：一元多项式简单的计算器学生学号： 1402120135 专业班级：软件学院一班学生姓名：张文东学生成绩：指导教师（职称）：袁溪（讲师）课题工作时间： 2013.12.9 至 2013.12.23软件学院课程设计任务书指导教师：院长：日期：2013年12月9日软件学院课程设计进度安排表学生姓名：张文东学号： 1402120135 专业：软件工程班级：一班指导教师签名：2013年12月11日成绩评定表学生姓名：张文东学号： 1402120135 专业：软件工程班级：一班摘要摘要：随着科技的不断发展，人们生活水平的不断提高，方便、高效、快捷成为了人们所追求的主要目标，面对一些复杂的技术总会花费大量时间进行计算，因此有一个多项式功能的计算器是很有必要的。

开发这样一个程序需要用到C结点、链表方面的知识，系统分为多项式的输入输出、多项式的加法、多项式的减法、多项式的乘法四个模块。

该报告主要是通过系统的程序段、程序设计的要求以及计算器的功能来介绍该计算器实现过程。

关键字：多项式；C语言；结点；链表目录目录 (1)第一章课题背景 (2)1.1绪论 (2)1.2主要内容 (2)第二章设计简介及设计方案论述 (3)2.1系统分析 (3)2.2总体设计 (3)第三章详细设计 (5)3.1建立多项式 (5)3.2多项式相加 (7)3.3多项式相减 (9)3.4多项式相乘 (10)主要代码如下： (12)主要代码如下： (15)第四章设计结果及分析 (18)4.1调试与测试 (18)4.2运行结果 (20)4.3结果分析 (22)总结 (23)参考文献 (24)附录 (25)第一章课题背景1.1 绪论随着科技的进步，社会的不断发展，计算器已普遍应用于各行各业，为了帮助人们提高工作效率，节约运算时间，设计一个多功能的计算器是很有必要的，在此设计一个多项式计算器可以很方便的对多项式相加、相减、相乘，对提高人们的运算效率很有帮助。

一元稀疏多项式计算器实现（完整实现版详细源码）

1.5一元稀疏‎多项式计算‎器实习报告一、需求分析1．输入并建立‎多项式；2．输出多项式‎，输出形式为‎整数序列：n，c1，e1，c2，e2，……，c n，e n，其中n是多‎项式的项数‎，c i和ei‎分别是第i‎项的系数和‎指数，序列按指数‎降序排列；3．多项式a和‎b相加，建立多项式‎a＋b；4．多项式a和‎b相减，建立多项式‎a—b；5．多项式a和‎b相乘，建立多项式‎a×b；6．计算多项式‎在x处的值‎；7．求多项式P‎的导函数P‎'；8.多项式的输‎出形式为类‎数学表达式‎；9.做出计算器‎的仿真界面‎；10.测试数据：（1） (2x+5x^8-3.1x^11)+(7-5x^8+11x^9)=(-3.1x^11+11x^9+2x+7)（2） (6x^-3-x+4.4x^2-1.2x^9+1.2x^9)-(-6x^-3+5.4x^2-x^2+7.8x^15 ) =(-7.8x^15-1.2x^9+12x^-3-x);（3）(1+x+x^2+x^3+x^4+x^5)+(-x^3-x^4)=(1+x+x^2+x^5);（4）(x+x^3)+(-x-x^3)=0（5）(x+x^100)+(x^100+x^200)=(x+2x^100+x^200)（6）(x+x^2+x^3)+0=x+x^2+x^3（7）互换上述测‎试数据中的‎前后两个多‎项式二、概要设计1.链表的抽象‎数据类型定‎义为：ADT LinkL‎i st{数据对象：D＝{ ai | ai∈ElemS‎e t, i=1,2,...,n, n≥0 }数据关系：R1＝{ <ai-1, ai>|ai-1, ai∈D, i=2,...,n }基本操作：InitL‎i st(&L)操作结果：构造一个空‎的线性表L‎。

Destr‎o yLis‎t(&L)初始条件：线性表L已‎存在。

操作结果：销毁线性表‎L。

一个一元稀疏多项式简单计算器

//设计一个一元稀疏多项式简单计算器#include<stdio.h>#include<stdlib.h>struct tagNode{int coef; //多项式的系数int exp; //多项式的指数struct tagNode *next;};typedef struct tagNode Node; //重新定义结点名称typedef struct tagNode* pNode; //重新定义指针名称void TrailInsertList(pNode,int,int); //在链表表尾部插入结点void AddPolynomial(pNode,pNode); //将两个多项式相加void PrintPolynomial(pNode); //打印多项式int main(void){pNode pa,pb;//定义两个头指针pNode pFree;//定义一个释放指针pa=pb=NULL;Node heada,headb; //定义两个头结点heada.coef=headb.coef=0; //头结点的coef作为结点的个数heada.exp=headb.exp=-1; //头结点的exp无意义故赋给其-1的值heada.next=headb.next=NULL;//让头指针指向头结点pa=&heada;pb=&headb;int coef=0; //系数int exp =0; //指数//第一个多项式的输入printf("请分别输入第一个多项式的系数和指数，并以输入系数为0作为结束标志!\n");do{printf("系数: ");scanf("%d",&coef);printf("指数: ");scanf("%d",&exp);printf("\n");if(coef!=0)TrailInsertList(pa,coef,exp);}while(coef!=0);//第二个多项式的输入printf("请分别输入第二个多项式的系数和指数，并以输入系数为0作为结束标志!\n");do{printf("系数: ");scanf("%d",&coef);printf("指数: ");scanf("%d",&exp);printf("\n");if(coef!=0)TrailInsertList(pb,coef,exp);}while(coef!=0);AddPolynomial(pa,pb); //将两个多项式相加PrintPolynomial(pa); //打印出相加后的多项式pFree=pa->next;free(pFree); //释放动态申请的内存空间return 0;}void TrailInsertList(pNode pHead,int coef,int exp){pNode trail=NULL; //定义一个指向链表尾部的指针pNode newnode=NULL; //定义一个指向新结点的指针//让trail指针指向尾部的结点trail=pHead;while(trail->next!=NULL){trail=trail->next;}newnode=(struct tagNode *)malloc(sizeof(Node)); //申请一块大小为Node的内存空间if(!newnode) //如果申请失败{printf("Allocte memory failure!\n");exit(1); //退出}//初始化申请的新结点newnode->coef=coef;newnode->exp=exp;newnode->next=NULL;trail->next=newnode; //插入新结点pHead->coef++; //头结点的计算器加一}void AddPolynomial(pNode p1,pNode p2){pNode cur1=p1->next; //链表1,结果存放的地方pNode cur2=p2->next; //链表2pNode pre1=p1;pNode temp=NULL; //临时指针while(cur1!=NULL && cur2!=NULL)//当前两个链表都不为空{if(cur1->exp<cur2->exp)//比较链表1与链表2当前指数大小{pre1=cur1;cur1=cur1->next; //cur1指向下一个结点}else if(cur1->exp==cur2->exp) //链表1与链表2指数相等时{cur1->coef+=cur2->coef;if(cur1->coef!=0){pre1=cur1;}else{pre1->next=cur1->next; //保持链表1的连续性free(cur1);}cur1=pre1->next; //cur1指向要比较的下一个结点//下面是删除指针cur2指向的结点，因为结果已经存放在链表1的结点中temp=cur2;cur2=cur2->next;free(temp);}else //链表1当前结点的指数比链表2的大时{p2->next=cur2->next;cur2->next=cur1;pre1->next=cur2;pre1=cur2;cur2=p2->next;}}if(cur2) //如果链表2比链表1长{pre1->next=cur2;}p2->next=NULL;}void PrintPolynomial(pNode pHead){pNode p; //定义头指针p=pHead;p=p->next;while(p){printf("%dX(%d)",p->coef,p->exp);if(p->next){printf(" + ");}p=p->next;}printf("\n");}。

简单的一元多项式计算器程序

简单的一元多项式计算器程序简单的一元多项式计算器程序是一款用于求解一元多项式的数学工具。

该程序能够接收用户输入的多项式表达式，并根据用户的需求进行加法、减法、乘法、除法等基本运算，以及求导、积分等高级运算。

下面是该计算器程序的标准格式文本：一、程序介绍该一元多项式计算器程序是基于Python语言开发的，旨在提供一个简单易用的工具，帮助用户进行一元多项式的计算。

通过该程序，用户可以快速进行多项式的基本运算和高级运算，提高计算效率。

二、功能特点1. 支持一元多项式的输入：用户可以输入多项式表达式，例如2x^2 + 3x + 1，程序能够识别并进行计算。

2. 支持基本运算：程序支持一元多项式的加法、减法、乘法和除法运算，用户可以根据需要选择相应的运算。

3. 支持高级运算：程序还提供了求导、积分等高级运算功能，用户可以根据需要进行相关计算。

4. 提供友好的交互界面：程序提供了简洁、直观的用户界面，用户可以轻松输入多项式表达式，并查看计算结果。

5. 提供详细的计算过程：程序在计算过程中，会详细展示每一步的计算过程，让用户清晰了解计算的步骤和结果。

三、使用方法1. 输入多项式表达式：用户可以在程序界面中输入一元多项式的表达式，例如2x^2 + 3x + 1。

2. 选择运算类型：用户可以选择需要进行的运算类型，包括加法、减法、乘法、除法、求导和积分。

3. 查看计算结果：程序会根据用户的选择进行计算，并将计算结果显示在程序界面中。

四、示例演示假设用户输入了多项式表达式2x^2 + 3x + 1，并选择进行求导运算。

程序会按照如下步骤进行计算：1. 计算多项式的一阶导数：- 对2x^2求导，得到4x^1=4x；- 对3x求导，得到3；- 对1求导，得到0；2. 将各项导数相加，得到4x + 3。

五、注意事项1. 输入格式正确性：用户在输入多项式表达式时，请确保格式正确，例如每一项之间用"+"或"-"连接，指数使用"^"符号表示。

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

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功能模块图为实现上述程序功能，用带表头结点的单链表存储多项式。

(完整word版)一元多项式计算器报告(C语言编程)

题目：编制一个一元多项式基本运算的程序姓名: 学号:PB110130一、需求分析1．在通常的应用中，多项式的次数可能很高且变化很大，使得顺序存储结构的最大长度很难确定。

由稀疏多项式的特点，故采用链式存储结构，可以不会带来浪费存储空间。

2．程序中单链表存储，根据链表的指数域，对链表进行升序排序，可给运算带来方便。

3．程序设计是在VC6.0环境下设计的的。

4．程序执行的命令为（程序主界面）：二、概要设计抽象数据类型一元多项式的定义如下：1.LNode *MakeNode（double coef, int exp) 通过传入指数和系数创建一个节点,返回该节点的地址。

2.void InitList（LinkList &L）初始化,带头节点3.void PrintPolyn （LinkList L) 传入链表的指针，打印该链表4.LinkList CreatPolyn（void)//输入m项的系数和指数，建立表示一元多项式的有序链表L5.double SumPolyn(LinkList L,double x) 传入链表的指针及x值，求多项式的值。

6.void DestroyPolyn (LinkList &L) 销毁多项式，去掉头节点7.void ClearPolyn (LinkList ＆L) 清空多项式,保留节点实验报告8.void CopyPolyn (LinkList La，LinkList ＆Lb) 将La位置的多项式复制到Lb位置9.void AddPolyn（LinkList L,LinkList J ,LinkList ＆K) 将a和b多项式相加存到c10.void MultiplyPolyn（LinkList L，LinkList J，LinkList ＆K）将a和b相减存到c11. void MultiplyPolyn(LinkList L，LinkList J,LinkList ＆K）将a和b多项式相乘存到c12。

一元多项式计算器完整报告

1、课程设计目的1.1、本次课程设计的主要目的是设计一个一元多项式简单计算器，体会链式存存储结构和顺序存储结构各自的优缺点和适用性；1.2、了解并掌握数据结构与算法的设计方法，具备初步的独立分析和设计能力；1.3、初步掌握软件开发过程的问题分析、系统设计、程序编码、测试等基本方法和技1.4、提高综合运用所学的理论知识和方法独立分析和解决问题的能力；1.5、加深对常用数据结构的理解，强化学生的逻辑思维能力和动手能力，巩固良好的编程习惯，掌握工程软件设计的基本方法，为后续课程的学习打下坚实基础。

2、课程设计的准备和功能要求2.1、需求环境本课程设计需要的设备为硬件要求和软件配置要求具体要求如下：①硬件要求：一台计算机。

②软件配置：windows XP或windows 7、VC++6.0。

2.2、目标程序的功能要求集合链式存储结构和顺序存储结构实现一元多项式计算器的设计，并使该计算器具有以下功能：①能够按照多项式变量的指数降序创建一个多项式；②能够对已创建的多项式进行显示；③能够对已创建的多项式之间的加法运算；④能够对已创建的多项式之间的减法运算；⑤能够对已创建的多项式进行删除；⑥能够实现计算器退出操作；2.3、系统总框图3、课程设计过程3.1、菜单界面设计考虑到计算器的操作应具备简易性，我们采取用户和计算机的对话方式执行，即程序运行时，在计算机终端上显示该计算器的功能菜单栏，其中包括对应的选项共用户选择输入；当用户根据选项中的“提示信息”在键盘上输入多项式的项数及各项的系数和指数，然后进行显示、相加运算、相减运算、多项式删除以及计算器退出操作。

如下所示：用户菜单多项式的显示多项式的相加多项式的相减多项式的删除退出菜单多项式的建立3.2、菜单选项的实现对于计算器菜单中各选项的设计处理，我们采用了switch (menu) 语句并将各选项前的数字定义为字符型。

然后根据所输入的不同的memu列出对应的6种case分支情况。

一元稀疏多项式简单的计算器

1．一元稀疏多项式简单的计算器（实验类型：综合型）1）问题描述：用线性表表示一元稀疏多项式，设计一个一元多项式运算器2）实验要求:✧采用单链表存储结构一元稀疏多项式✧输入并建立多项式✧输出多项式✧实现多项式加、减运算3) 实现提示：以两个多项式相加为例✧结果多项式另存✧扫描两个相加多项式，若都未检测完：⏹若当前被检测项指数相等，系数相加，若结果未变成0，则将结果插入到结果多项式。

⏹若当前被检测项指数不等，则将指数较小者插入到结果多项式。

若有一个多项式已检测完，则将另一个多项式剩余部分直接连接到结果多项式。

4.一元稀疏多项式简单的计算器（实验类型：综合型）#include<stdio.h>#include<stdlib.h>typedef struct{float coef;//系数int expn;//指数} Term;typedef struct ploynomial{Term term;ploynomial* next;} ploynomial,*LinkList;void InitList(LinkList&L){//初始化链表L= (ploynomial*)malloc(sizeof(ploynomial));//头结点L->term.coef=0.0;L->term.expn=-1; L->next=NULL;}int cmp(Term a,Term b){//比较结点的系数大小函数if(a.expn>b.expn) return -1;else if(a.expn==b.expn) return 0; else return 1;}void insertNode(LinkList&L,Term e){//将结点插入多项式链表的适当位置，可以同时起到创建链表和多项式相加的功能ploynomial* q=L;while(q->next!=NULL){if(cmp(q->next->term,e)<0)//如果当前结点q的下一个结点的指数大于要插入的结点的指数q=q->next;//q指向下一个结点else break;//此时，q.term.expn>e.expn>=q->next->term.expn }if(q->next!=NULL&&cmp(q->next->term,e)==0) //指数相同，系数相加{q->next->term.coef+=e.coef;}else{ploynomial* node =(ploynomial*) malloc(sizeof(ploynomial));node->term.coef=e.coef;node->term.expn=e.expn;if(q->next==NULL)node->next=NULL; //如果q结点为尾结点，则node的指针域设为NULLelsenode->next=q->next; //否则node的指针域指向q的下一个结点q->next=node;//将node结点插入链表中}}void CreatPolyn(LinkList&L,int m){//输入m项的系数和指数，建立表示一元多项式的有序链表L Term e;InitList(L);for(int i=1; i<=m; i++){printf("\n第%d项的系数和指数：",i);scanf("%f%d",&e.coef,&e.expn);insertNode(L,e);}}void addPolyn(LinkList&L,LinkList L1,LinkList L2){//用L返回L1+L2的结果ploynomial* q;for(q=L1->next; q!=NULL; q=q->next){insertNode(L,q->term);//将L1的每一项插入到L中}for(q=L2->next; q!=NULL; q=q->next) //将L2的每一项插入到L 中{insertNode(L,q->term);}}void SubtracatPolyn(LinkList&L,LinkList L1,LinkList L2){//用L返回L1-L2的结果ploynomial* q;for(q=L1->next; q!=NULL; q=q->next){insertNode(L,q->term);//将L1的每一项插入到L中}for(q=L2->next; q!=NULL; q=q->next){q->term.coef = -(q->term.coef); //把系数变成相反数,再进行相加操作，即为L1-L2insertNode(L,q->term);//将L2的每一项插入到L中}}void multiplyPolyn(LinkList&L,LinkList L1,LinkList L2) {//用L返回L1*L2的结果ploynomial *p,*q;Term term;term.coef=0.0;term.expn=0;for(q=L1->next; q!=NULL; q=q->next){for(p=L2->next; p!=NULL; p=p->next){term.coef=(q->term.coef)*(p->term.coef);//系数相乘term.expn=(q->term.expn)+(p->term.expn);// 指数想加insertNode(L,term);}}}void derivativePolyn(LinkList&L,LinkList L1){//用L返回L1的导数ploynomial *p;Term term;for(p=L1->next; p!=NULL; p=p->next){if(p->term.expn==0){ continue;//指数为0时，导数为0 ，跳过此次循环}else{ term.coef=(p->term.coef)*(p->term.expn); //系数乘以指数term.expn=(p->term.expn)-1;//指数减一insertNode(L,term);}}}void visitList(LinkList L){//以类数学表达式的形式打印输出一元多项式L，//即指数或者系数为1的情况下省略1ploynomial* q=L;int flag;while(q->next!=NULL){q=q->next;flag=1;if(q->term.coef==0) continue;//系数为0 不输出if(q->term.expn==0&&flag==1) //指数为1{if(q->term.coef>0)printf("+%.2f",q->term.coef);elseprintf("%.2f",q->term.coef);flag=0;}if((q->term.coef==1||q->term.coef==-1)&&flag==1)//系数为1{if(q->term.expn==1){ if(q->term.coef==1)printf("+X"); elseprintf("-X");}else{if(q->term.coef==1)printf("+X^%d",q->term.expn); elseprintf("-X^%d",q->term.expn); } flag=0;}if(flag==1){ if(q->term.coef>0)printf("+%.2fX^%d",q->term.coef,q->term.expn);elseprintf("%.2fX^%d",q->term.coef,q->term.expn);} } printf("\n");}int main(){LinkList L1,L2; int n1,n2;printf("请输入多项式L1的项数：");scanf("%d",&n1);CreatPolyn(L1,n1);printf("请输入多项式L2的项数：");scanf("%d",&n2);CreatPolyn(L2,n2);printf("\n多项式L1:");visitList(L1);printf("\n多项式L2: ");visitList(L2);LinkListadd,sub,multiply,derivative1,derivative2;InitList(ad d);InitList(sub);InitList(multiply);InitList(derivative1);InitList(derivative2);derivativePol yn(derivative1,L1);derivativePolyn(derivative2,L2);printf("\nL1的导数：");visitList(derivative1);printf("\nL2的导数：");visitList(derivative2);addPolyn(add,L1,L2);SubtracatPolyn(sub,L1,L2);multiplyPolyn(multiply ,L1,L2);printf("\nL1 + L2: ");visitList(add);printf("\nL1 - L2: ");visitList(sub);printf("\nL1 * L2: ");visitList(multiply);}实验心得：无。

一元稀疏多项式计算器源代码

一元稀疏多项式计算器源代码#include#includetypedefstructnode{浮腔；intexp；structnode*next;}lnode,*polynmial;voidcreate（多项式&l）；//输入并建立一个多项式lvoiddisplay（polynamiall）//显示，输出多项式lvoidsort（polynomy&L）//多项式L按void reverse（polynomy&L）//Inverse void select（）//用户选择的加减运算voidadd(polynmialla,polynmiallb,polynmial&lc);//多项式voidsubtract(polynmialla,polynmiallb,polynmial&ld);//多项式Void create（多项式&L）//输入并创建多项式L{inti,n;静态结构节点*p；斯坎夫(\l=(structnode*)malloc(sizeof(structnode));l->next=null;for(i=0;i<n;i++){p=（structnode*）malloc（sizeof（structnode））；scanf（\p->next=l->next；l->next=p；}voiddisplay(polynmiall)//显示，输出多项式l{结构节点*p，*q；intflag=0；intk=0；q=l->next；while（q）{if(q->coef!=0)k++;q=q->next；la,lb相加La减去lbld，结果是}printf（\p=l->next；if（p->coef！=0）{printf(\flag++;}用于（p=p->next；p；p=p->next）{if(p->coef!=0){printf（\flag++；}}if(flag==0)printf（\else）printf(\}Void port（多项式&L）//多项式L按指数排序{polynmialp,q,r,u;p=l->next;l->next=null；while（p！=null）{r=l;q=l->next；while((q!=null)&&(q->exp<=p->exp)){r=q；q=q->next;}u=p->next；r->next=p；p->next=q；p=u；}voidreverse(polynmial&l)//逆置{polynmialh;静态结构节点*p，*q，*s；h=(structnode*)malloc(sizeof(structnode));h->next=null;p=（structnode*）malloc（sizeof（structnode））；s=l->next；p->coef=s->coef;p->exp=s->exp;p->next=s->next;while(s){p->coef=s->coef；p->exp=s->exp；p->next=s->next；q=h->next；h->next=p；p->next=q；p=(structnode*)malloc(sizeof(structnode));s=s->next;}p=h->next；q=l->next；while（p）{q->coef=p->coef;q->exp=p->exp;q=q->next;p=p->next;}}Void select（）//用户选择加法和减法{printf(\请选择加减操作\\n\Printf（\添加两个单变量多项式\\n\Printf（\减去两个单变量多项式\\n\}voidadd(polynmialla,polynmiallb,polynmial&lc)//{结构节点*pa，*pb；staticstructnode*pc；lc=(structnode*)malloc(sizeof(structnode));La，LB多项式加法pa=la->next;pb=lb->next;lc->next=null;while(pa&&pb){pc=（structnode*）malloc（sizeof（structnode））；如果（pa->exp<pb->exp）{pc->next=lc->next;lc->next=pc;pc->coef=pa->coef；pc->exp=pa->exp；pa=pa->next；}其他的if(pa->exp==pb->exp){pc->next=lc->next；lc->next=pc；pc->exp=pa->exp；pc->coef=pa->coef+pb->coef;pa=pa->next;pb=pb->next;}else{pc->next=lc->next；lc->next=pc；pc->coef=pb->coef;pc->exp=pb->exp;pb=pb->next;}}而（宾夕法尼亚州）{pc=(structnode*)malloc(sizeof(structnode));pc->next=lc->next;lc->next=pc;pc->coef=pa->coef；pc->exp=pa->exp；pa=pa->next；}while(pb){pc=（structnode*）malloc（sizeof（structnode））；pc->next=lc->next；lc->next=pc；pc->coef=pb->coef;pc->exp=pb->exp;pb=pb->next;}}Voidsubtract（polynmialla，polynmiallb，polynamil&LD）//多项式{structnode*pa,*pb;staticstructnode*pd;ld=（structnode*）malloc（sizeof（structnode））；pa=la->next；pb=lb->next；ld->next=null；while（pa和pb）{pd=(structnode*)malloc(sizeof(structnode));if(pa->exp<pb->exp){pd->next=ld->next；ld->next=pd；pd->coef=pa->coef;pd->exp=pa->exp;pa=pa->next;}else如果（pa->exp==pb->exp）{pd->next=ld->next;ld->next=pd;pd->exp=pa->exp;pd->coef=pa->coef pb->coef；pa=pa->next；pb=pb->next；}否则{pd->next=ld->next;ld->next=pd;pd->coef=pb->coef；pd->exp=pb->exp；la减去lb，结果给ld。

一元多项式计算器完整报告

2、课程设计的准备和功能要求2.1、需求环境本课程设计需要的设备为硬件要求和软件配置要求具体要求如下：①硬件要求：一台计算机。

②软件配置：windows XP或windows 7、VC++6.0。

然后根据所输入的不同的memu列出对应的6种case分支情况。

c实现一元多项式运算器

//c实现一元多项式运算器#include <stdio.h>#include <stdlib.h>#include <math.h>#define OK 1#define ERROR 0#define TRUE 1#define FALSE 0typedef struct Polynode{int coef;int exp;struct Polynode *next;}Polynode, *Polylist;void polycreate(Polylist head){Polynode *rear, *n;int c,e;rear=head; // rear 始终指向单链表的尾，便于尾插法建表scanf("%d,%d",&c,&e); //输入多项式的系数和指数项while(c!=0) //若c=0，则代表多项式的输入结束{n=(Polynode*)malloc(sizeof(Polynode)); //申请新的结点n->coef=c;n->exp=e;rear->next=n; //在当前表尾做插入rear=n;scanf("%d,%d",&c,&e);}rear->next=NULL; //将表的最后一个结点的next置NULL，以示表结束}void show(Polylist head){if(head->next==NULL)printf("0");else{printf("%d",head->next->coef);printf("X^%d",head->next->exp);head=head->next->next;while(head!=NULL){if(head->coef>0) printf("+%d",head->coef);else printf("%d",head->coef);printf("X^%d",head->exp);head=head->next;}}printf("\n\n");}void polyadd(Polylist polya, Polylist polyb){Polynode *p, *q, *temp;int sum;Polylist r;p=polya->next; //令 p和q分别指向polya和polyb多项式链表的第一个结点q=polyb->next;r=polya; // r指向和多项式的尾结点r->next=NULL;temp=r;while (p!=NULL && q!=NULL) //当两个多项式均未扫描结束时{if(p->exp < q->exp) //若p的指数小于q的指数，将p加入到和多项式中{r->next=p;r=p;p=p->next;}else if ( p->exp == q->exp) //若指数相等，则相应的系数相加{sum=p->coef + q->coef;if (sum != 0){p->coef=sum;r->next=p;r=p;p=p->next;temp=q;q=q->next;free(temp);}else{temp=p;p=p->next;free(temp); //若系数和为零，则删除p与q，并指向下一结点temp=q;q=q->next;free(temp);}}else{r->next=q;r=q; //将q结点加入到和多项式中q = q->next;}}if(p!=NULL) //多项式A中还有剩余，则将剩余的结点加入到和多项式中r->next=p;else //否则，将B中的结点加入到和多项式中r->next=q;}void caculate(Polylist head){float x,sum=0;printf("请输入X的值:");scanf("%f",&x);while(head->next!=NULL){sum=sum+head->next->coef*pow(x,head->next->exp);head=head->next;}printf("\n多项式结果为:%f\n",sum);}int main(){Polylist polya,polyb;int flag;Polynode *p;printf("请输入数据建立多项式A:(以0,0结束!)\n");polya=(Polynode *)malloc(sizeof(Polynode));polycreate(polya);printf("\n输入的多项式A为:");show(polya);printf("请输入数据建立多项式B:(以0,0结束!)\n");polyb=(Polynode *)malloc(sizeof(Polynode));polycreate(polyb);printf("\n输入的多项式B为:");show(polyb);printf("\t1:代数式相加\n");printf("\t2:代数式相减\n\n");printf("请选择运算类型:");scanf("%d",&flag);if(flag==1) //加法计算{polyadd(polya,polyb);printf("\n相加后的多项式为:");}else //要计算减法，将多项式B的各项系数置为相反数后求和{p = polyb;while(p->next!=NULL){p->next->coef=-p->next->coef;p=p->next;}polyadd(polya,polyb);printf("\n相减后的多项式为:");}show(polya);caculate(polya);return 0;}。

一元稀疏多项式计算器c语言

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

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

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

二、需求分析。

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

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

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

三、设计方案。

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

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

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

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

2.多项式运算。

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

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

3.系数排序。

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

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

4.多项式表示。

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

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

四、实现细节。

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

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

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

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

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

五、总结。

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

一元稀疏多项式计算器c语言

一元稀疏多项式计算器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;```这个计算器使用了链表来表示多项式，每个节点包含一个系数和一个指数。

一元稀疏多项式计算器实验报告(c++编写,附源代码)

一元稀疏多项式计算器实验报告级班年月日姓名学号_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）为了实现上述程序功能，需要定义多项式结点的抽象数据类型：class Term{数据对象：floatcoef;该数据对象为多项式一项中的系数。

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

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

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

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

一元多项式计算器设计与实现

一元稀疏多项式简单计算器一、设计课题设计一元稀疏多项式简单计算器。

二、需求分析2.1 输入的形式和输入值的范围：输入是从键盘输入的，输入的内容为多项式的系数和指数，数为任意的整数，指数为大于等于0的整数2.2 输出的形式从屏幕输出，显示用户输入的多项式，并显示多项式加减以后的多项式的值。

2.3 程序所能达到的功能a：输入并建立多项式；b：输出多项式，输出形式为整数序列：n,c1,e1,c2,e2,……,cn,en,其中n是多项式的项数，ci和ei 分别是第i项的系数和指数，序列按指数降序排列；c：多项式a和b相加，建立多项式a+b；d：多项式a和b相减，建立多项式a-b；2.4 测试数据（1）(2x+5x^8-3.1x^11)+(7-5x^8+11x^9) = (-3.1x^11+11X^9+2X+7)（2）(X+X^3)+(-X-X^3)=0（3）(X+X^2+X^3)+0= X+X^2+X^3三、概要设计3.1 设计思路A：数据结构的选用为了实现任意多项式的加法、减法，因此选择单链表的结构体，它有一个系数，指数，下一个指针3个元属；单链表抽象结构类型定义见附录2。

B：多项式的输入采用头节点插法的方式，输入多项式中一个项的系数和指数，就产生一个新的节点，建立起它的右指针，并用头节点指向它；为了判断一个多项式是否输入结束，定义一个结束标志，当输入非00时就继续，当输入00时，就结束一个多项式的输入；C：2个多项式的加法它从2个多项式的头部开始，2个多项式的某一项都不为空时，如果指数相等的话，系数就应该相加；相加的和不为0的话，用头插法建立一个新的节点。

p的系数小于q的系数的话，就应该复制q接点到多项式中。

p的系数大于q的系数的话，就应该复制p接点到多项式中。

当第2个多项式空，第1个数不为空时，将第一个数剩下的全用新节点产生。

当第1个多项式空，第1个数不为空时，将第2个数剩下的全用新节点产生D：2个多项式的减法它从2个多项式的头部开始，2个多项式的某一项都不为空时，如果指数相等的话，系数就应该相减；相加的和不为0的话，用头插法建立一个新的节点。

一元多项式计算器 c语言

typedef struct Linklistomial{
float coef;
int expn;
struct Linklistomial *next;
}Linklistomial,*Linklist;
void Insert(Linklist p,Linklist h){
Linklist qa=pa->next;
Linklist qb=pb->next;
Linklist headc,hc,qc;
hc=(Linklist)malloc(sizeof(struct Linklistomial));//建立头结点
hc->next=NULL;
scanf("%f %d",&p->coef,&p->expn);
Insert(p,head); //调用Insert函数插入结点
}
return head;
}
void DestroyLinklist(Linklist p){ //销毁多项式p
qc->expn=qa->expn;
qa=qa->next;
qb=qb->next;
break;
}
case -1: {
qc->expn=qa->expn;
qa=qa->next;
break; }
case 0: {
qc->coef=qa->coef-qb->coef;
qc->coef=-qb->coef;
qc->expn=qb->expn;