一元稀疏多项式的计算
一元稀疏多项式计算器实现（完整实现版详细源码）
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 LinkLi st{数据对象：D＝{ ai | ai∈ElemSe t, i=1,2,...,n, n≥0 }数据关系：R1＝{ <ai-1, ai>|ai-1, ai∈D, i=2,...,n }基本操作：InitLi st(&L)操作结果：构造一个空的线性表L。
Destro yList(&L)初始条件：线性表L已存在。
操作结果：销毁线性表L。
一元稀疏多项式的链式存储实现及简单运算
一元稀疏多项式的链式存储实现及简单运算大家好，今天我们来聊聊一元稀疏多项式的链式存储实现及简单运算。
我们要明白什么是一元稀疏多项式。
一元稀疏多项式就是形如f(x) = ax^n + bx^(n-1) + ... + b的多项式，其中a、b、n是常数，x是未知数，x^0=1。
在很多实际问题中，我们会遇到很多这样的多项式，但是它们的系数a和b并不是很多，而且有些系数可能是0,这时候我们就需要用到稀疏矩阵来存储这些多项式。
那么，为什么我们需要用链表来存储稀疏矩阵呢？这是因为链表有很多优点，比如说它可以根据需要动态地分配内存空间，这样就可以节省内存资源。
而且，链表还可以方便地进行插入和删除操作，这对于我们处理稀疏矩阵来说是非常重要的。
下面，我们来看一个例子。
假设我们有一个一元稀疏多项式f(x) = 2x^3 + 3x^2 + x + 4。
为了方便起见，我们先把它表示成一个链表的形式：```Node 1: {value: 2, next: Node 2}Node 2: {value: 3, next: Node 3}Node 3: {value: 1, next: null}Node 4: {value: 4, next: null}```这个链表表示的是一元稀疏多项式的系数。
从这个链表中，我们可以很容易地计算出f(x)的值。
具体方法是：从链表的头节点开始，依次取出每个节点的值，然后将它们相乘并加上下一个节点的值，直到遍历完整个链表为止。
在这个例子中，f(x) = 2 * x^3 + 3 * x^2 + x + 4 = x(2x^2 + 3x + 1) + 4。
除了上述的例子之外，链表还有很多其他的应用场景。
比如说，在计算机科学中，链表可以用来实现栈和队列等数据结构；在数学中，链表可以用来表示无穷级数；在工程领域，链表可以用来表示文件系统等等。
链表是一种非常有用的数据结构，它可以帮助我们更好地处理各种问题。
一元稀疏多项式的链式存储实现及简单运算
一元稀疏多项式的链式存储实现及简单运算### 一元稀疏多项式的链式存储实现及简单运算在咱们的日常生活中，数学可是无处不在的。
就拿我们常用的手机来说吧，它里面装的那些算法，可都是数学的宝贝呢！今天，我就来聊聊那个“数学界的小可爱”——一元稀疏多项式。
得说说什么是一元稀疏多项式。
这玩意儿啊，就像是数学界的魔术师，它能把复杂的问题变得简单又直观。
想象一下，你手里有一堆数字，这些数字有时候多得像星星一样密集，有时候却像沙漠一样空旷。
而一元稀疏多项式就是那个神奇的魔法棒，轻轻一挥，就能让那些密密麻麻的数字变得井然有序，就像画了一幅美丽的画卷。
说到一元稀疏多项式的存储方式，那可真是既聪明又有创意。
它不像传统的多项式那样，把所有数字都记下来，而是像放风筝一样，只记住那些关键的、有用的信息。
这样一来，存储空间就省了不少，计算起来也飞快。
接下来，咱们聊聊如何用一元稀疏多项式来解决实际问题。
比如说，你想计算一个数的平方根，但手头只有有限的几个数。
这时候，一元稀疏多项式就派上用场了。
它不仅能帮你快速找到答案，还能让你轻松应对各种复杂情况。
当然啦，一元稀疏多项式也不是万能的。
在某些情况下，它可能不如传统的多项式来得准确。
但这没关系，只要我们用心去探索、去尝试，总会找到最适合自己的方法。
毕竟，数学的魅力就在于此——它总是能带给我们惊喜和挑战。
总的来说，一元稀疏多项式就像是一个小巧玲珑的数学工具箱，让我们在解决问题时更加得心应手。
虽然它的魔法可能没有那些大英雄们那么震撼，但我相信，在我们的生活里，它一定能找到属于自己的舞台，为我们带来无尽的乐趣和惊喜。
好了，今天的分享就到这里啦！如果你对一元稀疏多项式还有更多的好奇和疑问，记得来找我哦！我们一起探索数学的奥秘，发现生活中的数学之美！。
实验报告——一元稀疏多项式的加法
程序2：一元稀疏多项式加法运算［问题描述］设计一个求解一元稀疏多项式加法运算的程序。
［基本要求］（1）输入并建立多项式。
（2）输出多项式，输出形式为整数序列：n,c1,e1,c2,e2,…,c n,e n,其中n是多项式的项数，c i和e i分别是第i项的系数和指数，序列按指数降序排列。
（3）多项式a和b相加，建立多项式a＋b［算法实现］#include<stdio.h>#include<stdlib.h>typedef struct Node{int cofe;//系数域int expn;//指数域struct Node *next;}LNode,*LinkList;void InitList(LinkList &L)//初始化{L=(LinkList)malloc(sizeof(LNode));if(!L)exit(0);L->next=NULL;}int Input(LinkList &L)//输入{LinkList p;int i=0;p=(LinkList)malloc(sizeof(LNode));L->next=p;printf("输入多项式的系数与指数，按“系数指数”格式，且指数按从小到大顺序输入，以(0 0)结束：\n");while(1){scanf("%d %d",&p->cofe,&p->expn);if((p->cofe)==0)break;p->next=(LinkList)malloc(sizeof(LNode));p=p->next;++i;}p->next=NULL;return i;}void Output(LinkList &L)//输出{LinkList p;p=L->next;printf("多项式为：\n");if((p->expn)==0)printf("%d",p->cofe);else if(p->expn==1)printf("%dx",p->cofe);else if((p->cofe)==1||(p->cofe)==-1){if((p->cofe)==1)printf("x^%d",p->expn);else if((p->cofe)==-1)printf("-x^%d",p->expn);}elseprintf("%dx^%d",p->cofe,p->expn);p=p->next;for(;(p->cofe!=0);p=p->next){if((p->expn==0)&&(p->cofe!=0)){if((p->cofe)>0)printf("+%d",p->cofe);else if((p->cofe)<0)printf("%d",p->cofe);}else if((p->expn==1)&&(p->cofe==1))printf("+x",p->cofe);else if((p->cofe)==1||(p->cofe)==-1){if((p->cofe)==1)printf("+x^%d",p->expn);else if((p->cofe)==-1)printf("-x^%d",p->expn);}else if((p->cofe)>0)printf("+%dx^%d",p->cofe,p->expn);else if((p->cofe)<0)printf("%dx^%d",p->cofe,p->expn);}printf("\n");}void Add(LinkList &L1,LinkList L2)//计算L1，L2的和，放入L1{LinkList p,q,per,r;//p为指向L1的指针，p2为指向L2的指针,per指向p的前驱,r 为中间变量int x;//存放和的结果p=L1->next;q=L2->next;per=L1;while((p!=NULL)&&(q!=NULL))if((p->expn)>(q->expn))//p的指数大于q的指数，将q插到p之前{r=q->next;q->next=p;//先让q的next指向p，并将q的next存入rper->next=q;per=q;q=r;//再让p的前驱的next指向q，此时，q就成为p 的前驱，所以令per=q，q（前驱）的next指向q原来的next}else if((p->expn)==(q->expn)){x=(p->cofe)+(q->cofe);//求和if(x!=0)//和不为0，代替原值，并将p做为先驱（为下次计算做准备）{p->cofe=x;per=p;}else//和为0，释放p结点：将p前驱的next指向p的next，再释放p的空间即可{per->next=p->next;free(p);}p=per->next;r=q;q=q->next;free(r);//将q向后移一位}else if((p->expn)<(q->expn))//p的指数小于q的指数，将q插到p之后{per=p;p=p->next;}if(q!=NULL)//将q中多余的项（即指数在p中没有的）移入p的后面per->next=q;free(L2);//释放：L2}void main(){LinkList L1,L2;int i,j;printf("输入L1：");InitList(L1);i=Input(L1);printf("共%d项\n",i);Output(L1);printf("\n");printf("输入L2：");InitList(L2);j=Input(L2);printf("共%d项\n",j);Output(L2);printf("\n");Add(L1,L2);printf("L1与L2的和");Output(L1);printf("\n");}[实验结果]。
一元稀疏多项式的加法运算(数据结构实习)
实习一线性表、栈和队列及其应用——一元稀疏多项式的加法运算【问题描述】设计一个实现一元稀疏多项式相加运算的演示程序。
【基本要求】（1）输入并建立两个多项式；（2）多项式a与b相加，建立和多项式c；（3）输出多项式a,b,c。
输出格式：比如多项式a为：A(x)=c1xe1+c2xe2+…+ cmxem，其中，ci和ei分别为第i项的系数和指数，且各项按指数的升幂排列，即0≤e1＜e2＜…＜em。
多项式b,c类似输出。
【测试数据】（1）(1+x+x2+x3+x4+x5)+(-x3-x4)=(1+x+x2+x5)（2）(x+x100)+(x100+x200)=(x+2x100+x200)（3）(2x+5x8-3x11)+(7-5x8+11x9)=(7+2x+11x9-3x11)一．需求分析1.输入的形式和输入值的范围：输入是从键盘输入的，输入的内容为多项式的系数和指数，其中多项式的每一项分别以一个系数和指数的形式输入，不带未知数X，系数为任意的实数，指数为任意的整数。
要结束该多项式的输入时，输入的指数和系数都为0.2. 输出的形式从屏幕输出，显示用户输入的多项式，并显示多项式加减以后的多项式的值，并且多项式中将未知数X表示了出来. 形式为：+c1X^e1+c2X^e2+…+ciX^ei+…(ci和ei分别是第i项的系数和指数，序列按指数升序排列。
)当多项式的某一项的系数为+1或者-1时侧该项多项式的输出形式为X^ei或-X^ei；当该项的系数为正时输出+ciX^ei,当为负数时则输出ciX^ei3. 程序所能达到的功能输入并建立多项式，实现一元稀疏多项式的相加并输出。
4. 注意：所有多项式都必须以指数升密形式输入。
5. 测试数据为（1）(1+x+x2+x3+x4+x5)+(-x3-x4)=(1+x+x2+x5)（2）(x+x100)+(x100+x200)=(x+2x100+x200)（3）(2x+5x8-3x11)+(7-5x8+11x9)=(7+2x+11x9-3x11)二．设计1.设计思路（1）.储存结构：链式存储（2）. 主要算法基本思路首先定义一个多项式的结构体，存放多项式每一项的系数和指数以及next指针；然后定义两个指针，第一个指针指向第一个多项式，第二个指针指向第二个多项式。
一元稀疏多项式计算器数据结构
一元稀疏多项式计算器数据结构一元稀疏多项式计算器是一种用于计算多项式的工具，该工具可以用于代数计算、数学分析以及计算机科学中的算法设计。
它可以通过一种特殊的数据结构来存储多项式，并可以对其进行加法、减法、乘法、除法等运算。
这种数据结构被称为稀疏多项式，它是一种基于链表的数据结构。
在稀疏多项式中，每个节点表示一个单项式，节点的数据包含该单项式的系数和指数。
在一个稀疏多项式中，只有少数几个节点表示一个多项式，这就是稀疏性的来源。
稀疏多项式的加法和减法非常简单，只需要对两个多项式的对应节点进行加减即可。
而稀疏多项式的乘法需要更复杂的算法。
乘法的过程中需要将两个多项式的每个单项式乘起来，并将同类项合并成一个新的多项式。
这个过程涉及到大量的链表操作，但只要注意一些细节，将会得到正确的结果。
除了基本的加法、减法、乘法运算，一元稀疏多项式计算器还有一个非常重要的运算，那就是求导。
求导是一种将多项式每个单项式的指数减一，并将系数乘以指数的运算。
它常用于解决微积分、概率论等问题。
求导操作可以通过修改节点的指数和系数来实现。
在计算机科学中，稀疏多项式可以用于设计高效的算法，例如在数论、密码学、图像处理、计算器表达式求值等方面。
稀疏多项式的优点在于它可以有效地节省存储空间和计算时间。
通过动态链表的形式，可以轻松地添加、删除节点，使得稀疏多项式非常适合用于处理大规模的数据。
总的来说，一元稀疏多项式计算器是一种非常实用的工具。
它可以用于解决多项式运算问题，并可以为计算机科学方面的算法设计提供很大的帮助。
通过了解这种数据结构，我们可以更深入地理解代数学、微积分学等数学原理，并且能够更好地应用于实际问题中。
实验一一元稀疏多项式的表示及加法运算
实验一 一元稀疏多项式的表示及加法运算一、 需求分析1.程序的功能: ● 多项式以指数递增的顺序输入。
● 设计的数据结构应有利于表示任意一元稀释多项式。
● 输出原始多项式及运算结果。
● 附加功能：乱序输入计算表达式结果 2. 输入输出要求： ● 多项式以指数递增的方式输入 ● 输出原始多项式及其结果 3.测试数据(1)1785937x x x +++ , 879228x x x -+ (2)0 , 879228x x x -+(3)87109228x x x -+ , -1附加功能测试数据：(4) 53658672x x x x +--,268x x --二、 概要设计●所用数据结构定义：struc t Term{ //多项式结点的定义float coef; //系数 int exp;//指数Term * link; Term(float c,int e,Term * next=NULL){coef=c;exp=e;link=next;} Term *Inser t Afte r (float c,int e); Term & opera t or -=(Term & t){if (t.exp==exp) coef-=t.coef;retur n *this ;} Term & opera t or +=(Term & t){if (t.exp==exp) coef+=t.coef;retur n *this ;} frien d ostre a m & opera t or <<(ostre a m &,const Term&); };class Polyn o mal{//多项式的类定义 publi c : Polyn o mal(){ //构造函数，建立空链表first =new Term(0,-1);first->link=first;//必须链成环}~Polyno mal(){makeEm pty();}Polyno mal(Polyno mal & R); //复制构造函数Polyno mal & operat or=(constPolyno mal & R); //重载复制赋值操作符void insert(floatc,int e,Polyno mal& R);//对于二项式进行插入排序 Polyno mal sort();//对于多项式进行排序Term * getHea d() const{return first;}void makeEm pty();privat e:Term * first;friend ostrea m & operat or<<(ostrea m &,constPolyno mal&);friend istrea m & operat or>>(istrea m &,Polyno mal&);friend Polyno mal operat or+(Polyno mal&,Polyno mal&);};主程序的流程及各模块之间的层次关系：1)主程序流程2)模块之间层次关系三、详细设计1、插入一个结点Term* Term::Insert After(floatc,int e){//在当前由this指针指示的项(即调用此函数的对象)后面插入一个新项link=new Term(c,e,link); //创建一个新结点，自动链接return link; //插入到this结点后面2、重载各运算符（1）Polyno mal & Polyno mal::operat or =(constPolyno mal & R){makeEm pty(); //先清空first=new Term(0,-1);Term *destpt r=first,*srcptr=R.first->link;while(srcptr!=R.first){destpt r->Insert After(srcptr->coef,srcptr->exp);srcptr=srcptr->link;destpt r=destpt r->link;}destpt r->link=first;//必须链成环return *this;}#伪代码清空；动态创建节点f irst；创建节点指针*destpt r指向fi rst，创建节点指针*srcptr指向R.first->link；WHILE（R链未遍历结束）将R链表中的结点一次插入到fir st之后；ENDWHI LE将*destpt r连成环；结束（2）istrea m& operat or>>(istrea m& in,Polyno mal& x){Term *rear=x.first;int e;floatc; //定义尾指针rearwhile(1){cout<<"输入：系数,指数（以、-1结束）:"<<endl;in>>c>>e;if(c==0&&e==-1)break;//用e小于控制输入结束rear=rear->Insert After(c,e); //链接到rear所指结点后}return in;}（3）ostrea m & operat or<<(ostrea m& out,constPolyno mal & x){ //输出到附加头结点的多项式链表xTerm *curren t=x.first->link;cout<<"The polyno mal is:"<<endl;bool h=true;while(curren t!=x.first){if(h==false&¤ t->coef>0.0)out<<"+";h=false;if(curren t->coef==0){out<<"0";curren t=curren t->link;}else{out<<*curren t; //调用term类的重载操作"<<"curren t=curren t->link;}}out<<endl;return out;}#伪代码创建指针*curren t指向当前节点x.first->link；设置标志位hWHILE<遍历多项式>IF<标志位h为假，当前指向节点指数为0>打印符号+；改变标志位；ELSE打印该节点；指向下一个节点；ENDIFENDWHI LE（4）Polyno mal operat or+(Polyno mal& A,Polyno mal& B){Term *pa,*pb,*pc,*p,*last;floattemp;Polyno mal C;pc=C.first;pa=A.first->link;pb=B.first->link;while(pa!=A.first&&pb!=B.first){ //两两比较if(pa->exp==pb->exp){ //对应项指数相等temp=pa->coef+pb->coef; //系数相加if(fabs(temp)!=0)pc=pc->Insert After(temp,pa->exp);pa=pa->link ;pb=pb->link;}else if(pa->exp<pb->exp){pc=pc->Insert After(pa->coef,pa->exp); //pa指数小pa=pa->link;}else{pc=pc->Insert After (pb->coef,pb->exp);pb=pb->link;} //pb指数小，加入ah 链}if(pa!=A.first){p=pa;last=A.first;}else{p=pb;last=B.first;}while(p!=last){pc=pc->Insert After (p->coef,p->exp );p=p->link;}return C;}#伪代码*Pa=二项式a的当前节点;*pb=二项式b的当前节点;新建二项式c；WHILE<遍历二项式>IF<pa,pb的指数相等>IF<指数之和不为0>系数相加后将插入节点到c尾部；ENDIF比较a,b的下一个节点ELSEIF<pa的指数小于pb的>将pa的当前节点复制到c尾部；Pa后移；ELSE将Pb的当前节点复制到c尾部；Pb后移；ENDIFENDWHI LEIF<pa,pb中某一多项式未遍历结束>将未遍历空的那一个所在的二项式剩余部分复制到c尾部；ENDIF返回合成多项式3、排序算法（1）Polyno mal Polyno mal::sort(){Polyno mal R;Term *p=first;p=p->link;while(p!=first){insert(p->coef,p->exp,R);p=p->link;}return R;}（2）void Polyno mal::insert(floatc, int e, Polyno mal &R){Term *q=R.first,*p=R.first->link, *r;if(p==R.first) {q->link=new Term(c,e);//c为空q->link->link=R.first;}else{while(p!=R.first){if(p->exp==e)//指数相等{p->coef+=c;if(p->coef!=0)break;if(p->coef==0){q->link=p->link;r=p;p=p->link;delete r;break;}}else if(p->exp>e)//e小于当前结点的指数{q->link=new Term(c,e);q=q->link;q->link=p;break ;}else { p=p->link; q=q->link;}} if (p==R.first ) //e 大于R 中每一项的指数，插在表尾 { q->link=new Term(c,e); q->link->link=p;}}}四、 调试分析1、调试中的问题（1）在测试数据一时，出现带有常数项的多项式，常数项被构造为一次项，例如多项式1785937x x x +++被输出为1785937x x x x +++解决办法：在重载运算符+中，当pa 的指数小时，将程序由{pc=pc->Inser t Afte r (pa->coef,pb->exp);pb=pb->link;}改为{pc=pc->Inser t Afte r (pb->coef,pb->exp);pb=pb->link;}即可； （2）在调试问题二的过程中，出现的0被程序自动忽略，不能打印使得输出结果为879228x x x -++ 解决办法：在重载输出运算符的程序模块中添加： if(curre n t->coef==0){ out<<"0"; curre n t=curre n t->link; }即可保证程序的输出正常，但是是以作8792280x x x -++为输出的。
一元稀疏多项式加法运算
一元稀疏多项式加法运算一、需求分析1．程序的功能设计一个简单的一元稀疏多项式加法运算器。
一元稀疏多项式简单计算器的基本功能包括：(1)．按照指数升序次序，输入并建立多项式A与B。
(2）．计算多项式A与B的和，即建立多项式A+B。
(3）．按照指数升序次序，输出多项式A、B、A+B。
2．输入输出的要求输入多项式时可以按任意次序输入各项的数据，不必按指数有序；在算法中实现建立按指数有序的多项式。
多项式的输出形式采用图形界面，通过调整指数应该出现的坐标位置来表示指数形式，如X+2X2-3X100的形式。
3．测试数据（1）．(x+3x6－8.6x11)+(6－3x6+21x9)=6+x+21x9－8.6x11（2).(3x－3－x+4.1x2－1.2x9)＋(―3x―3－5.1x2 +7.8x12)=－x－x2－1.2x9+7.8x12（3）．(x+x3)+(―x―x3)=0(4)．(x+x100)+(x100+x200)=(x+2x100+x200)(5)．(x+x2+x3)+0=x+x2+x3二、概要设计1. 输入多项式，建立多项式链表首先创建带头结点的单链表；然后按照指数递增的顺序和一定的输入格式输入各个系数不为0的子项：“系数、指数对”，每输入一个子项就建立一个结点，并将其插入到多项式链表的表尾，如此重复，直至遇到输入结束标志的时候停止，最后生成按指数递增有序的链表。
2. 多项式相加多项式加法规则：对于两个多项式中指数相同的子项，其系数相加，若系数的和非零，则构成“和多项式”中的一项；对于指数不同的项，直接构成“和多项式”中的一项。
3. 多项式的输出可以在文本界面下，采用类似于数学表达式的方式输出多项式，如多项式A可显示为：A=3+6X∧3-2X∧8+12X∧20三、详细设计1. 数据类型定义可描述如下：typedef struct pnode{float coef; /*系数域*/int exp; /*指数域*/struct pnode *next; /*指针域，指向下一个系数不为的子项*/}PolyNode, *PolyLink;PolyLink A,B,C; /*单链表存储的多项式A、B、C*/2.输入多项式，建立多项式链表首先创建带头结点的单链表；然后按照指数递增的顺序和一定的输入格式输入各个系数不为0的子项：“系数、指数对”，必须按照升序输入，每输入一个子项就建立一个结点，并将其插入到多项式链表的表尾，如此重复，直至遇到输入结束标志的时候停止，最后生成按指数递增有序的链表。
一元稀疏多项式运算(数据结构c语言)
{ 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;
数据结构课程方案一元稀疏多项式计算
#include<stdio.h>#include<malloc.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>。
//系数为0的话释放结点else{Polyn q1,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>{//系数为0的话释放结点q1->next=q2->next。
free(q2>。
}}else{//指数为新时将结点插入p->next=q2。
q1->next=p。
}}}Polyn CreatePolyn(Polyn head,int m>{//建立一个头指针为head、项数为m的一元多项式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>。
数据结构课程设计_一元稀疏多项式的计算
#include<stdio.h>#include<malloc.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);//系数为0的话释放结点 else{Polyn q1,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){//系数为0的话释放结点q1->next=q2->next;free(q2);}}else{//指数为新时将结点插入p->next=q2;q1->next=p;}}}Polyn CreatePolyn(Polyn head,int m){//建立一个头指针为head、项数为m的一元多项式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); //调用Insert函数插入结点}return head;}void DestroyPolyn(Polyn p){//销毁多项式pPolyn 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){ //若多项式为空，输出0putchar('0');printf("\n");return;}while(q){if(q->coef>0&&flag!=1) putchar('+'); //系数大于0且不是第一项 if(q->coef!=1&&q->coef!=-1){//系数非1或-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;//a多项式已空，但b多项式非空else return 1;//b多项式已空，但a多项式非空}Polyn AddPolyn(Polyn pa,Polyn pb){//求解并建立多项式a+b，返回其头指针 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);//当相加系数为0时，释放该结点}return headc;}Polyn SubtractPolyn(Polyn pa,Polyn pb){//求解并建立多项式a-b，返回其头指针Polyn h=pb;Polyn p=pb->next;Polyn pd;while(p){ //将pb的系数取反p->coef*=-1;p=p->next;}pd=AddPolyn(pa,h);for(p=h->next;p;p=p->next) //恢复pb的系数p->coef*=-1;return pd;}int ValuePolyn(Polyn head,int x){//输入x值，计算并返回多项式的值Polyn p;int i;int sum=0,t;for(p=head->next;p;p=p->next){t=1;for(i=p->expn;i!=0;){if(i<0){t/=x;i++;}//指数小于0，进行除法else{t*=x;i--;}//指数大于0，进行乘法}sum+=p->coef*t;}return sum;}Polyn Derivative(Polyn head){//求解并建立导函数多项式，并返回其头指针Polyn q=head->next,p1,p2,hd;hd=p1=(Polyn)malloc(sizeof(struct Polynomial));//建立头结点 hd->next=NULL;while(q){if(q->expn!=0){ //该项不是常数项时p2=(Polyn)malloc(sizeof(struct Polynomial));p2->coef=q->coef*q->expn;p2->expn=q->expn-1;p2->next=p1->next;//连接结点p1->next=p2;p1=p2;}q=q->next;}return hd;}Polyn MultiplyPolyn(Polyn pa,Polyn pb){//求解并建立多项式a*b，返回其头指针Polyn hf,pf;Polyn qa=pa->next;Polyn qb=pb->next;hf=(Polyn)malloc(sizeof(struct Polynomial));//建立头结点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);//调用Insert函数以合并指数相同的项}}return hf;}void main(){int m,n,a,x;char flag;Polyn pa=0,pb=0,pc;printf(" 欢迎使用多项式操作程序\n\n");printf("请输入a的项数:");scanf("%d",&m);pa=CreatePolyn(pa,m);//建立多项式aprintf("请输入b的项数:");scanf("%d",&n);pb=CreatePolyn(pb,n);//建立多项式b//输出菜单printf("*******************************************************\n");printf(" * 多项式操作程序*\n");printf(" * *\n");printf(" * A:输出多项式 B:输出多项式 b*\n");printf(" * *\n");printf(" * C:输出a的导数 D:输出b的导数*\n");printf(" * *\n");printf(" * E:代入x的值计算a F:代入x的值计算b*\n");printf(" * *\n");printf(" * G:输出a+b H:输出a-b*\n");printf(" * *\n");printf(" * I:输出a*b J:退出程序*\n");printf(" * *\n");printf("*******************************************************\n");while(a){printf("\n请选择操作：");scanf(" %c",&flag);//空格符号一定要注意switch(flag){case'A':case'a':{printf("\n 多项式a=");PrintPolyn(pa);break;}case'B':case'b':{printf("\n 多项式b=");PrintPolyn(pb);break;}case'C':case'c':{pc=Derivative(pa);printf("\n 多项式a的导函数为：a'=");PrintPolyn(pc);break;}case'D':case'd':{pc=Derivative(pb);printf("\n 多项式b的导函数为：b'=");PrintPolyn(pc);break;}case'E':case'e':{printf("输入x的值：x=");scanf("%d",&x);printf("\n x=%d时，a=%d\n",x,ValuePolyn(pa,x));break;}case'F':case'f':{printf("输入x的值：x=");scanf("%d",&x);printf("\n x=%d时，b=%d\n",x,ValuePolyn(pb,x));break;}case'G':case'g':{pc=AddPolyn(pa,pb);printf("\n a+b=");PrintPolyn(pc);break;}case'H':case'h':{pc=SubtractPolyn(pa,pb);printf("\n a-b=");PrintPolyn(pc);break;}case'I':case'i':{pc=MultiplyPolyn(pa,pb);printf("\n a*b=");PrintPolyn(pc);break;}case'J':case'j':{printf("\n 感谢使用此程序！\n");DestroyPolyn(pa);DestroyPolyn(pb);a=0;break;}default:printf("\n 您的选择错误，请重新选择!\n");}}}。
《C语言程序设计课程设计》题目
1 一元稀疏多项式的运算问题描述：设有两个带头指针的单链表表示两个一元稀疏多项式A、B，实现两个一元稀疏多项式的处理。
实现要求：⑴输入并建立多项式；⑵输出多项式，输出形式为整数序列：n，c1，e1，c2，e2……c n，e n，其中n是多项式的项数，c i，e i分别为第i项的系数和指数。
序列按指数降序排列；⑶多项式A和B相加，建立多项式A+B，输出相加的多项式；⑷多项式A和B相减，建立多项式A-B，输出相减的多项式；⑸多项式A和B相乘，建立多项式A×B，输出相乘的多项式；⑹设计一个菜单，至少具有上述操作要求的基本功能。
测试数据：(1) (2x+5x8-3.1x11)+(7-5x8+11x9)(2) (6x-3-x+4.4x2-1.2x9)-(-6x-3+5.4x2+7.8x15)(3)(x+x2+x3)+0(4)(x+x3)-(-x-x-3)2 成绩排序假设某年级有4个班，每班有45名同学。
本学期有5门课程考试，每门课程成绩是百分制。
假定每个同学的成绩记录包含：学号、姓名各门课程的成绩共7项，其中学号是一个10位的字符串，每个学生都有唯一的学号，并且这4个班的成绩分别放在4个数组中，完成以下操作要求：⑴编写一个成绩生成函数，使用随机数方法，利用随机函数生成学生的各门课程的成绩（每门课程的成绩都是0∽100之间的整数），通过调用该函数生成全部学生的成绩；⑵编写一个平均成绩计算函数，计算每个同学的平均成绩并保存在成绩数组中；⑶用冒泡排序法对4个班的成绩按每个同学的平均成绩的以非递增方式进行班内排序；⑷ 用选择排序法对4个班的成绩按每个同学的平均成绩的以非递增方式进行班内排序；⑸ 对已按平均成绩排好序的4个班的同学的构造一个所有按平均成绩的以非递增方式排列的新的单链表；⑹ 设计一个菜单，至少具有上述操作要求的基本功能。
3 栈及其操作问题描述：栈(Stack)：是限制在表的一端进行插入和删除操作的线性表。
一元稀疏多项式的表示及加法运算
一元稀疏多项式的表示及加法运算一、需求分析1．程序的功能(1)．按照指数升序顺序，输入并建立多项式M与N。
(2）．计算多项式M与N的和(3）．输出多项式M、N、M+N。
2．输入输出的要求多项式按指数递增顺序输入；设计的数据结构应有利于表示任意一元稀释多项式；多项式的输出采用数学多项式的表示形式。
3．测试数据（1）7+3x+9x8+5x17, 8x+22x7-9x8（2) 0, 8x+22x7-9x8（3）8x10+22x7-9x8 , -1二、概要设计1.通过建立链表来实现多项式的输入在多项式输入之前，要先定义一个带有头结点的单链表，紧接着以指数递增的顺序输入多项式中系数不为零的项，其中每一项对应一个结点，每项对应的结点依次插入直至遇到结束标志，这样结完成了多项式的输入。
2. 两个多项式相加两个多项式中如果指数相同则系数相加，构成和多项式的一项；如果指数不同，则直接构成和多项式的一项。
3. 多项式的输出采用数学多项式的表达方式三、详细设计1.定义数据类型：typedef struct pnode{float coef; //系数int exp; //指数struct pnode *next; //指针,指向下一个系数不为的子项}PNode, *PLink;PLink M,N,P; //多项式M、N、P2.通过建立链表来实现多项式的输入在多项式输入之前，要先定义一个带有头结点的单链表，先输入多项式项数，紧接着以指数递增的顺序输入多项式中系数不为零的项，其中每一项对应一个结点，每项对应的结点依次插入，当项数达到时结束，这样完成了多项式的输入。
PNode *createList(PNode *p) //建立多项式链表{float a;int b;int c;int d;p=new PNode;PNode *nNode;PNode *kNode=p;if(p==NULL){return NULL;}else{p->next=NULL;cout<<"请输入多项式项数"<<endl;cin>>d;cout<<"请输入系数和指数"<<endl;for(c=0;c<d;c++){cin>>a>>b;nNode=new PNode;if(nNode==NULL){return p;}nNode->coef=a;nNode->exp=b;kNode->next=nNode;kNode=nNode;}nNode->next=NULL;}return p;}3. 两个多项式相加两个多项式中如果指数相同则系数相加，构成和多项式的一项；如果指数不同，则直接构成和多项式的一项。
一元稀疏多项式的计算
实验元稀疏多项式的计算一、实验目的通过一元稀疏多项式的表示和计算，帮助学生熟练掌握线性表的基本操作，以及用线性链表表示线性表的存储结构和操作的实现。
二、实验内容实现一元稀疏多项式的如下运算：(1)两个一元稀疏多项式相加运算(2)两个一元稀疏多项式相减运算(3)两个一元稀疏多项式相乘运算三、实验原理1、一元多项式的逻辑表示一元多项式P n(X)可表示成：P n(X)=p 0+p i X+p2X2 + …+p n X nn+1个系数可用线性表来表示：p o, p1, p2,…，p n)其中每一项的指数i隐含在其系数口的序号中。
一个一元多项式，如果其系数不为0的项相对于其多项式的次数(最大指数)而言要少得多，则称该一元多项式为一元稀疏多项式。
对一元稀疏多项式，若采用顺序存储结构，需n+1个元素单元存放系数。
当n很大且为零的系数较多时，既浪费存储空间，又浪费运算时间。
如：，、‘ C 10000 c 20000s(x)=1+3x +2X采用顺序存储分配需20001个元素空间，但只有3个元素有意义。
若参与同数量级的加法运算，要运行2000次以上。
因此，对一元多项式采用链式存储结构是必然的选择。
上例的链表表示形式如图1-1所示。
图1-1 : 一元稀疏多项式的链表表示示意图2、一元稀疏多项式的链式存储表示结点结构定义如下：typedef struct ltem{double coef;int exp n;struct Item *n ext;}ltem,*Poly n;3、一元稀疏多项式运算原理设有两个稀疏多项式A 和B ，其运算原理如下：(1 )两个多项式相加(C=A + B)的运算原则：指数相同，系数相加，若不为0，则在结果多项式中构成一新项。
指数不同，则两项分别抄入结果多项式中。
(2 )两个多项式相减(C=A —B)的运算原则：指数相同，系数相减，若不为0，则构成一新项。
指数不同，对A 多项式的项，直接抄入结果多项式中。
一元稀疏多项式以循环单链表按降幂排列
一元稀疏多项式以循环单链表按降幂排列一元稀疏多项式是指只含有一种未知数的多项式，并且其中大部分系数为零。
在计算机科学和数学领域，如何高效地表示和计算一元稀疏多项式一直是一个重要的问题。
循环单链表作为一种数据结构，可以很好地解决这一问题。
本文将从深度和广度两个方面来探讨一元稀疏多项式以循环单链表按降幂排列的表示方法。
一、基本概念和原理1. 一元稀疏多项式的定义一元稀疏多项式是指形如P(x)=a0x^m0 + a1x^m1 + ... + anx^mn的多项式，其中ai为系数，mi为指数。
很显然，如果某些项的系数为0，那么这些项可以被省略，从而得到一元稀疏多项式。
2. 循环单链表的定义循环单链表是一种特殊的单链表，它的最后一个节点指向头节点，从而形成一个循环。
这种数据结构可以很好地表示具有环路特性的问题，如环形队列和循环链表。
二、一元稀疏多项式的表示在计算机中，一元稀疏多项式通常以循环单链表的形式进行表示。
每个节点表示多项式的一项，节点中包含系数和指数两个信息。
按降幂排列的循环单链表可以很好地反映多项式的次序关系，从而方便进行各种运算操作。
举例来说，对于多项式P(x)=3x^5 + 2x^3 - x^2 + 4的表示，可以使用如下的循环单链表结构：1. 指数为5，系数为32. 指数为3，系数为23. 指数为2，系数为-14. 指数为0，系数为4这样，通过循环单链表的方式，可以直观地展现出多项式的结构和内容。
三、如何操作循环单链表表示的一元稀疏多项式1. 多项式的相加当需要对两个一元稀疏多项式进行相加时，可以直接对对应指数的节点进行系数相加。
如果某一项在另一个多项式中不存在，则直接将这一项插入到结果多项式的对应位置。
2. 多项式的相乘多项式的相乘需要将一个多项式的每一项依次与另一个多项式的所有项进行相乘，并将结果按指数相加合并。
这个操作需要对循环单链表进行多次插入和删除操作，而循环单链表的特性能够很好地支持这种需求。
一元稀疏多项式
一元稀疏多项式一元稀疏多项式是指只有一个未知数，并且多项式中的项数相对较少的一种多项式。
本文将对一元稀疏多项式进行详细介绍，并给出一些例子来帮助读者更好地理解。
一元稀疏多项式可以用如下的一般形式表示：P(x) = a_nx^n +a_{n-1}x^{n-1} + ... + a_2x^2 + a_1x + a_0，其中n为多项式的最高次数，a_n, a_{n-1}, ..., a_1, a_0为常数系数。
需要注意的是，a_n不能为0，且多项式中的项数n相对较小。
在一元稀疏多项式中，通常只有少数几个项的系数不为0，其余项的系数均为0。
这就是所谓的稀疏性。
由于稀疏性的存在，一元稀疏多项式的表达和计算都相对简单，可以有效地节省时间和空间。
下面我们通过一些具体的例子来看一元稀疏多项式的应用。
例1：P(x) = 3x^4 + 2x^3 + 5x + 1这是一个一元稀疏多项式，其中只有四个项的系数不为0。
通过观察可以发现，该多项式的最高次数为4，只有这一项的系数不为0，其余项的系数均为0。
因此，这个多项式可以用较简单的形式表示。
例2：Q(x) = 2x^6 + 4x^2 - 3这也是一个一元稀疏多项式，其中有三个项的系数不为0。
与例1类似，通过观察可以发现，该多项式的最高次数为6，只有两个项的系数不为0，其余项的系数均为0。
从例子中我们可以看出，一元稀疏多项式具有较为简洁的表达形式，且易于计算。
在实际应用中，一元稀疏多项式常用于各种数学问题的求解，如多项式插值、信号处理等。
多项式插值是指通过给定数据点，来拟合一个多项式函数，使得该多项式函数与给定数据点的值相近。
在一元稀疏多项式的情况下，我们可以通过给定的数据点，找到一个相应的一元稀疏多项式来近似表示这些数据点。
通过这种方式，我们可以通过已知的数据点来推断未知数据点的值，或者通过已知数据点的值来预测未来的数值。
在信号处理领域，一元稀疏多项式也有着广泛的应用。
一元多项式的加减求导运算算法(数据结构算法)
if(expo1==0)
{
i=1;
cout<<coef1;
}
else if(expo1==1)
{
i=1;
if(coef1==1)
cout<<"X";
else if(coef1==-1)
cout<<"-X";
else
cout<<coef1<<"X";
}
else
{
i=1;
if(coef1==1) cout<<"XA"<<expo1;
temp=h;
h->next =NULL;〃头结点
cout<<"多项式"<<o<<"的项数:";cin»num;
for(i nt i=1;i<=nu m;i++)
{
cout<<"请输入第"<<i<<"项"<<endl; cout<<"系数:";
cin> >coef1;
cout<<"指数:";
cin> >expo1; data=new polyno de; data->coef=coef1;
(2)计算多项式A与B的和，即建立多项式A+B
(3)按照指数升序次序，输出多项式AB、A+B
(4)计算多项式A与B的差，即建立多项式A-B;
(5)计算多项式A的导函数A，。
一元稀疏多项式的链式存储实现及简单运算
一元稀疏多项式的链式存储实现及简单运算### 一元稀疏多项式的链式存储实现及简单运算大家好！今天咱们来聊聊那些数学里的小秘密——一元稀疏多项式。
想象一下，你手里有一张扑克牌，上面写着各种数字，这些数字就是系数，它们告诉我们每张牌的权重。
现在，你想知道如何用最少的卡片来表示这张扑克牌，这就是一元稀疏多项式要解决的问题。
让我们来搞清楚什么是一元稀疏多项式。
简单来说，它就是一个多项式，但这个多项式里只有几个“关键”系数是“非零”的，其他的都是“零”。
这就像是在说：“嘿，我只需要记住这几个重要的数，其他的都不用管。
”那么，怎么存储这样的多项式呢？别担心，我们可以用一种叫做“链式存储”的方法。
想象一下，你的手机内存有限，但你有好多照片和视频需要保存。
你不可能把每一个照片都单独存一个文件，对吧？你需要把它们连在一起，形成一个长串。
同样地，对于一元稀疏多项式，我们也可以把它看作是一串数字，每个数字后面跟着一个“0”，这样就形成了一个“链”。
接下来，让我们来谈谈如何计算一元稀疏多项式的值。
假设我们有一个系数序列，比如1, 2, 1, 0, 0, 3, 0, 0, 4, ...。
如果我们把这些系数连成一条线，你会发现，这条线上的数字并不是均匀分布的。
有些地方数字多，有些地方数字少。
这就是所谓的“稀疏性”。
为了计算这个多项式的值，我们可以采用一种叫做“拉格朗日插值法”的方法。
想象一下，你有一张地图，上面标着各个城市的位置。
现在你要去一个未知的城市，你可以根据已知的几个城市的位置，用拉格朗日插值法来计算这个未知城市的位置。
这个方法就像是一种“魔法”，能够帮你找到那些“关键”系数之间的“空隙”，从而计算出整个多项式的结果。
让我们来谈谈一元稀疏多项式的应用。
想象一下，你是一个游戏开发者，你需要在游戏中展示一个动态变化的地形。
你知道，如果地形变化得太频繁，玩家可能会感到困惑。
所以，你决定使用一元稀疏多项式来表示地形的变化。
一元稀疏多项式的加法运算[整理版]
![一元稀疏多项式的加法运算[整理版]](https://img.taocdn.com/s3/m/21ea7811e97101f69e3143323968011ca300f797.png)
一元稀疏多项式的加法运算一、需求分析1、要求用带头结点的单链表存储两个多项式，然后进行多项式加法运算，存入另一个单链表中。
2、从键盘输入多项式a的项数，然后分别输入每项的系数和指数；类此输入多项式b。
3、测试数据：（1）、(1+x+x2+x3+x4+x5)+(-x3-x4)=(1+x+x2+x5)（2）、(x+x100)+(x100+x200)=(x+2x100+x200)（3）、(2x+5x8-3x11)+(7-5x8+11x9)=(7+2x+11x9-3x11)二、设计1、设计思想（1）、存储结构：带头结点的单链表（2）、主要算法基本思想先输入多项式的项数j，建立一个循环，分别进行链表的插入操作，插入时就是建立空结点存入系数和指数后再插入链表中。
在插入的同时要比较与原链表中指数项的大小，从而建立由低次方到高次方的存储链表。
在多项式相加时，将多项式a先存入多项式c中，此时c中的指数是升序排列，再将b中系数与指数存入，存入的方法是：指数比较寻找插入结点，指数相等时，进行系数相加操作，其他是建立一个空结点，存入b的系数与指数载插入c中。
至于输入过程，多项式a、b、c均可输出，由于存储的按指数升序存的，所以不必进行查找了，只需要按一个个结点顺序输出即可。
#include<stdio.h>#include<malloc.h>#include<stdlib.h>typedef struct{float coef;int expn;}count;typedef struct Node{float coef;//系数int expn;//指数struct Node *next;}LinkList;void ListInitiate(LinkList **head)//链表初始化{if((*head=(LinkList *)malloc(sizeof(LinkList)))==NULL)exit(0);(*head)->next=NULL;}void ListInsert(LinkList *head,count L)//链表插入操作{LinkList *p,*q;p=head;while(p->next!=NULL)//从系数由小到大排序的角度寻找插入结点{if(p->next->expn>L.expn)break;p=p->next;}if((q=(LinkList *)malloc(sizeof(LinkList)))==NULL)exit(0);q->coef=L.coef;q->expn=L.expn;q->next=p->next;p->next=q;}int print(LinkList *head)//输出{LinkList *p;p=head->next;if(p==NULL)//多项式为零时直接输出{printf("0\n");exit(0);}while(p->coef==1&&p->expn>0)//指数不为零时系数为1时的输出{printf("x^%d",p->expn);p=p->next;if(p==NULL)return 0;else printf("+");}while(p->next){printf("%gx^%d",p->coef,p->expn);p=p->next;if(p->coef>0)printf("+");}printf("%gx^%d",p->coef,p->expn);return 1;}void Add(LinkList *a,LinkList *b,LinkList *c)//多项式a、b相加等于多项式c {LinkList *p,*q,*s,*k;s=c;p=a->next;while(p!=NULL)//先将a存入c中{if((q=(LinkList *)malloc(sizeof(LinkList)))==NULL)exit(0);q->coef=p->coef;q->expn=p->expn;q->next=NULL;c->next=q;c=c->next;p=p->next;}c=s;p=b->next;while(p!=NULL)//将b存入c中{while((c->next!=NULL)&&(p->expn)>((c->next)->expn))//寻找插入结点{c=c->next;}if(c->next==NULL)//从最后插入{if((q=(LinkList *)malloc(sizeof(LinkList)))==NULL)exit(0);q->coef=p->coef;q->expn=p->expn;q->next=c->next;c->next=q;}else if(p->expn==c->next->expn) //指数相等时系数相加{s=c;c=c->next;c->coef=c->coef+p->coef;if(c->coef==0){k=c;c=s;c->next=c->next->next;free(k);}}else if(p->expn>c->expn&&c->next!=NULL)//普通插入{if((q=(LinkList *)malloc(sizeof(LinkList)))==NULL)exit(0);q->coef=p->coef;q->expn=p->expn;q->next=c->next;c->next=q;}p=p->next;}}void main()//主函数{LinkList *a,*b,*c;count L;int i,j;ListInitiate(&a);ListInitiate(&b);ListInitiate(&c);printf("请输入a的项数：");scanf("%d",&j);for(i=0;i<j;i++){printf("输入a的第%d项系数:",i+1);scanf("%g",&L.coef);printf("输入a的第%d项指数:",i+1);scanf("%d",&L.expn);ListInsert(a,L);}printf("输入b的项数:");scanf("%d",&j);for(i=0;i<j;i++){printf("输入b的第%d项系数:",i+1);scanf("%g",&L.coef);printf("输入b的第%d项指数:",i+1);scanf("%d",&L.expn);ListInsert(b,L);}Add(a,b,c);printf("输入的多项式a为:\n");print(a);printf("\n");printf("输入的多项式b为:\n");print(b);printf("\n");printf("多项式a+b=c为:\n");print(c);printf("\n");}。
一元稀疏多项式简单计算器数据结构
一元稀疏多项式简单计算器数据结构
一元稀疏多项式简单计算器需要输入并建立两个多项式，然后对其进行相加和相减操作，最终输出结果。
为了实现这个功能，可以使用带头结点的单链表来存储多项式，其中每个节点存储一个项的系数和指数。
如果多项式 a 和 b 中有指数相等的两项，则可以直接相加，否则需要对指数更大的项进行插入到该项的前面。
在计算多项式 a 和 b 的和或差时，需要忽略多项式中系数为零的项。
最后，将输出的多项式按照指数的升幂排列，以便于打印输出。
具体实现可以参考博客中提供的参考信息，其中使用了一个Term 类来存储一个项，包括项的系数和指数，以及一个 Polynome 类来存储多项式，包括多项式的头结点和操作。
在 Polynome 类的构造函数和复制构造函数中，初始化多项式的头结点和每一项，同时在复制过程中，将新对象的头结点指向一个相同的链表。
在 Term 类的构造函数中，初始化类成员 ceof 和 exp，以及 next 指针指向下一项。
在 main 函数中，从文件中读取多项式数据，然后对其进行相加和相减操作，并输出结果。
需要注意的是，实现过程中需要考虑多项式的符号问题，即当指数为负数时需要特殊处理。
此外，为了实现仿真界面，可以使用 GUI 库，如 Visual Studio 2017 自带的 MFC 库，来实现计算器的界面设计。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验一一元稀疏多项式的计算一、实验目的通过一元稀疏多项式的表示和计算，帮助学生熟练掌握线性表的基本操作，以及用线性链表表示线性表的存储结构和操作的实现。
二、实验内容实现一元稀疏多项式的如下运算：(1)两个一元稀疏多项式相加运算(2)两个一元稀疏多项式相减运算(3)两个一元稀疏多项式相乘运算三、实验原理1、一元多项式的逻辑表示一元多项式p n(x)可表示成:p n(x)=p0+p1x+p2x2+…+p n x nn+1个系数可用线性表来表示：p0，p1，p2，…，p n）其中每一项的指数i隐含在其系数p i的序号中。
一个一元多项式，如果其系数不为0的项相对于其多项式的次数（最大指数）而言要少得多，则称该一元多项式为一元稀疏多项式。
对一元稀疏多项式，若采用顺序存储结构，需n+1个元素单元存放系数。
当n很大且为零的系数较多时，既浪费存储空间，又浪费运算时间。
如：s(x)=1+3x10000+2x20000采用顺序存储分配需20001个元素空间，但只有3个元素有意义。
若参与同数量级的加法运算，要运行2000次以上。
因此，对一元多项式采用链式存储结构是必然的选择。
上例的链表表示形式如图1-1所示。
图1-1：一元稀疏多项式的链表表示示意图2、一元稀疏多项式的链式存储表示结点结构定义如下：typedef struct Item{double coef;int expn;struct Item *next;}Item,*Polyn;3、一元稀疏多项式运算原理设有两个稀疏多项式A和B，其运算原理如下：（1）两个多项式相加(C=A＋B)的运算原则：指数相同，系数相加，若不为0，则在结果多项式中构成一新项。
指数不同，则两项分别抄入结果多项式中。
（2）两个多项式相减(C=A－B)的运算原则：指数相同，系数相减，若不为0，则构成一新项。
指数不同，对A多项式的项，直接抄入结果多项式中。
对B多项式的项，系数符号变换后，再将放入结果多项式中（3）两个多项式相乘(C=A×B)的运算原则用B多项式的每一项分别去乘A多项式的每一项，并将乘得得结果放入结果多项式中。
若结果多项式中有指数相同的项，则应把它们合并为一项。
四、实现1、约定使用带头结点的链表表示一元稀疏多项式。
（2）用线性链表表示的一元稀疏多项式中，各结点按指数的升序排列。
（3）每个多项式都独立存在，即参与运算的两个多项式的数据不能因运算而受到破坏，加、减、乘运算的结果应相互不受影响。
因此，对于每种情况都必须单独建立一个链表进行表示。
（4）每一种重复性的操作都要进行确认，以免破坏原有操作的结果。
如需要输入A多项式，而A多项式已经存在，这时通过“确认”后再确定是否真正需要输入。
2、基本功能(1)多项式的输入(2)两个一元稀疏多项式相加运算：P(x)+Q(x(3)两个一元稀疏多项式相减运算：P(x)－Q(x)(4)两个一元稀疏多项式相乘运算：P(x)×Q(x)(5)多项式打印3、辅助功能(1)菜单选择：将上述功能通过“菜单”形式罗列出来，通过菜单选择进行交互式控制程序运行。
(2)插入结点位置查找：确定将一个新结点插入到多项式链表结构中的位置，以保证链表中结点按指数升序排列。
(3)交互选择：当出现重复性操作时，提供交互式选择方式，以确定其重复操作是否进行。
(4)撤消多项式：释放表示多项式链表中所有结点的存储空间。
(5)多项式项插入：将表示多项式中一项的结点插入到链表中给定的位置。
(6)判多项式非空：判断某个多项式是否存在。
(7)判断两个多项式的当前运算项的关系（指数大于，等于，小于）4、程序结构本程序可以由13个函数组成，其中主函数1个，基本功能函数5个，辅助功能函数7个。
函数间的调用关系图1-2所示。
图1-2：程序结构示意图5、程序函数（1）主函数：main功能：通过菜单选择控制对系统功能的操作（2）菜单选择函数：menu函数格式：int menu(void)函数功能：构造功能菜单，并选择下一步要操作的功能。
函数参数：无参数。
函数返回值：1～11中的一个序号。
可供选择的功能如下：1--create P(x) 表示生成P多项式2--create Q(x) 表示生成Q多项式3--p(x)+Q(x) 表示两多项式相加4--P(x)-Q(x) 表示两多项式相减5--p(x)*Q(x) 表示两多项式相乘6--print P(x) 表示打印P多项式7--print Q(x) 表示打印Q多项式8--print P(x)+Q(x) 表示打印两多项式相加的结果9--print P(x)-Q(x) 表示打印两多项式相减的结果10--print P(x)*Q(x) 表示打印两多项式相乘的结果11—Quit 表示退出系统，结束程序的运行在运行过程中，输入其中一个序号，即表示下一步执行后面的功能。
如输入3，表示执行P(x)+(x)额运算。
(3)输入多项式函数：input函数格式：Polyn Input(void)函数参数：无参数函数功能：输入多项式各项的系数和指数，生成一个多项式链表。
函数返回值：指向一个多项式链表的头指针(4)两多项式相加函数：AddPolyn函数格式Polyn AddPolyn(Polyn h1,Polyn h2)函数功能：实现两个多项式h1和h2相加。
函数参数：Polyn h1—指向第一个多项式链表的头指针Polyn h2—指向第二个多项式链表的头指针函数返回值：指向相加后的结果链表的头指针(5)两多项式相减函数：SubtractPolyn函数格式Polyn SubtractPolyn(Polyn h1,Polyn h2)函数功能：实现两个多项式h1和h2相减。
函数参数：Polyn h1—指向第一个多项式链表的头指针Polyn h2—指向第二个多项式链表的头指针函数返回值：指向相减后的结果链表的头指针(6)两多项式相乘函数：MultPolyn函数格式Polyn MultPolyn(Polyn h1,Polyn h2)函数功能：实现两个多项式h1和h2相乘。
函数参数：Polyn h1—指向第一个多项式链表的头指针Polyn h2—指向第二个多项式链表的头指针函数返回值：指向相乘后的结果链表的头指针(7)显示多项式函数：Output函数格式：void Output(Polyn h,char *title)函数功能：输出多项式的完整表示。
如：P(x)=+^^9函数参数：Polyn h－要输出的多项式链表的头指针char *title－字符串，提示要输出一个什么样的多项式，如“P(x)”。
函数返回值：无返回值。
(8)判断选择函数：Select函数格式：int Select(char *str)函数功能：根据str提示的内容判断是执行指定的操作，还是不执行。
输入“Y”则表示执行，若输入“N”表示不执行。
如当P(x)多项式已经产生后，若再选择产生P(x)，这是提示：P(x) is not Empty,Create P(x) again?Input Y or N:若输入“Y”则表示重新产生多项式P(x)，若输入“N”表示维持原多项式不变。
函数参数：char *str－将要确定的内容。
函数返回值：1－表示执行指定的操作0－表示不执行指定的操作(9)插入位置定位函数：InsertLocate函数格式：int InsertLocate(Polyn h,int expn,Item **p)函数功能：确定新结点的插入位置。
其插入位置的确定是保证多项式链表按指数递增排列的关键。
函数参数：Polyn h－要查找的多项式链表的头指针int expn－新插入项的指数值。
Item **p－插入位置的前驱结点指针，由该函数的调用而被确定的内容。
新结点一定插入到该结点的后面。
函数返回值：-1－若指数expn值在某两个结点之间，则返回－1，参数p带回的值为指数值小于expn的结点指针。
0－若指数expn值等于某结点的指数值，则返回0，参数p带回的值为指数值等于expn的结点指针。
1－若指数expn值大于最后一个结点的指数值，则返回1，参数p带回最后一个结点的指针（10）结点插入函数：insert函数格式：void insert(Item *pre,Item *p)函数功能：在指定结点pre后插入一个新结点p。
函数参数：Item *pre－被插入结点的前驱结点Item *p－要插入的新结点函数返回值：无（11）撤消链表函数：Destroy函数格式：void Destroy(Polyn h)函数功能：释放链表所占用的存储空间函数参数：Polyn h－被撤消的链表的头指针函数返回值：无（12）判链表非空函数：PolynNotEmpty函数格式：int PolynNotEmpty(Polyn h,char *p)函数功能：判断链表是否非空，即代表了一个真正的多项式。
函数参数：Polyn h－多项式链表的头指针char *p－多项式名函数返回值：0—链表为空1—链表不为空(13)比较多项式两项关系函数：ItemComp函数格式：int ItemComp(Item x Item y)函数功能：根据两个多项式项的指数判断它们的关系。
函数参数：Item x－表示多项式项的变量Item y－表示多项式项的变量函数返回值：-1—x项的指数小于y项的指数0—x项的指数等于y项的指数1—x项的指数大于y项的指数五、部分算法描述两个多项式相加运算的算法参见教科书的描述。
两个多项式相减运算算法与多项式相加运算的算法结构一致，只是把Q(x)多项式的结点作为独立的一项时，其系数应改变其正/负号。
这里只对两个多项式相乘运算的算法加以描述。
两个多项式相乘运算的基本原理是：用Q(x)多项式的每一项分别去乘P(x)多项式的每一项，并将乘得得结果放入结果多项式中。
若结果多项式中有指数相同的项，则应把它们合并为一项。
这实际上是运用加法运算来实现乘法运算，实现时有两种不同的方法把每次计算的结果与原来的中间结果进行相加。
【算法1】基本思想：把Q(x)多项式的每一项分别去乘P(x)多项式的每一项所得到的每一个结果（一个结点）插入到结果多项式中，若结果多项式中无相同指数的项，则生成一个新结点插入；若有相同指数的项，则系数相加。
算法如图1-3所示。
图1-3 两个多项式相乘算法1描述【算法2】基本思想：把Q(x)多项式的每一项分别去乘P(x)多项式得到一个新的多项式，然后把新多项式与结果多项式相加。
算法如图3所示。
图1-4 两个多项式相乘算法2描述七、思考题修改一元多项式相加运算的函数，实现：1、两个有序表合并为一个有序表。
2、假设具有整数值的集合用有序的线性链表表示，实现求两个集合的联合运算，要求结果集合中不能有两个值相同的元素。