(整理)一元稀疏多项式计算器

合集下载

一元稀疏多项计算器【加法和减法】

Data Structure.实习报告【实习一线性表、堆栈和队列的应用】一元稀疏多项式运算器Xiaohui HuangChina University of Geosciences(Wuhan) , Wuhan,Wuhan , Hubei Province , China ;Email : hxh1994@/hxh20111003570@1.问题描述设计一个一元稀疏多项式简单计算器。

要求为：（1）输入并建立两个多项式；（2）多项式a与b相加，建立和多项式c；（3）多项式a与b相减，建立和多项式d；（4）输出多项式a,b,c,d。

输出格式：比如多项式a为：A(x)=c1x e1+ c2x e2+…+ c m x em，其中，c i 和e i分别为第i项的系数和指数，且各项按指数的升幂排列，即0≤e1＜e2＜…＜e m。

2.设计◆设计思想我们知道，一个一元多项式可表示为A(x)=a0+a1x+a2x2+⋯+a n x n 其中，a0、a1、a2、…、a n为多项式的系数，惟一确定了这个多项式，而每一项的指数这隐藏在系数a i的序号中了。

那么我们可以使用线性表(a0、a1、a2、…、a n)来表示。

设A=(a0、a1、a2、…、a n)，B=(b0、b1、b2、…、b n)，则多项式的加法就相当于A+B=C，其中，C=(c0、c1、c2、…、c n)，其中c i=a i+b i。

◆概要设计从设计思想我们可以得知我们这个程序的主要功能是模拟计算器的加法和减法功能。

那么问题就归结于创建两个线性表，通过线性表相对应元素的相加减来模拟计算器的功能。

现在的问题是：我们应该选择什么类型的线性表、我们应该选择线性表的哪一种存储结构。

通过我们所学习的知识可以知道，我们有线性表、堆栈和队列等来可供选择，而经过考虑后，多项式的建立应该使用一种线性结构，故我们选择线性表。

另一方面，我们知道一个多项式并不是每一项的系数是存在的，比如一个只含有两个项的多项式，其中，一个项的指数是1，一个项的指数是1000，如果此时我们采用线性表的顺序存储结构，那么会极大的浪费内存空间。

数据结构实习报告——一元稀疏多项式运算器的设计

数据结构实习报告——一元稀疏多项式运算器的设计一、引言在计算机科学领域中，数据结构是研究数据组织、存储和管理的关键概念之一。

在本次实习中，我设计并实现了一个一元稀疏多项式运算器，旨在使用适当的数据结构和算法来高效地进行多项式的加法、减法和乘法运算。

本报告将详细介绍该运算器的设计思路、算法实现以及性能评估。

二、设计思路1. 多项式的表示在设计多项式运算器时，首先需要确定多项式的表示方法。

为了高效地处理稀疏多项式，我选择使用链表作为基本数据结构。

每个节点包含多项式的系数和指数，并通过指针连接在一起形成链表。

这种表示方法可以有效地处理稀疏多项式，减少了不必要的空间浪费。

2. 多项式的输入和输出为了方便用户输入和输出多项式，我设计了简单的交互界面。

用户可以通过命令行输入多项式的系数和指数，并选择进行的运算操作。

运算结果将直接在命令行中输出。

三、算法实现1. 多项式的加法多项式的加法是指将两个多项式相加得到一个新的多项式。

为了实现这个功能，我设计了一个算法如下：- 创建两个空的链表，分别表示两个多项式。

- 逐个读取用户输入的系数和指数，并将其插入到相应的链表中。

- 对两个链表进行遍历，根据指数的大小关系进行合并操作。

- 将合并后的结果链表输出。

2. 多项式的减法多项式的减法是指将一个多项式减去另一个多项式得到一个新的多项式。

为了实现这个功能，我设计了一个算法如下：- 创建两个空的链表，分别表示两个多项式。

- 逐个读取用户输入的系数和指数，并将其插入到相应的链表中。

- 对第二个链表中的每个节点的系数取相反数。

- 对两个链表进行遍历，根据指数的大小关系进行合并操作。

- 将合并后的结果链表输出。

3. 多项式的乘法多项式的乘法是指将两个多项式相乘得到一个新的多项式。

为了实现这个功能，我设计了一个算法如下：- 创建一个空的链表，表示乘法结果。

- 逐个读取用户输入的系数和指数，并将其插入到链表中。

- 对第一个链表中的每个节点，与第二个链表中的每个节点进行乘法运算，并将结果插入到结果链表中。

实验报告——2一元稀疏多项式计算器

2345、z34、
(3)(1+x+x +x +x +x ) +( -x-x )
(4)(x+x2+x3)+0
(5)(x+x3)-(-x-x-3)
⑹(x+x2+x3)+0
三、实验内容
主要算法设计
typedef struct Node
{
float coef;
int in dex;
struct Node *n ext;
{
LinkList *pc;
int flag=0;
while(flag==0)
{
if(pb->next==NULL)
flag=1;
else
{
pb=pb->next;
pc=(LinkList *)malloc(sizeof(LinkList));
pc->coef=-pb->coef; pc->index=pb->index; pc->next=NULL;
主冃主冃斗冃主
2,1
5,B -3.1,11
项式b的项数；3 7,0-5.8ffl-ltb疏多项式计算器
3
»■快I列歹序序1数2数弓整t(展lt4L2^^bm、」丄-TrJ二上M?E--uMr.选项选项选现岀岀岀4-.冷丄#-W
3
nV为===*
,2,1
,7,
请输更入塾项更蠢製扌吐亟人第2项更薑癒吋备入第咗项的系数却1逼△鄴项翌謎I诰倉△第2项更舍魅吐亟人＞项聶入第4项的系数稲
Insert(pc,head);
}
}
return head;
void main()

一元稀疏多项式计算器数据结构

一元稀疏多项式计算器数据结构一元稀疏多项式计算器是一种用于计算多项式的工具，该工具可以用于代数计算、数学分析以及计算机科学中的算法设计。

它可以通过一种特殊的数据结构来存储多项式，并可以对其进行加法、减法、乘法、除法等运算。

这种数据结构被称为稀疏多项式，它是一种基于链表的数据结构。

在稀疏多项式中，每个节点表示一个单项式，节点的数据包含该单项式的系数和指数。

在一个稀疏多项式中，只有少数几个节点表示一个多项式，这就是稀疏性的来源。

稀疏多项式的加法和减法非常简单，只需要对两个多项式的对应节点进行加减即可。

而稀疏多项式的乘法需要更复杂的算法。

乘法的过程中需要将两个多项式的每个单项式乘起来，并将同类项合并成一个新的多项式。

这个过程涉及到大量的链表操作，但只要注意一些细节，将会得到正确的结果。

除了基本的加法、减法、乘法运算，一元稀疏多项式计算器还有一个非常重要的运算，那就是求导。

求导是一种将多项式每个单项式的指数减一，并将系数乘以指数的运算。

它常用于解决微积分、概率论等问题。

求导操作可以通过修改节点的指数和系数来实现。

在计算机科学中，稀疏多项式可以用于设计高效的算法，例如在数论、密码学、图像处理、计算器表达式求值等方面。

稀疏多项式的优点在于它可以有效地节省存储空间和计算时间。

通过动态链表的形式，可以轻松地添加、删除节点，使得稀疏多项式非常适合用于处理大规模的数据。

总的来说，一元稀疏多项式计算器是一种非常实用的工具。

它可以用于解决多项式运算问题，并可以为计算机科学方面的算法设计提供很大的帮助。

通过了解这种数据结构，我们可以更深入地理解代数学、微积分学等数学原理，并且能够更好地应用于实际问题中。

c一元稀疏多项式计算器-课程设计实验报告

2016-2017学年第二学期学号1608220203 《网络工程》课程设计报告题目:一元稀疏多项式计算器专业:网络工程班级:网络工程(3)班姓名:代应豪指导教师:代美丽成绩:[键入文字] [键入文字] [键入文字]一、问题描述 (3)二、需求分析 (3)三、概要设计 (4)四、详细设计 (5)五、源代码 (6)六、程序测试 (19)七、使用说明 (25)八、课设总结 (26)一、问题描述1.1基本要求(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)计算器的仿真界面。

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

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

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

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

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

元稀疏多项式计算器实验报告c编写,附源代码(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以上实验结果均能正确输出。

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

(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.5一元稀疏多项式计算器实习报告一、需求分析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．多项式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 LinkList{数据对象：D＝{ ai | ai∈ElemSet, i=1,2,...,n, n≥0 }数据关系：R1＝{ <ai-1, ai>|ai-1, ai∈D, i=2,...,n }基本操作：InitList(&L)操作结果：构造一个空的线性表L。

DestroyList(&L)初始条件：线性表L已存在。

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

ClearList(*L)初始条件：线性表L已存在。

操作结果：将线性表L重置为空表。

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

一、课程设计概述：本次数据结构课程设计共完成五个题：一元稀疏多项式计算器、迷宫问题、成绩分析问题、图的基本操作与实现以及背包问题的求解使用语言：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;}}[调试分析]本程序主要的操作对象是记录数组，使用的存储结构是结构体数组。

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

数据结构课程设计:系别计算机与通信工程学院专业计算机科学与技术班级学号姓名|指导教师成绩2012年7 月12 日一、需求分析1、问题描述：（需求分析和背景意义）\设计一个一元稀疏多项式简单计算器.2、基本要求：（设计阶段，概要设计和详细设计）一元稀疏多项式简单计算器的基本功能是:(1)输入并建立多项式;(2)输出多项式,输出形式为整数序列:n,c1,e1,c2,e2,…,cn,en,其中n是多项式的项数,ci和ei分别是第i项的系数和指数,序列按指数降序排列;(3)多项式a和b相加,建立多项式a+b;(4)多项式a和b相减,建立多项式a-b.3、测试数据：(2x++(7-5x8+11x9)=+11x9+2x+7)(6x-3-x+互换上述测试数据中的前后两个多项式4、实现提示：}用带表头结点的单链表存储多项式5、选做内容：(1)计算多项式在x处的值.(2)求多项式a的导函数a′.(3)多项式a和b相乘,建立乘积多项式ab.(4)多项式的输出形式为类数学表达式.例如,多项式-3x8+6x3-18的输出形式为-3x∧8+6x∧3 -18,x15+(-8)x7-14的输出形式为x∧15-8x∧7-14.注意,系数值为1 的非零次项的输出形式中略去系数1,如项1x8的输出形式为x8,项-1x3的输出形式为-x3.(5) 计算器的仿真界面.二、详细设计本程序采用VS2010编写，开始创建了一个工程，本程序的文件有：?头文件：用以定义全局变量用以声明函数源文件：用以定义函数主函数下面罗列每个文件主要代码#ifndef DEFINE_H#define DEFINE_H#include<iostream>—using namespace std;#include<>struct linklistmultinomial{float a;int e;struct linklistmultinomial *next;};typedef struct linklistmultinomial *linklist,node;—#endif#ifndef FUNCTION_H#define FUNCTION_H#include""void welcome();…void goodbye();linklist createlinklist(linklist head,int n);void insert(linklist p,linklist head);void printlinklist(linklist head);void addlinklist(linklist pa,linklist pb);void sublinklist(linklist pa,linklist pb);void dlinklist(linklist pa);void calclinklista(linklist pd,int x);void menu();;#endif#include""入计算器0.退出\n\n"<<endl;}出多项式a 2.输出多项式b "<<endl;cout<<" 3.输出a+b 4.输出a-b "<<endl;cout<<" 5.输出a的导数 6.计算多项式a在x处的值"<<endl;[cout<<" 7.计算多项式b在x处的值0.返回主菜单\n\n"<<endl;cout<<"*********************************************************************\n\n\n\n\n\ n\n";while(q!=0){cout<<"请输入命令"<<endl;cin>>q;switch(q){case 1:printlinklist(pa);break;case 2:printlinklist(pb);break;case 3:addlinklist(pa,pb);break;~case 4:sublinklist(pa,pb);break;case 5:dlinklist(pa);break;case 6:cout<<"输入x"<<endl;cin>>x;calclinklista(pa,x);break;case 7:cout<<"输入x"<<endl;cin>>x;calclinklista(pb,x);break;case 0:q=0;break;default:cout<<"输入错误，请重新输入"<<endl;}}}三、调试分析！在这个程序写完后的调试过程中，出现了以下问题：1、printlinklist函数刚开是测试会出现首项系数为正，带加号的情况，加了个选择后解决此问题。

实验报告(实验二：一元稀疏多项式计算器)

云南大学软件学院实验报告指导教师：朱艳萍 2009秋季学期学号：20081120064 姓名：李雪寒【实验题目】实验2. 一元稀疏多项式简单计算器【问题描述】设计并实现一个一元稀疏多项式的简单计算器。

【基本要求】一元稀疏多项式简单计算器的基本功能是：1.输入并建立多项式；2.输出多项式，序列按指数降序排列；3.多项式a和b相加，并建立多项式a+b；4.多项式a和b相减，并建立多项式a-b；【实现提示】1.用带头节点的单链表作为多项式的存储结构；一、【概要设计】链式存储结构，由于不要求逻辑上相邻的元素在物理上也相邻，因此，能够迅速进行插入或删除操作，而且不像顺序存储结构那样需要移动大量元素，但也没有顺序表那样随机存取的优点。

主程序中通过调用void create(polynmial &L) 创建存储在单链表中的多项式，调用void display(polynmial L); 输出显示多项式，调用void sort(polynmial &L)和void reverse(polynmial &L)对多项式进行排序，使其按降序排列，调用void add(polynmial La,polynmial Lb, polynmial &Lc) 和void subtract(polynmial La, polynmial Lb, polynmial &Ld) 对两个多项式进行加减操作。

二、【详细设计】在此次试验中，主要通过以下7个子函数对存储在单链表中的多项式进行操作：void create(polynmial &L) //输入并建立多项式L{int i, n;static struct node *p;printf("输入多项式项数：\n");scanf("%d", &n);//输入多项式的项数L = (struct node *)malloc (sizeof(struct node));L->next = NULL;for(i = 0; i < n; i++){p = (struct node *)malloc(sizeof(struct node));printf("输入一个项的系数和指数，用空格隔开：\n");scanf("%f %d", &p->c, &p->e);p->next = L->next;L->next = p;}//利用for循环输入多项式中每一项的系数和指数}void display(polynmial L)//显示，输出多项式L{struct node *p, *q;//建立两个结点int flag = 0;int k = 0;q = L->next;while(q){if(q->c!= 0)k++;//计算多项式的项数q = q->next;}printf("共%d项\n", k);//输出多项式的项数p = L->next;if(p->c != 0){printf("+%.1fx^%d", p->c, p->e);flag++;}//判断该项是否为零，不为零则输出for(p = p->next; p; p = p->next){if(p->c != 0){printf("+%.1fx^%d", p->c, p->e);flag++;}}//输出多项式if(flag == 0)printf("%d\n", flag);elseprintf("\n");}void sort(polynmial &L)//多项式L按指数排序{polynmial p, q, r, s;p = L->next;L->next = NULL;while(p != NULL){r = L;q = L->next;while((q != NULL) && (q->e <= p->e)){r = q;q = q->next;}s = p->next;r->next = p;p->next = q;p = s;}}void reverse(polynmial &L)//逆置{polynmial H;static struct node *p, *q, *s;H = (struct node*)malloc(sizeof(struct node));H->next = NULL;p = (struct node*)malloc(sizeof(struct node));s = L->next;p->c = s->c;p->e = s->e;p->next = s->next;while(s){p->c = s->c;p->e = s->e;p->next = s->next;q = H->next;H->next = p;p->next = q;p = (struct node*)malloc(sizeof(struct node));s = s->next;}p = H->next;q = L->next;while(p){q->c = p->c;q->e = p->e;q = q->next;p = p->next;}}void select() //用户选择加减操作{printf("请选择加减操作\n");printf("1.两个一元多项式相加\n");printf("2.两个一元多项式相减\n");}void add(polynmial La, polynmial Lb, polynmial &Lc)//多项式La,Lb相加，并付给Lc {struct node *pa, *pb;static struct node *pc;Lc = (struct node*)malloc(sizeof(struct node));pa = La->next;pb = Lb->next;Lc->next = NULL;while(pa && pb){pc = (struct node*)malloc(sizeof(struct node));if(pa->e < pb->e){pc->next = Lc->next;Lc->next = pc;pc->c = pa->c;pc->e = pa->e;pa = pa->next;}elseif(pa->e == pb->e){pc->next = Lc->next;Lc->next = pc;pc->e = pa->e;pc->c = pa->c + pb->c;pa = pa->next;pb = pb->next;}else{pc->next = Lc->next;Lc->next = pc;pc->c= pb->c;pc->e = pb->e;pb = pb->next;}}while(pa){pc = (struct node*)malloc(sizeof(struct node));pc->next = Lc->next;Lc->next = pc;pc->c = pa->c;pc->e = pa->e;pa = pa->next;}while(pb){pc = (struct node*)malloc(sizeof(struct node));pc->next = Lc->next;Lc->next = pc;pc->c = pb->c;pc->e = pb->e;pb = pb->next;}}void subtract(polynmial La, polynmial Lb, polynmial &Ld)//多项式La减去Lb，结果赋给Ld{struct node *pa, *pb;static struct node *pd;Ld = (struct node*)malloc(sizeof(struct node));pa = La->next;pb = Lb->next;Ld->next = NULL;while(pa && pb){pd = (struct node*)malloc(sizeof(struct node));if(pa->e< pb->e){pd->next = Ld->next;Ld->next = pd;pd->c= pa->c;pd->e = pa->e;pa = pa->next;}elseif(pa->e == pb->e){pd->next = Ld->next;Ld->next = pd;pd->e= pa->e;pd->c = pa->c - pb->c;pa = pa->next;pb = pb->next;}else{pd->next = Ld->next;Ld->next = pd;pd->c = pb->c;pd->e = pb->e;pb = pb->next;}}while(pa){pd = (struct node*)malloc(sizeof(struct node));pd->next = Ld->next;Ld->next = pd;pd->c = pa->c;pd->e = pa->e;pa = pa->next;}while(pb){pd = (struct node*)malloc(sizeof(struct node));pd->next = Ld->next;Ld->next = pd;pd->c = -pb->c;pd->e = pb->e;pb = pb->next;}}三、【测试结果】四、【实验总结】此次实验较实验一来说要难得多，算法也复杂得多，原因主要有：1、C语言的应用很生疏，有待加强；2、对于单链表的插入和删除操作不熟练，需要借助课本和资料进行参考；3、程序比较复杂，算法思想也很难理清，需要多加锻炼。

(完整word版)一元稀疏多项式计算器实验(报告+程序)

一元稀疏多项式计数器预习报告姓名：刘茂学号222012315220062一、实验要求（1)输入并建立多项式；(2）输出多项式，输出形式为整数序列:n，c1，e1，c2，e2……cn，en，其中n是多项式的项数,ci，ei分别为第i项的系数和指数.序列按指数降序排列；（3）多项式a和b相加，建立多项式a+b；（4)多项式a和b相减，建立多项式a—b。

（5）多项式求值;(6）多项式求导；（7）求多项式的乘积。

二、测试数据: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、互换上述测试数据中的前后两个多项式.三、思路分析用带表头结点的单链表存储多项式.本程序要求输入并建立多项式,能够降幂显示出多项式,实现多项式相加相减的计算问题，输采用链表的方式存储链表，定义结点结构体.运用尾差法建立两条单链表，以单链表polyn p 和polyn h分别表示两个一元多项式a和b.为实现处理，设p、q分别指向单链表polya和polyb的当前项,比较p、q结点的指数项。

① 若p—〉expn〈q—>expn,则结点p所指的结点应是“和多项式”中的一项，令指针p 后移。

② 若p->expn=q—〉expn，则将两个结点中的系数相加，当和不为0时修改结点p的系数。

③ 若p—>expn>q—>expn,则结点q所指的结点应是“和多项式"中的一项,将结点q插入在结点p之前,且令指针q在原来的链表上后移.四、实验程序//头文件#include〈stdio.h>#include<malloc。

一元稀疏多项式计算器实验报告(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表示指向下一个多项式结点的指针)。

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

数据结构课程设计系别计算机与通信工程学院专业计算机科学与技术班级学号姓名/raichen 指导教师成绩2012年7 月12 日一、需求分析1、问题描述：（需求分析和背景意义）设计一个一元稀疏多项式简单计算器.2、基本要求：（设计阶段，概要设计和详细设计）一元稀疏多项式简单计算器的基本功能是:(1)输入并建立多项式;(2)输出多项式,输出形式为整数序列:n,c1,e1,c2,e2,…,cn,en,其中n是多项式的项数,ci和ei分别是第i项的系数和指数,序列按指数降序排列;(3)多项式a和b相加,建立多项式a+b;(4)多项式a和b相减,建立多项式a-b.3、测试数据：(2x+5x8-3.1x11)+(7-5x8+11x9)=(-3.1x11+11x9+2x+7)(6x-3-x+4.4x-2-1.2x9)-(-6x-3+5.4x2-x2+7.8x15)(1+x+x2+x3+x4+x5)+(-x3-x4)=(1+x+x2+x5)(x+x3)+(-x-x3)=0(x+x100)+(x100+x200)=(x+2x100+x200)(x+x2+x3)+0=x+x2+x3互换上述测试数据中的前后两个多项式4、实现提示：用带表头结点的单链表存储多项式5、选做内容：(1)计算多项式在x处的值.(2)求多项式a的导函数a′.(3)多项式a和b相乘,建立乘积多项式ab.(4)多项式的输出形式为类数学表达式.例如,多项式-3x8+6x3-18的输出形式为-3x∧8+6x∧3 -18,x15+(-8)x7-14的输出形式为x∧15-8x∧7-14.注意,系数值为1 的非零次项的输出形式中略去系数1,如项1x8的输出形式为x8,项-1x3的输出形式为-x3.(5) 计算器的仿真界面.二、详细设计本程序采用VS2010编写，开始创建了一个工程，本程序的文件有：头文件：define.h 用以定义全局变量function.h 用以声明函数源文件：function.cpp 用以定义函数main.cpp 主函数下面罗列每个文件主要代码define.h#ifndef DEFINE_H#define DEFINE_H#include<iostream>using namespace std;#include<stdlib.h>struct linklistmultinomial{float a;int e;struct linklistmultinomial *next;};typedef struct linklistmultinomial *linklist,node;#endiffunction.h#ifndef FUNCTION_H#define FUNCTION_H#include"define.h"void welcome();void goodbye();linklist createlinklist(linklist head,int n);void insert(linklist p,linklist head);void printlinklist(linklist head);void addlinklist(linklist pa,linklist pb);void sublinklist(linklist pa,linklist pb);void dlinklist(linklist pa);void calclinklista(linklist pd,int x);void menu();#endiffunction.cpp#include"define.h"//欢迎界面void welcome(){cout<<"\n\n\n\n\n";cout<<"*********************************************************************\n\n"<<endl ;cout<<" 一元稀疏多项式计算器\n\n"<<endl;cout<<" 制作者：王雨辰学号：4100113 \n\n"<<endl;cout<<"*********************************************************************\n\n\n\n\n\n\ n";cout<<" 请输入请求\n\n"<<endl;cout<<" 1.进入计算器0.退出\n\n"<<endl;}//结束界面void goodbye(){system("cls");cout<<"\n\n\n\n\n"<<endl;cout<<"*********************************************************************\n\n"<<endl ;cout<<" 谢谢使用，再见\n\n"<<endl;cout<<"*********************************************************************\n\n\n\n\n\n\ n";}//创建链表后按照次方从大到小插入void insert(linklist p,linklist head){if(p->a==0) free(p);else{linklist p1,p2;p1=head;p2=p1->next;while(p2&&p2->e>p->e){p1=p2;p2=p2->next;}if(p2&&p2->e==p->e){p2->a=p2->a+p->a;free(p);if(p2->a==0){p1->next=p2->next;free(p2);}}else{p->next=p2;p1->next=p;}}}//创建链表linklist createlinklist(linklist head,int n){linklist p;int i;p=head=(linklist)malloc(sizeof(node));head->next=NULL;for(i=1;i<=n;i++){p=(linklist)malloc(sizeof(node));cout<<"请输入第"<<i<<"项系数"<<endl;cin>>p->a;cout<<"请输入第"<<i<<"项指数"<<endl;cin>>p->e;insert(p,head);}return head;}//输出函数void printlinklist(linklist head)s{linklist p=head->next;if(!p) cout<<"0";else //处理首项，若系数为正，省略+{if(p->a==1){if(p->e==0) cout<<"1";else cout<<"x^"<<p->e;}elseif(p->a==0);elseif(p->a<0){if(p->e==0) cout<<p->a;else cout<<p->a<<"x^"<<p->e;}else{if(p->e==0) cout<<p->a;else cout<<p->a<<"x^"<<p->e;}p=p->next;}while(p){if(p->a==1){if(p->e==0) cout<<"+1";else cout<<"+x^"<<p->e;}elseif(p->a==-1){if(p->e==0) cout<<"-1";else cout<<"-x^"<<p->e;}elseif(p->a==0);elseif(p->a<0){if(p->e==0) cout<<p->a;else cout<<p->a<<"x^"<<p->e;}else{if(p->e==0) cout<<'+'<<p->a;else cout<<'+'<<p->a<<"x^"<<p->e;}p=p->next;}cout<<endl;}//a+bvoid addlinklist(linklist pa,linklist pb){linklist pc;linklist p1,p2,p3,p;p3=pc=(linklist)malloc(sizeof(node));p1=pa->next;p2=pb->next;if(!(p1||p2)) p3->next=NULL;else{while(p1||p2){p=p3->next=(linklist)malloc(sizeof(node));if(p1==NULL) {p->a=p2->a;p->e=p2->e;p2=p2->next;}else if(p2==NULL) {p->a=p1->a;p->e=p1->e;p1=p1->next;}else{if(p1->e==p2->e){p->a=p1->a+p2->a;p->e=p1->e;p1=p1->next;p2=p2->next;}else if(p1->e>p2->e) {p->a=p1->a;p->e=p1->e;p1=p1->next;}else if(p1->e<p2->e) {p->a=p2->a;p->e=p2->e;p2=p2->next;}}if(p->a==0) free(p);else p3=p;}p3->next=NULL;}printlinklist(pc);}//a-bvoid sublinklist(linklist pa,linklist pb){linklist pc;linklist p1,p2,p3,p;p3=pc=(linklist)malloc(sizeof(node));p1=pa->next;p2=pb->next;if(!(p1||p2)) p3->next=NULL;else{while(p1||p2){p=p3->next=(linklist)malloc(sizeof(node));if(p1==NULL) {p->a=p2->a;p->e=p2->e;p2=p2->next;}else if(p2==NULL) {p->a=p1->a;p->e=p1->e;p1=p1->next;}else{if(p1->e==p2->e) {p->a=p1->a-p2->a;p->e=p1->e;p1=p1->next;p2=p2->next;}else if(p1->e>p2->e) {p->a=p1->a;p->e=p1->e;p1=p1->next;}else if(p1->e<p2->e) {p->a=-p2->a;p->e=p2->e;p2=p2->next;} }if(p->a==0) free(p);else p3=p;}p3->next=NULL;}if(pc->next->next==NULL&&pc->next->a==0) //若a-b=0，输出0 cout<<"0"<<endl;else printlinklist(pc);}//对a求导void dlinklist(linklist pa){linklist pd;linklist p1,p4;p1=pa->next;p4=pd=(linklist)malloc(sizeof(node));while(p1!=NULL){p4->next=(linklist)malloc(sizeof(node));p4=p4->next;if(p1->e==0) {p4->a=0;p4->e=0;}else if(p1->e==1) {p4->a=p1->a;p4->e=0;}else {p4->e=p1->e-1;p4->a=p1->a*p1->e;}p1=p1->next;}p4->next=NULL;printlinklist(pd);}//计算多项式在x处的值void calclinklista(linklist pe,int x){int sum=0,t,i;linklist p5;for(p5=pe->next;p5;p5=p5->next){t=1;for(i=p5->e;i!=0;){if(i<0){t/=x;i++;}//指数小于0，进行除法else{t*=x;i--;}//指数大于0，进行乘法}sum+=p5->a*t;}cout<<sum<<endl;}//菜单void menu(){int m,n,q=1,x;linklist pa=0,pb=0;cout<<"请输入多项式a的项数"<<endl;cin>>m;pa=createlinklist(pa,m);cout<<"请输入多项式b的项数"<<endl;cin>>n;pb=createlinklist(pb,n);cout<<"*********************************************************************\n\n"<<endl ;cout<<" 功能表\n\n "<<endl;cout<<" 1.输出多项式 a 2.输出多项式 b "<<endl;cout<<" 3.输出a+b 4.输出a-b "<<endl;cout<<" 5.输出a的导数 6.计算多项式a在x处的值"<<endl;cout<<" 7.计算多项式b在x处的值0.返回主菜单\n\n"<<endl;cout<<"*********************************************************************\n\n\n\n\n\n\ n";while(q!=0){cout<<"请输入命令"<<endl;cin>>q;switch(q){case 1:printlinklist(pa);break;case 2:printlinklist(pb);break;case 3:addlinklist(pa,pb);break;case 4:sublinklist(pa,pb);break;case 5:dlinklist(pa);break;case 6:cout<<"输入x"<<endl;cin>>x;calclinklista(pa,x);break;case 7:cout<<"输入x"<<endl;cin>>x;calclinklista(pb,x);break;case 0:q=0;break;default:cout<<"输入错误，请重新输入"<<endl;}}}三、调试分析在这个程序写完后的调试过程中，出现了以下问题：1、printlinklist函数刚开是测试会出现首项系数为正，带加号的情况，加了个选择后解决此问题。

一元稀疏多项式简单计算器数据结构

一元稀疏多项式简单计算器数据结构
一元稀疏多项式简单计算器需要输入并建立两个多项式，然后对其进行相加和相减操作，最终输出结果。

为了实现这个功能，可以使用带头结点的单链表来存储多项式，其中每个节点存储一个项的系数和指数。

如果多项式 a 和 b 中有指数相等的两项，则可以直接相加，否则需要对指数更大的项进行插入到该项的前面。

在计算多项式 a 和 b 的和或差时，需要忽略多项式中系数为零的项。

最后，将输出的多项式按照指数的升幂排列，以便于打印输出。

具体实现可以参考博客中提供的参考信息，其中使用了一个Term 类来存储一个项，包括项的系数和指数，以及一个 Polynome 类来存储多项式，包括多项式的头结点和操作。

在 Polynome 类的构造函数和复制构造函数中，初始化多项式的头结点和每一项，同时在复制过程中，将新对象的头结点指向一个相同的链表。

在 Term 类的构造函数中，初始化类成员 ceof 和 exp，以及 next 指针指向下一项。

在 main 函数中，从文件中读取多项式数据，然后对其进行相加和相减操作，并输出结果。

需要注意的是，实现过程中需要考虑多项式的符号问题，即当指数为负数时需要特殊处理。

此外，为了实现仿真界面，可以使用 GUI 库，如 Visual Studio 2017 自带的 MFC 库，来实现计算器的界面设计。

一元稀疏多项式计算器

#include"stdio.h"#include"stdlib.h"#include"conio.h"typedef int elemtype;typedef struct list // 定义结构体链表{float c; // 多项式的常数域elemtype e; // 指数域struct list *next; //指针域}lnode,*linklist; // 结构体名称void create_jisuanqi_linklist(linklist *l) // 初始化结构体{(*l)=(linklist)malloc(sizeof(lnode));(*l)->next= NULL;}void insert_jisuqnai_linklist(linklist l) // 创建结构体{int e,n,i=1;float c;lnode *p=l;printf("How many terms in the polynomial:");scanf("%d",&n); // 输入多项式中的项数while(n){lnode *q=(linklist)malloc(sizeof(linklist));printf("Please input NO.%d's c and e:",i);fflush(stdin); // 清除缓存数据scanf("%f%d",&c,&e); // 分别输入多项式的常数域和指数域q->c=c;q->e=e;p->next=q; // 将结点q 接入链表中q->next=NULL;p=q;n--;i++;}}void chose_jisuanqi_linklist(linklist *l) // 对多项式按指数进行降序排序{lnode *p=(*l)->next;lnode *q=(lnode *)malloc(sizeof(linklist)); // 定义一个结点，用于循环比较指数域的值int tempc,tempe;while(p!=NULL)// 一直循环，直到遍历完链表中所有结点{q=p;while(q!=NULL){if(p->e<q->e) // 交换两节点中的常数和指数域的值{tempe=p->e;tempc=p->c;p->e=q->e;p->c=q->c;q->e=tempe;q->c=tempc;}q=q->next; // 指针下移}p=p->next;}}lnode *add_jisuanqi_linklist(linklist a,linklist b)// 执行多项式A与B相加{linklist c; // 定义一个链表C 用于存放两个多项式的和int x;create_jisuanqi_linklist(&c); // 创建该多项式lnode *p1=a->next;lnode *p2=b->next;lnode *t=c;t->next=NULL;lnode *p3=t;while(p1) // 遍历两个多项式中所有结点，找到指数域相同的结点，将其常数域相加存放到链表C中{p2=b->next;while(p2){if(p1->e==p2->e){lnode *q=(lnode *)malloc(sizeof(lnode));x=p1->c+p2->c;// 将常数域相加q->c=x;q->e=p1->e;p3->next=q;q->next=NULL;p3=q;break;}elsep2=p2->next;}p1=p1->next;}p1=a->next; // 指针复位指向头结点的nextwhile(p1) // 链表a与c比较，将a中指数域的值未在c中出现的结点连接在链表c后{lnode *q=t->next;while(q){if(p1->e!=q->e)q=q->next;else break;}if(q==NULL){lnode *q1=(lnode *)malloc(sizeof(lnode));q1->c=p1->c;q1->e=p1->e;p3->next=q1;q1->next=NULL;p3=q1;}p1=p1->next;}p2=b->next;while(p2) // 链表a与c比较，将a中指数域的值未在c 中出现的结点连接在链表c后{lnode *q=t->next;while(q){if(p2->e!=q->e)q=q->next;else break;}if(q==NULL){lnode *q2=(lnode *)malloc(sizeof(lnode));q2->c=p2->c;q2->e=p2->e;p3->next=q2;q2->next=NULL;p3=q2;}p2=p2->next;}chose_jisuanqi_linklist(&c); // 对链表c进行安指数降序排序return t; // 返回c的头结点}lnode *jian_jisuanqi_linklist(linklist a,linklist b) // 执行多项式A与B相减{linklist c;int x;create_jisuanqi_linklist(&c);lnode *p1=a->next;lnode *p2=b->next;lnode *t=c;t->next=NULL;lnode *p3=t;while(p1){p2=b->next;while(p2){if(p1->e==p2->e){lnode *q=(lnode *)malloc(sizeof(lnode));x=p1->c-p2->c; // 将两个多项式的常数项相减q->c=x;q->e=p1->e;p3->next=q;q->next=NULL;p3=q;break;}elsep2=p2->next;}p1=p1->next;}p1=a->next;while(p1){lnode *q=t->next;while(q){if(p1->e!=q->e)q=q->next;else break;}if(q==NULL){lnode *q1=(lnode *)malloc(sizeof(lnode));q1->c=p1->c;q1->e=p1->e;p3->next=q1;q1->next=NULL;p3=q1;}p1=p1->next;}p2=b->next;while(p2){lnode *q=t->next;while(q){if(p2->e!=q->e)q=q->next;else break;}if(q==NULL){lnode *q2=(lnode *)malloc(sizeof(lnode));q2->c=p2->c;q2->e=p2->e;p3->next=q2;q2->next=NULL;p3=q2;}p2=p2->next;}chose_jisuanqi_linklist(&c);return t;}void display_jisuanqi_linklist(linklist l) // 输出链表{lnode *p=l->next;printf("%3.1f^%d",p->c,p->e);p=p->next;while(p){if(p->c>0) // 如果多项式的常数项大于0，则在输出项前面加一个“+”{printf("+%3.1f^%d",p->c,p->e);p=p->next;}else if(p->c<0) // 如果多项式的常数项小于0，则输出原式{printf("%3.1f^%d",p->c,p->e);p=p->next;}else// 常数项为0，不输出p=p->next;}printf("\n");}#include"stdio.h"#include"stdlib.h"#include"conio.h"#include"jisuanqi_linklist.h"void main() // 主函数{linklist a,b,c,d;int k;start: printf("\n\t\t\t欢迎使用多项式计算器系统\n"); // 进入系统提示do{printf("\t|*********************************************************|\n"); // 选择模块printf("\t| 1.输入多项式A、B,并对其进行指数降序排列|\n");printf("\t| 2.输出多项式A 、B|\n");printf("\t| 3.计算多项式C=A+B|\n");printf("\t| 4.计算多项式D=A-B|\n");printf("\t| 5.输出多项式C、D|\n");printf("\t| 0.退出系统|\n");printf("\t|*********************************************************|\n") ;printf("\t 选择功能选项:");scanf("%d",&k); // 输入要选择的功能选项switch(k) // 对号调用子函数{case 1: system("cls"); // 清屏{create_jisuanqi_linklist(&a);insert_jisuqnai_linklist(a);chose_jisuanqi_linklist(&a);create_jisuanqi_linklist(&b);insert_jisuqnai_linklist(b);chose_jisuanqi_linklist(&b);} system("cls");break;case 2:system("cls");{printf("Polynomial A is:\n");display_jisuanqi_linklist(a);display_jisuanqi_linklist(b);getch();} system("cls");break;case 3:system("cls");{c=add_jisuanqi_linklist(a,b);printf("Calculae polynomialC=A+B is successful!!");getch();} system("cls");break;case 4:system("cls");{d=jian_jisuanqi_linklist(a,b);printf("Calculae polynomial C=A-B is successful!!");getch();}system("cls");break;case 5:system("cls");{printf("Polynomial C is:\n");display_jisuanqi_linklist(c);display_jisuanqi_linklist(d);getch();} system("cls");break;case 0:system("exit");exit(0);default:system("cls");goto start;}}while(1);}。