测试一一元稀疏多项式的计算
一元稀疏多项式的链式存储实现及简单运算
一元稀疏多项式的链式存储实现及简单运算大家好，今天我们来聊聊一元稀疏多项式的链式存储实现及简单运算。
我们要明白什么是一元稀疏多项式。
一元稀疏多项式就是形如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。
除了上述的例子之外，链表还有很多其他的应用场景。
比如说，在计算机科学中，链表可以用来实现栈和队列等数据结构；在数学中，链表可以用来表示无穷级数；在工程领域，链表可以用来表示文件系统等等。
链表是一种非常有用的数据结构，它可以帮助我们更好地处理各种问题。
稀疏多项式的加法
稀疏多项式的加法1．问题描述设计一个一元稀疏多项式简单计算器。
一元稀疏多项式简单计算器的基本功能是：（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。
2.设计2.1存储结构:(1)用带头结点的单链表来存储多项式。
(2)连表中只存储非零系数项，若两多项式中指数相等的项相加或相减，所得到的系数为零，则该项不存储。
2.2 主要算法设计（1）多项式结点类的定义：struct Term {int coef; //系数int exp; //指数Term *link;Term(int c,int e, Term *next = NULL){coef = c; exp = e; link = next;}Term *InsertAfter(int c,int e);friend ostream& operator << (ostream &,Term &);};多项式结点类的定义是为了方便多项式类Polynomial的项的存储与赋值。
（2）多项式类的定义：Class Polynomial {public:Polynomial() {first = new Term(0,-1);}Term *getHead()const {return first;}int Size();private:Term *first;friend ostream& operator << (ostream &, Polynomial &);friend istream& operator >> (istream &, Polynomial &);friend Polynomial operator + (Polynomial &, Polynomial &);friend Polynomial operator - (Polynomial &, Polynomial &);};函数实现在最后所给源代码中给出。
实验一一元稀疏多项式的表示及加法运算
实验一 一元稀疏多项式的表示及加法运算一、 需求分析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 -++为输出的。
一元稀疏多项式的分解实验报告
题目：一元稀疏多项式分解实验报告班级：10计算机2班姓名：徐燕学号：10070519 完成日期：2011年11月25日一、需求分析编写算法，将一元稀疏多项式分解成两个多项式，使这两个多项式中各自仅含奇次项或偶次项，并要求利用原多项式的结点空间构成这两个链表。
二、概要设计1.抽象数据类型一元多项式的定义如下：ADT Polynomial{数据对象：D＝{ ai | ai ∈TermSet, i=1,2,...,m, m≥0TermSet中的每个元素包含一个表示系数的实数和表示指数的整数}数据关系：R1＝{ <ai-1 ,ai >|ai-1 ,ai∈D, 且ai-1中的指数值<ai中的指数值i=2,...,n }基本操作：CreatPolyn( &P,m )操作结果：输入项的系数和指数，建立一元多项式P。
DestroyPloyn( &P )初始条件：一元多项式P已存在。
操作结果：销毁一元多项式P。
PrintPloyn( P )初始条件：一元多项式P已存在操作结果：打印输出一元多项式P。
AddPolyn(&Pa,&Pb)初始条件：一元多项式Pa,Pb已存在。
操作结果：完成多项式的相加运算，即Pa+Pb,并销毁一元多项式Pb。
SubtractPolyn( &Pa,&Pb )初始条件：一元多项式Pa,Pb已存在操作结果：完成多项式的相减运算，即Pa-Pb,并销毁一元多项式Pb。
} ADT List2.本程序主要包含个模块：1）主程序模块：main函数2）int departpolyn(polynomial &head_p,polynomial &Odd_items,polynomial &Even_items)奇数项，偶数项3）void printpolyn(polynomial head)处理的系数均为正数。
三、详细设计#include <stdio.h>#include <stdlib.h>typedef struct term{double coef;//系数int expn; //指数struct term *next;}term,*polynomial;//head_p是头指针，而非头结点。
一元稀疏多项式实验报告(罗忠霖)
集美大学计算机工程学院实验报告课程名称: 数据结构与算法班级：计算1013 实验成绩：指导老师：杨艳华姓名：罗忠霖实验名称：一元稀疏多项式计算器学号：2010810072 上机时间2011年10月20号编号：03 组号;12 上机完成时间:2学时一.目的（本次试验所涉及并要求掌握的知识点）本次实习的主要目的在于帮助学生熟练掌握线性表的基本操作在两种存储结构上的实现，其中以各种链表的操作和应用为重点。
二.实验内容与设计思想1．问题描述设计一个一元稀疏多项式简单计算器2．基本要求一元稀疏多项式简单计算器的基本功能：（1）输入并建立多项式；（2）输出多项式，输出的形式为整数序列：n,c1,e1,c2,,en,期中n为多项式的项数，ci和ei分别为第i 项的系数和指数，系列按指数的降序排列；(3)多项式a和多项式b相加，建立多项式a+b;(4)多项式a和b相减，建立多项式a-b;3．程序代码#include<stdio.h>#include<stdlib.h>#include<malloc.h>typedef struct list{float xishu;//某项的系数int zhishu;//某项的指数struct list * next;}*linklist;void caidan(void);void xianshi(linklist);linklist dx_built(int);linklist dx_jia(linklist,linklist);linklist dx_jian(linklist,linklist);linklist sort(linklist head);main(){int i,a,b;linklist pa,pb,pc1,pc2;caidan();do{printf("\n");printf("请选择你想要的功能0--4\n");scanf("%d",&i);switch(i){case 1: printf("请输入多项式A的项数：\n");scanf("%d",&a);pa=dx_built(a);pa=sort(pa);printf("请输入多项式B的项数：\n");scanf("%d",&b);pb=dx_built(b);pb=sort(pb);break;case 2: printf("多项式A与B的和为：");pc1=dx_jia(pa,pb);xianshi(pc1);break;case 3: printf("多项式A与B的差为：");pc2=dx_jian(pa,pb);xianshi(pc2);break;case 4: printf("多项式A=");xianshi(pa);printf("多项式B=");xianshi(pb);break;case 0: break;}} while(i!=0);printf("你选择了退出操作，欢迎使用!\n");system("pause");// 系统暂停，按任意键键继续flushall();system("cls");}void caidan(void){// 定义菜单函数printf("*************************************************\n");printf("\t一元稀疏多项式计算器\t\n");printf("*************************************************\n");printf("0.退出程序\n");printf("1.建立多项式\n");printf("2.多项式加法\n");printf("3.多项式减法\n");printf("4.多项式输出\n");printf("*************************************************\n"); }// caidanlinklist dx_built(int m){//创建多项式int i;linklist head,p;head=(struct list *)malloc(sizeof(struct list));head->next=NULL;for(i=1;i<=m;i++){p=(struct list *)malloc(sizeof(struct list));printf("(dx,%d)=",i);scanf("%f%d",&p->xishu,&p->zhishu);if(p->xishu==0) //系数为0的时候，删掉该节点free(p);else//系数不为0的时候{p->next =head->next ;head->next =p;}}return head;}linklist sort(linklist head){//指数按降序排列linklist p,q,tail,s;tail=NULL;while(head->next!=tail){p=head;q=p->next;while(q->next!=tail){if(p->next->zhishu<q->next->zhishu){s=q->next;p->next=q->next;q->next=q->next->next;p->next->next=q;q=s;}p=p->next;q=q->next;}tail=q;}return head;}void xianshi(linklist head){linklist q=head->next;int flag=0;//项数计数器if(!q){ //若多项式为空，输出0printf("0\n");return;}while(q){if(q->xishu>0&&flag!=0) putchar('+'); //系数大于0且不是第一项if(q->xishu!=1&&q->xishu!=-1){//系数非1或-1的普通情况printf("%.f",q->xishu);if(q->zhishu==1) putchar('X');else if(q->zhishu) printf("X^%d",q->zhishu);}else{if(q->xishu==1){if(!q->zhishu) putchar('1');else if(q->zhishu==1) putchar('X');else printf("X^%d",q->zhishu);}if(q->xishu==-1){if(!q->zhishu) printf("-1");else if(q->zhishu==1) printf("-X");else printf("-X^%d",q->zhishu);}}q=q->next;flag++;}printf("\n");}linklist dx_jia(linklist pa,linklist pb){/*多项式相加*/linklist p=pa->next ,q=pb->next ,pc,tail,s;//pc用来存储两个多项式的和pc=tail=(struct list *)malloc(sizeof(struct list));while(p!=NULL&&q!=NULL){s=(struct list *)malloc(sizeof(struct list));if(p->zhishu >q->zhishu )//p指数大，则存入pc,p然后后移{s->xishu=p->xishu;s->zhishu=p->zhishu;tail->next =s;tail=s;p=p->next;}else{ if(p->zhishu <q->zhishu)//q指数大，则存入pc,q然后后移{s->xishu=q->xishu;s->zhishu=q->zhishu;tail->next =s;tail=s;q=q->next;}else //指数相等时{ if(p->xishu +q->xishu==0 )//系数和为0则不存入pc中,p.q都后移{p=p->next ;q=q->next ;}else //系数和不为0，则存入pc中,q,p后移{s->xishu=p->xishu+q->xishu ;s->zhishu=p->zhishu;tail->next=s;tail=s;p=p->next;q=q->next;}}}}if(p==NULL)//p多项式比q短的时候，把q剩余的部分接到pctail->next=q;else//q多项式比p短的时候，把p剩余的部分接到pctail->next=p;return pc;}linklist dx_jian(linklist pa,linklist pb){/*多项式相减*/linklist p=pa->next ,q=pb->next ,pc,tail,s;//pc用来存储两个多项式的差pc=tail=(struct list *)malloc(sizeof(struct list));while(p!=NULL&&q!=NULL){s=(struct list *)malloc(sizeof(struct list));if(p->zhishu >q->zhishu )//p指数大，则存入pc,p然后后移{s->xishu=p->xishu;s->zhishu=p->zhishu;tail->next =s;tail=s;p=p->next;}else{ if(p->zhishu <q->zhishu)//q指数大，则把q是系数前加-1再存入pc,q然后后移{s->xishu=-(q->xishu);s->zhishu=q->zhishu;tail->next =s;tail=s;q=q->next;}else //指数相等时{ if(p->xishu -q->xishu==0 )//系数差为0则不存入pc中,p.q都后移{p=p->next ;q=q->next ;}else //系数差不为0，则存入pc中,q,p后移{s->xishu=p->xishu-q->xishu ;s->zhishu=p->zhishu;tail->next=s;tail=s;p=p->next;q=q->next;}}}}if(p ==NULL)//p多项式比q短的时候，把q剩余的部分接到pctail->next=q;else//q多项式比p短的时候，把p剩余的部分接到pctail->next=p;return pc;}三.实验使用环境（本实验所使用的平台和相关的软件）Microsoft Visual C++ 6.0四.实验步骤和调试过程（实验步骤测试数据设计测试结果分析）测试结果:五.实验小结（实验过程中遇到的问题及解决过程.实验体会和收获）1.在编写一元稀疏多项式程序代码的时候，为了实现这个程序，我采取了模块化设计，针对每个功能，我使用一个函数去实现它；2.在建立多项式的时候，我使用了单向链表去实现，在建立的时候，我把系数为0时候，这个节点给删掉，if(p->xishu==0) //系数为0的时候，删掉该节点free(p);然而我我这个函数还有个不足的地方，就是当指数相同，系数不同的时候，我没考虑到把它合并，这我以后会改进；2.在主函数里，我采用了调用函数的方式，使界面简洁，但是我刚开始的时候没有准确地调用函数，程序运行失败，并且我把排序函数插入到现实函数里，导致了一个未知的错误，程序失败了，后来我把排序函数加到了建立的地方，printf("请输入多项式A的项数：\n");scanf("%d",&a);pa=dx_built(a);pa=sort(pa);3，这个程序我花了最多时间的地方就是加法算法，我使用了三条链，pa.pb,pc,我把和的结果给存放在pc中，当和为0的时候我不存入pc,if(p->xishu +q->xishu==0 )//系数和为0则不存入pc中,p.q都后移{p=p->next ;q=q->next ;}并且我还考虑了当两个多项式项数不相等的时候，用了一下这条语句去实现if(p==NULL)//p多项式比q短的时候，把q剩余的部分接到pctail->next=q;else//q多项式比p短的时候，把p剩余的部分接到pctail->next=p;，但是我刚开始的时候，if(p->next==NULL),这个加法没有成功，最后发现了这个错误，运行成功；4.我在编写这个程序的时候，很好地复习了c语言的知识，并且能够对链表这个章节的知识有很好的巩固；。
一元稀疏多项式加法运算
一元稀疏多项式加法运算一、需求分析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的子项：“系数、指数对”，必须按照升序输入，每输入一个子项就建立一个结点，并将其插入到多项式链表的表尾，如此重复，直至遇到输入结束标志的时候停止，最后生成按指数递增有序的链表。
一元稀疏多项式简单的计算器
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);}实验心得：无。
(完整)《C语言程序设计课程设计》题目——软件工程2班
1 一元稀疏多项式的运算问题描述：设有两个带头指针的单链表表示两个一元稀疏多项式A、B，实现两个一元稀疏多项式的处理.实现要求：⑴输入并建立多项式；⑵输出多项式，输出形式为整数序列：n,c1，e1，c2，e2……cn，en,其中n是多项式的项数,ci，ei分别为第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个班的同学的构造一个所有按平均成绩的以非递增方式排列的新的单链表；⑹设计一个菜单,至少具有上述操作要求的基本功能。
（本题⑸由2人完成）3 迷宫问题问题描述：以一个m×n的长方阵表示迷宫,0和1分别表示迷宫中的通路和障碍。
一元稀疏多项式的加法运算数据结构实习
实习一线性表、栈和队列及其应用——一元稀疏多项式的加法运算【问题描述】设计一个实现一元稀疏多项式相加运算的演示程序。
【基本要求】（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指针；然后定义两个指针，第一个指针指向第一个多项式，第二个指针指向第二个多项式。
一元稀疏多项式求导实验报告
TermSet中的每个元素包含一个表示系数的实数和表示指数的整数}
数据关系：R1＝{ <ai-1 ,ai >|ai-1 ,ai∈D,且ai-1中的指数值<ai中的指数值i=2,...,n }
基本操作：
CreatPolyn( &P,m)
SubtractPolyn(&Pa,&Pb)
初始条件：一元多项式Pa,Pb已存在
操作结果：完成多项式的相减运算，即Pa-Pb,并销毁一元多项式Pb。} ADT List
2.本程序主要包含个模块：
1）主程序模块：main函数
2）插入结点模块：void Insert(Polyn p,Polyn h)函数
flag++;
}
printf("\n");
}
Polyn QiuDaoPolyn(Polyn head)//求解并建立导函数多项式，并返回其头指针
{
Polyn q=head->next,p1,p2,hd;
hd=p1=(Polyn)malloc(sizeof(struct Polynomial));//建立头结点
}
}
}
Polyn CreatePolyn(Polyn head,int m)//建立一个头指针为head、项数为m的一元多项式
{
int i;
Polyn p;
p=head=(Polyn)malloc(sizeof(struct Polynomial));
head->next=NULL;
for(i=0;i<m;i++)
一元稀疏多项式的表示及加法运算
一元稀疏多项式的表示及加法运算一、需求分析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. 两个多项式相加两个多项式中如果指数相同则系数相加，构成和多项式的一项；如果指数不同，则直接构成和多项式的一项。
实验报告(实验二：一元稀疏多项式计算器)
云南大学软件学院实验报告指导教师：朱艳萍 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、程序比较复杂，算法思想也很难理清，需要多加锻炼。
一元稀疏多项式求解问题
中文摘要链表（Linked List）和顺序表（Sequential List）是程序语言中使用内存常用的方法，链表存储结构主要的不同在内存位置上不须相邻，顺序表是将线性表中的结点按其逻辑顺序依次存放在内存中的一组连续的存储单元中。
故容易对链表做插入或删除的操作，对顺序表进行取长度，查找等相对容易。
多项式的加，减，乘法等求解问题的运算正好实用链表，通过多项式指数值间的判断，进行系数间的加减乘法运算。
关键字：链表；顺序存储结构；多项式加、减、乘法；序言链表（Linked List），顺序表（Sequential List）和数组是程序语言中使用内存常用的方法，它们都为“有序列表”，就像火车一般，一个车厢接着一个车厢有序地连在一起。
但数组结构必须在程序编译前就定好数组元素的大小，因此，常须事先预估数据量的多少，且在删除或增加元素后，在其后的元素都必须跟着移动，而降低了执行的效率，链表结构正好可以完全改善数组结构的缺点，而顺序表要连续的内存空间，其主要的不同点在于内存位置不须相邻，所以每项数都有一个连接栏，可以存放下一个数据的地址，这样便可形成列表结构。
使用链表存储的目的及效果，在于“容易”对此结构作插入或删除的操作。
而我们必须决定组成链表的结构类型，动态数据结构至少包含两种不同的字段声明，其中一个字段是指向同一个结构类型的结构指针，另外一个则是存放数据的基本数据类型。
一元稀疏多项式的求解问题同样对于链表存储结构也适用，使算法简单化，更容易被人所理解，链表存储结构也在其他很多地方被用到。
目录中文摘要 (1)序言 (2)目录 (3)正文 (4)1.采用类c语言定义相关的数据类型 (4)2.各模块的伪码算法 (4)2.1两个多项式的输入 (4)2.2多项式进行降序排列 (5)2.3合并同类项 (6)3.各函数间调用关系图 (6)4.程序编码 (7)5.调试分析 (23)5.1调试中遇到的问题及对问题的解决方法 (23)5.2算法的时间复杂度 (23)6.测试结果 (23)6.1两个多项式的输入 (23)6.2进行加法运算 (24)6.3进行减法运算 (24)6.4乘法运算 (25)设计总结 (26)参考文献 (27)致谢 (28)正文1.采用类c语言定义相关的数据类型定义一元多项式链表：typedef struct DXS{ //定义一个多项式的结构体double c,e; //c,e分别为系数和指数int flag; //标记struct DXS *next;}DXS;2.各模块的伪码算法2.1两个多项式的输入la=pa=new DXS; //为多项式A,B结点分配空间，并指向头指针 lb=pb=new DXS;cout<<"请输入多项式A的项数（多项式为0，则算一项）:";cin>>n1;na=n1; //保存第一条多项式的项数cout<<"请输入A的数据（请按升序输入：第一项系数，第一项指数，第二项系数，第二项指数.....若为0，则输入0 0）:"<<endl;for(i=1;i <=n1;i++) //输入第一条多项式的数据 {cin>>pa->c>>pa->e;p=pa;pa=new DXS;p->next=pa;}cout<<endl<<endl;cout<<"请输入多项式B的项数（多项式为0，则算一项）:";cin>>n2;nb=n2; //保存第二条多项式的项数cout<<"请输入B的数据（请按升序输入：第一项系数，第一项指数，第二项系数，第二项指数.....若为0，则输入0 0）:"<<endl;for(i=1;i <=n2;i++) //输入第一条多项式的数据 {cin>>pb->c>>pb->e;q=pb;pb=new DXS;q->next=pb;}2.2多项式进行降序排列void down(DXS *l1,DXS *l2,int b) //多项式指数降序排列函数{double f,g;for(int c=b;c>1;c--){for(int d=1;d <c;d++){if(l1->e <l1->next->e){f=l1->e;l1->e=l1->next->e;l1->next->e=f;g=l1->c;l1->c=l1->next->c;l1->next->c=g;}l1=l1->next;}l1=l2;}}2.3合并同类项int arrange(DXS *s,DXS *head,int &b) //检测多项式中有没有相同项,若有,则合并为一项{for(int c=b;c>1;c--){if((s->e==s->next->e)){s->next->c = s->c + s->next->c;if(s->next->c==0)b--;b--;s->c=0;}s=s->next;}return b;}3.各函数间调用关系图4.程序编码#include <iostream>using namespace std;typedef struct DXS{ //定义一个多项式的结构体double c,e; //c,e分别为系数和指数int flag; //标记struct DXS *next;}DXS;void out(DXS *l,DXS *head,int a) //输出函数，参数为结点、头指针、多项式项数{if(a==0) //如果项数为0，则多项式为0cout<<0;for(int m=1;m <=a;m++){if(l->e==1){if(l==head) //分析第一个结点 {if( l->flag==-1) //输出几个特殊的系数{l=l->next;}if(l->c==0){cout<<l->c;l=l->next;}else if(l->e==0){cout<<l->c;l=l->next;}else if(l->c==1){cout<<"x";l=l->next;}else if(l->c==-1){cout<<"-x";l=l->next;}else{cout<<l->c<<"x";l=l->next;}}else //分析第一个之后的结点 {if( l->flag==-1) //输出几个特殊结点{l=l->next;}if(l->c==0){l=l->next;}else if(l->e==0){if(l->c>0){cout<<"+"<<l->c;l=l->next;}else{cout<<l->c;l=l->next;}}else if(l->c==1){cout<<"+x^";l=l->next;}else if(l->c==-1){cout<<"-x";l=l->next;}else if(l->c>0){cout<<"+"<<l->c<<"x";l=l->next;}else if(l->c <0){cout<<l->c<<"x";l=l->next;}}}else{if(l==head) //分析第一个结点 {if( l->flag==-1) //输出几个特殊的系数{l=l->next;}if(l->c==0){cout<<l->c;l=l->next;}else if(l->e==0){cout<<l->c;l=l->next;}else if(l->c==1){cout<<"x^"<<l->e;l=l->next;}else if(l->c==-1){cout<<"-x^"<<l->e;l=l->next;}else{cout<<l->c<<"x^"<<l->e;l=l->next;}}else //分析第一个之后的结点{if( l->flag==-1) //输出几个特殊结点 {l=l->next;}if(l->c==0){l=l->next;}else if(l->e==0){if(l->c>0){cout<<"+"<<l->c;l=l->next;}else{cout<<l->c;l=l->next;}}else if(l->c==1) {cout<<"+x^"<<l->e;l=l->next;}else if(l->c==-1){cout<<"-x^"<<l->e;l=l->next;}else if(l->c>0){cout<<"+"<<l->c<<"x^"<<l->e;l=l->next;}else if(l->c <0){cout<<l->c<<"x^"<<l->e;l=l->next;}}}}}void down(DXS *l1,DXS *l2,int b) //多项式指数降序排列函数{double f,g;for(int c=b;c>1;c--){for(int d=1;d <c;d++){if(l1->e <l1->next->e){f=l1->e;l1->e=l1->next->e;l1->next->e=f;g=l1->c;l1->c=l1->next->c;l1->next->c=g;}l1=l1->next;}l1=l2;}}void up(DXS *l1,DXS *l2,int b) //多项式指数升序排列函数{double f,g;for(int c=b;c>1;c--){for(int d=1;d <c;d++){if(l1->e>l1->next->e){f=l1->e;l1->e=l1->next->e;l1->next->e=f;g=l1->c;l1->c=l1->next->c;l1->next->c=g;}l1=l1->next;}l1=l2;}}int arrange(DXS *s,DXS *head,int &b) //检测多项式中有没有相同项,若有,则合并为一项{for(int c=b;c>1;c--){if((s->e==s->next->e)){s->next->c = s->c + s->next->c;if(s->next->c==0)b--;b--;s->c=0;}s=s->next;}return b;}int main(){DXS *pa,*pb,*pc; //定义三个多项式的结点DXS *la,*lb,*lc; //定义三个多项式的头指针 DXS *p,*q,*s;int n1,n2,n3,na,nb,nc; //多项式项数int i,j=0;char Q,Y;la=pa=new DXS; //为多项式A,B结点分配空间，并指向头指针 lb=pb=new DXS;cout<<"请输入多项式A的项数（多项式为0，则算一项）:";cin>>n1;na=n1; //保存第一条多项式的项数cout<<"请输入A的数据（请按升序输入：第一项系数，第一项指数，第二项系数，第二项指数.....若为0，则输入0 0）:"<<endl;for(i=1;i <=n1;i++) //输入第一条多项式的数据 {cin>>pa->c>>pa->e;p=pa;pa=new DXS;p->next=pa;}cout<<endl<<endl;cout<<"请输入多项式B的项数（多项式为0，则算一项）:";cin>>n2;nb=n2; //保存第二条多项式的项数cout<<"请输入B的数据（请按升序输入：第一项系数，第一项指数，第二项系数，第二项指数.....若为0，则输入0 0）:"<<endl;for(i=1;i <=n2;i++) //输入第一条多项式的数据 {cin>>pb->c>>pb->e;q=pb;pb=new DXS;q->next=pb;}pa=la; //重新指向头指针pb=lb;cout<<endl<<endl;cout<<"你希望做+/-/*:"; //选择多项式相加还是相减 cin>>Q;cout<<"希望降序还是升序排列（S：升序/J：降序）：";cin>>Y;cout<<endl<<endl<<endl<<endl;cout<<"(";out(pa,la,na); //输出多项式A并指回头指针 cout<<")";pa=la;if(Q=='+')cout<<endl<<endl<<" +"<<endl<<endl;else{if(Q=='*') cout<<endl<<endl<<" *"<<endl<<endl; else cout<<endl<<endl<<" -"<<endl<<endl;}cout<<"(";out(pb,lb,nb); //输出多项式B并指回头指针 pb=lb;cout<<")";switch(Q){case'-':{for(i=1;i<=n2;i++){pb->c=(-1)*pb->c;pb=pb->next;}pb=lb;}case'+':{lc=pc=new DXS;//为多项式C结点分配空间，并指向头指针 if(n1==1&&la->c==0) //关于有多项式为0的处理 n1--;else if(n2==1&&lb->c==0)n2--;while(n1>0&&n2>0) //两个不为0的多项式的运算，结果放到C中{if(pa->e>pb->e){pc->c=pb->c;pc->e=pb->e;pb=pb->next;pc->flag=0;s=pc;pc=new DXS; //重新分配结点空间s->next=pc;j++;n2--;}else if(pa->e <pb->e){pc->c=pa->c;pc->e=pa->e;pa=pa->next;pc->flag=0;s=pc;pc=new DXS;s->next=pc;j++;n1--;}else if(pa->e==pb->e){if(pa->c+pb->c!=0){pc->c=pa->c+pb->c; pc->e=pa->e;pa=pa->next;pb=pb->next;pc->flag=0;s=pc;pc=new DXS;s->next=pc;j++;n1--;n2--;}if(pa->c+pb->c==0){pa=pa->next;pb=pb->next;n1--;n2--;}}}while(n1>0) //把较长的多项式的其余部分放到C中 {pc->c=pa->c;pc->e=pa->e;pa=pa->next;pc->flag=0;s=pc;pc=new DXS;s->next=pc;j++;n1--;}while(n2>0){pc->c=pb->c;pc->e=pb->e;pb=pb->next;pc->flag=0;s=pc;pc=new DXS;s->next=pc;j++;n2--;}break;}case'*':{lc=pc=new DXS;//为多项式C结点分配空间，并指向头指针if(n1==1&&la->c==0) //关于有多项式为0的处理n1--;else if(n2==1&&lb->c==0)n2--;while(n1>0){pb=lb;n2=nb;while(n2>0){pc->c=pa->c*pb->c;pc->e=pa->e+pb->e;pb=pb->next;pc->flag=0;s=pc;pc=new DXS;s->next=pc;j++;n2--;}pa=pa->next;n1--;}break;}default: cout<<"输入有误";}nc=n3=j; //结果多项式的项数cout<<endl<<endl<<" ="<<endl<<endl;if(Y=='J'||Y=='j'){pc=lc;down(pc,lc,nc); //把多项式C降序排列 }else if(Y=='S'||Y=='s'){pc=lc;up(pc,lc,nc);}pc=lc;arrange(pc,lc,n3);cout<<"(";pc=lc;out(pc,lc,nc); //输出多项式Ccout<<")";if(n3==0)cout<<" "<<"(多项式共有"<<" "<<1<<" "<<"项)";elsecout<<" "<<"(多项式共有"<<" "<<n3<<" "<<"项)";cout<<endl<<endl<<endl;return 0;}5.调试分析5.1调试中遇到的问题及对问题的解决方法5.1.1在书写程序的过程中，由于自己的疏忽和粗心，有的函数名，关键字有写错的情况，再进行调试时发现了，并及时的加以了改正。
数据结构实验-一元多项式的加法运算
一元多项式加法一、实验目的通过实现多项式加法，对链表有更深入的了解二、实验内容问题描述：设计一个一元稀疏多项式简单的加法计算器实现要求：一元稀疏多项式简单计算器的基本功能是：（1）输入并建立多项式：1785937)(x x x x A +++=；879228)(x x x x B -+=（2）输出多项式（3）多项式A 和B 相加，建立多项式C ＝A ＋B ，并输出相加的结果多项式C（4）选作：多项式A 和B 相减，建立多项式C ＝A －B ，并输出相减的结果多项式D 方法说明：（1）多项式的输入与存储用带表头结点的单链表存储多项式，链表中的每个节点分别存储多项式各项的系数和指数，即每从键盘输入多项式的一对数（系数，指数），可对应建立链表的一个结点。
每个节点的结构为：建立两个链表，其中pa 和pb 分别为它们的头指针：pb结果链表Pa(或者是Pc)Pc（2）多项式数据类型的定义struct tagNode{float coef;int exp;struct tagNode *next;typedef struct tagNode Node;typedef struct tagNode* pNode;（3）主要算法①创建两个链表，分别存放多项式1和多项式2，这两个链表中的节点是按指数降序或者升序排列的②多项式相加，下面给出多项式相加的部分实现/*下面的函数实现两个多项式的相加，要相加的链表分别由pa和pb指向（其中，pa，pb都是分配了空间的头结点）。
相加的结果直接由pa指向的链表保存，即是在pa链表中添加或删除（当系数因为相加为0的情况下）一些结点，构成结果。
相加的链表中指数按从小到大的顺序排列好的，是升序链表。
*/void add_poly(Node *pa,Node *pb){Node *p=pa->pNext;//链表1，将来的结果也放在此Node *q=pb->pNext;//链表2Node *pre=pa;Node *u;//临时用float x;while (p!=NULL && q!=NULL)//当两个链表都不为空{if (p->exp<q->exp)//比较链表1跟链表2当前节点的指数大小，链表1也是存放结果的地方{pre=p;p=p->pNext;//p指向要比较的下一个结点。
246_考试11元稀疏多项式的计算
法运算，实现时有两种不同的方法把每次计算的结果与原来的中间结果进行相加。
【算法 1】 基本思想：把 Q(x)多项式的每一项分别去乘 P(x)多项式的每一项所得到的每 一个结果（一个结点）插入到结果多项式中，若结果多项式中无相同指数的项，则生成一个
8
新结点插入；若有相同指数的项，则系数相加。算法如图 函数接口：传入多项式链表指针 h1,h2
数递增排列的关键。
函数参数： Polyn h－要查找的多项式链表的头指针
int expn－新插入项的指数值。
Item **p －插入位置的前驱结点指针，由该函数的调用而被确定的内 容。新结点一定插入到该结点的后面。
函数返回值： -1－若指数 expn 值在某两个结点之间，则返回－ 1，参数 p 带回
4
(2)插入结点位置查找：确定将一个新结点插入到多项式链表结构中的位置，以保证 链表中结点按指数升序排列。
(3)交互选择：当出现重复性操作时，提供交互式选择方式，以确定其重复操作是否 进行。
(4)撤消多项式：释放表示多项式链表中所有结点的存储空间。 (5)多项式项插入：将表示多项式中一项的结点插入到链表中给定的位置。 (6)判多项式非空：判断某个多项式是否存在。 (7)判断两个多项式的当前运算项的关系（指数大于，等于，小于）
4、程序结构
本程序可以由 13 个函数组成，其中主函数 个。函数间的调用关系图 1-2 所示。
1 个，基本功能函数 5 个，辅助功能函数 7
main
nemu
Destroy
PolynNotEmpty
Input
AddPolyn
SubtractPolyn
MultPolyn
Output
Select
实习一 线性表及其应用 (题目：一元稀疏多项式的加法运算 )
实习一线性表及其应用（题目：一元稀疏多项式的加法运算）一、需求分析1.输入并建立两个多项式；2.多项式a与b相加，建立和多项式c；3.输出多项式abc。
输出格式：比如多项式a为：A(x)=c1xe1+c2xe2+…+ cmxem，其中，ci和ei分别为第i项的系数和指数，且各项按指数的升幂排列，即0≤e1＜e2＜…＜em。
多项式bc类似输出。
4测试数据（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)实习一线性表及其应用题目：一元稀疏多项式的加法运算实习时间：2012/9/20.10.12一、需求分析1.输入并建立两个多项式；2.多项式a与b相加，建立和多项式c；3.输出多项式abc。
输出格式：比如多项式a为：A(x)=c1xe1+c2xe2+…+ cmxem，其中，ci和ei分别为第i项的系数和指数，且各项按指数的升幂排列，即0≤e1＜e2＜…＜em。
多项式bc类似输出。
4测试数据（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）存储结构用带头结点的单链表存储多项式。
三个多项式链表中都只存储非零系数项。
若多项式a与b中指数相等的两项相加后，系数为零，则在和多项式c中不存储该指数项。
（2）主要算法基本思想按照链表的基本操作，初始化三个链表，在两个链表中按指数由小到大分别插入a和b的多项式（系数和指数），将多项式a的链表复制给多项式c的链表，再调用求和函数（b的链表和c的链表相加），将求和的结果插入到c的链表中（作为多项式c）最后输出多项式a，b，c三个多项式。
一元多项式的加减求导运算算法(数据结构算法)
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，。
一元稀疏多项式的加法运算[整理版]
![一元稀疏多项式的加法运算[整理版]](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");}。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
(5)两多项式相减函数： SubtractPolyn 函数格式 Polyn SubtractPolyn(Polyn h1,Polyn h2) 函数功能：实现两个多项式 h1 和 h2 相减。 函数参数： Polyn h1 —指向第一个多项式链表的头指针 Polyn h2 —指向第二个多项式链表的头指针 函数返回值：指向相减后的结果链表的头指针
三、实验原理
1、一元多项式的逻辑表示
一元多项式 pn(x)可表示成 : pn(x)=p 0+p1x+p 2x +2 …+pnx n
n+1 个系数可用线性表来表示：
p0，p1，p2，…， pn）
其中每一项的指数 i 隐含在其系数 pi 的序号中。
一个一元多项式，如果其系数不为 0 的项相对于其多项式的次数（最大指数）而言要少
(7)显示多项式函数： Output 函数格式： void Output(Polyn h,char *title) 函数功能：输出多项式的完整表示。如： P(x)=1.00+2.50x^3-3.5x^9 函数参数： Polyn h－要输出的多项式链表的头指针 char *title －字符串， 提示要输出一个什么样的多项式， 函数返回值：无返回值。
法运算，实现时有两种不同的方法把每次计算的结果与原来的中间结果进行相加。
【算法 1】 基本思想：把 Q(x)多项式的每一项分别去乘 P(x)多项式的每一项所得到的每 一个结果（一个结点）插入到结果多项式中，若结果多项式中无相同指数的项，则生成一个
8
新结点插入；若有相同指数的项，则系数相加。算法如图 函数接口：传入多项式链表指针 h1,h2
对 B 多项式的项，系数符号变换后，再将放入结果多项式中 （3）两个多项式相乘 (C=A ×B)的运算原则
用 B 多项式的每一项分别去乘 A 多项式的每一项， 并将乘得得结果放入结果
多项式中。 若结果多项式中有指数相同的项，则应把它们合并为一项。
四、实现
1、约定 使用带头结点的链表表示一元稀疏多项式。
2
实验一 一元稀疏多项式的计算
一、实验目的
通过一元稀疏多项式的表示和计算，帮助学生熟练掌握线性表的基本操作，以及用线性 链表表示线性表的存储结构和操作的实现。
二、实验内容
实现一元稀疏多项式的如下运算： (1)两个一元稀疏多项式相加运算 (2)两个一元稀疏多项式相减运算 (3)两个一元稀疏多项式相乘运算
A多
2、基本功能
(1)多项式的输入 (2)两个一元稀疏多项式相加运算： (3)两个一元稀疏多项式相减运算： (4)两个一元稀疏多项式相乘运算：
(5)多项式打印
P(x)+Q(x P(x)－Q(x) P(x)×Q(x)
3、辅助功能
(1)菜单选择：将上述功能通过“菜单”形式罗列出来，通过菜单选择进行交互式控 制程序运行。
1-3 所示。
初始化结果多项式链表 h3
Pb=h2->next;
Pa=h1->next;
Expn=pb->expn+pa->expn; Coef=pb->coef*pa->coef
While(Pb)
While(Pa)
InsertLocate(head,exItem(s); s->coef=coef; s->expn=expn; insert(pp,s);
4
(2)插入结点位置查找：确定将一个新结点插入到多项式链表结构中的位置，以保证 链表中结点按指数升序排列。
(3)交互选择：当出现重复性操作时，提供交互式选择方式，以确定其重复操作是否 进行。
(4)撤消多项式：释放表示多项式链表中所有结点的存储空间。 (5)多项式项插入：将表示多项式中一项的结点插入到链表中给定的位置。 (6)判多项式非空：判断某个多项式是否存在。 (7)判断两个多项式的当前运算项的关系（指数大于，等于，小于）
的值为指数值小于 expn 的结点指针。
0－若指数 expn 值等于某结点的指数值，则返回 0，参数 p 带回
的值为指数值等于 expn 的结点指针。
1－若指数 expn 值大于最后一个结点的指数值， 带回最后一个结点的指针
则返回 1，参数 p
（10）结点插入函数： insert
7
函数格式： void insert(Item *pre,Item *p) 函数功能：在指定结点 pre 后插入一个新结点 p。 函数参数： Item *pre －被插入结点的前驱结点
8--print P(x)+Q(x)
表示打印两多项式相加的结果
9--print P(x)-Q(x)
表示打印两多项式相减的结果
10--print P(x)*Q(x)
表示打印两多项式相乘的结果
11—Quit
表示退出系统，结束程序的运行
在运行过程中，输入其中一个序号，即表示下一步执行后面的功能。如输入
3，
（ 2） 用线性链表表示的一元稀疏多项式中，各结点按指数的升序排列。 （ 3） 每个多项式都独立存在，即参与运算的两个多项式的数据不能因运算而受到破坏， 加、减、乘运算的结果应相互不受影响。因此，对于每种情况都必须单独建立一个链表进行 表示。 （ 4） 每一种重复性的操作都要进行确认，以免破坏原有操作的结果。如需要输入 项式，而 A 多项式已经存在，这时通过“确认”后再确定是否真正需要输入。
9
函数接口：传入多项式链表指针 h1,h2 初始化结果多项式链表 h3
(6)两多项式相乘函数： MultPolyn 函数格式 Polyn MultPolyn(Polyn h1,Polyn h2) 函数功能：实现两个多项式 h1 和 h2 相乘。 函数参数： Polyn h1 —指向第一个多项式链表的头指针
6
Polyn h2 —指向第二个多项式链表的头指针 函数返回值：指向相乘后的结果链表的头指针
数递增排列的关键。
函数参数： Polyn h－要查找的多项式链表的头指针
int expn－新插入项的指数值。
Item **p －插入位置的前驱结点指针，由该函数的调用而被确定的内 容。新结点一定插入到该结点的后面。
函数返回值： -1－若指数 expn 值在某两个结点之间，则返回－ 1，参数 p 带回
五、部分算法描述
两个多项式相加运算的算法参见教科书的描述。 两个多项式相减运算算法与多项式相加运算的算法结构一致， 作为独立的一项时，其系数应改变其正 /负号。
只是把 Q(x)多项式的结点
这里只对两个多项式相乘运算的算法加以描述。两个多项式相乘运算的基本原理是：用
Q(x)多项式的每一项分别去乘 P(x)多项式的每一项，并将乘得得结果放入结果多项式中。若 结果多项式中有指数相同的项，则应把它们合并为一项。这实际上是运用加法运算来实现乘
得多，则称该一元多项式为一元稀疏多项式。
对一元稀疏多项式，若采用顺序存储结构，需
n+1 个元素单元存放系数。当
零的系数较多时，既浪费存储空间，又浪费运算时间。如：
s(x)=1+3x 10000 +2x 20000
n 很大且为
采用顺序存储分配需 20001 个元素空间，但只有 3 个元素有意义。若参与同数量级的加
insert
图 1-2：程序结构示意图
5、程序函数
（1）主函数： main 功能：通过菜单选择控制对系统功能的操作
（2）菜单选择函数： menu 函数格式： int menu(void) 函数功能：构造功能菜单，并选择下一步要操作的功能。 函数参数：无参数。
ItemComp
5
函数返回值： 1～11 中的一个序号。 可供选择的功能如下：
3
int expn; struct Item *next; }Item,*Polyn;
3、一元稀疏多项式运算原理
设有两个稀疏多项式 A 和 B，其运算原理如下： （1）两个多项式相加 (C=A ＋B)的运算原则：
指数相同，系数相加，若不为 0，则在结果多项式中构成一新项。 指数不同，则两项分别抄入结果多项式中。 （2）两个多项式相减 (C=A －B)的运算原则： 指数相同，系数相减，若不为 0，则构成一新项。 指数不同，对 A 多项式的项，直接抄入结果多项式中。
如“P(x)”。
(8)判断选择函数： Select 函数格式： int Select(char *str) 函数功能： 根据 str 提示的内容判断是执行指定的操作，
还是不执行。 输入“Y”
则表示执行，若输入“ N”表示不执行。如当 P(x)多项式已经产生后，若
再选择产生 P(x)，这是提示：
P(x) is not Empty,Create P(x) again?
表示执行 P(x)+(x) 额运算。
(3)输入多项式函数： input 函数格式： Polyn Input(void) 函数参数：无参数 函数功能：输入多项式各项的系数和指数，生成一个多项式链表。 函数返回值：指向一个多项式链表的头指针
(4)两多项式相加函数： AddPolyn 函数格式 Polyn AddPolyn(Polyn h1,Polyn h2) 函数功能：实现两个多项式 h1 和 h2 相加。 函数参数： Polyn h1 —指向第一个多项式链表的头指针 Polyn h2 —指向第二个多项式链表的头指针 函数返回值：指向相加后的结果链表的头指针
1--create P(x) 2--create Q(x)
表示生成 P多项式 表示生成 Q 多项式
3--p(x)+Q(x)
表示两多项式相加
4--P(x)-Q(x)
表示两多项式相减
5--p(x)*Q(x)
表示两多项式相乘
6--print P(x)
表示打印 P多项式