一元多项式求和
一元多项式的求和运算
一元多项式的求和运算一元多项式的求和运算是代数学中的重要概念，它涉及到多项式的基本运算和代数方程的求解。
在本文中，我们将全面介绍一元多项式的求和运算，并提供一些指导意义。
一元多项式是由若干项组成的，每一项包含一个常数乘以一个变量的幂。
例如，多项式f(x) = 3x^2 + 2x + 1就是一个一元多项式，其中包含了三个项：3x^2、2x和1。
求和运算即将多项式中的所有项相加，得到一个结果。
求和运算过程中，首先需要将多项式按照指数从高到低排列。
这样做的目的是方便相同指数的项合并，从而简化求和的过程。
例如，对于多项式f(x) = 3x^2 + 2x + 1，按照指数从高到低排列后，变为f(x) = 3x^2 + 2x + 1。
接下来，我们将相同指数的项合并。
在本例中，没有相同指数的项，所以不需要合并。
最后，将所有项相加，得到最终结果。
除了将相同指数的项合并外，求和运算还可以应用于求解代数方程。
当我们需要找到使得多项式等于零的变量值时，可以通过求和运算得到该变量的解。
例如，若要求解方程f(x) = 0，可以将多项式按照指数从高到低排列，并将所有项相加。
若最终结果为0，即表明该变量的某个值满足方程。
一元多项式的求和运算在数学和科学中有广泛的应用。
在代数学中，基于求和运算的多项式求解技术被广泛应用于方程求解、多项式插值和最小二乘拟合等问题中。
在物理学中，一元多项式的求和运算用于描述物理量之间的关系，如牛顿运动定律、电路分析和热力学方程等。
在经济学和金融学中，多项式的求和运算用于建模和预测经济变量，如股票价格、利率和通货膨胀率等。
通过一元多项式的求和运算，我们可以更好地理解多项式的性质和特点，从而应用于实际问题的求解。
同时，求和运算也是培养数学思维和解决实际问题的重要途径之一。
通过合理运用多项式的求和运算，我们可以化繁为简，解决复杂的问题。
综上所述，一元多项式的求和运算是代数学中的重要概念，它不仅包括多项式的基本运算和代数方程的求解，还具有广泛的应用。
一元多项式的求和
一元多项式的求和一元多项式的求和是数学中常见的问题，它涉及到对一元多项式中的各项进行求和运算，是代数学中的重要概念之一。
本文将介绍一元多项式的求和的基本概念、方法和应用。
一元多项式是指仅含有一个未知数的多项式，它由若干个单项式相加或相减而成。
每个单项式由系数和次数两部分组成，其中系数可以是实数、复数或其他数域中的元素，次数为非负整数。
一元多项式的一般形式可以表示为：P(x) = a_nx^n + a_{n-1}x^{n-1} + ... + a_1x + a_0其中，P(x)表示一元多项式，a_n, a_{n-1}, ..., a_1, a_0为系数，x为未知数，n为最高次数。
一元多项式的求和即是对多项式中各项的系数进行求和运算。
具体来说，就是将各项的系数相加得到一个结果。
例如，对于一元多项式：P(x) = 2x^3 - 5x^2 + 3x - 1我们可以将其系数相加得到求和结果为：2 + (-5) +3 + (-1) = -1这就是该一元多项式的求和结果。
对于一元多项式的求和，可以应用代数学中的求和公式或方法进行计算。
常见的求和方法包括直接相加法、分组求和法和利用求和公式法。
直接相加法是最简单直观的求和方法，即将各项的系数直接相加。
这种方法适用于项数较少或系数较简单的一元多项式。
例如，对于一元多项式：P(x) = 2x^3 - 5x^2 + 3x - 1我们可以直接相加得到求和结果为：2 + (-5) +3 + (-1) = -1分组求和法是将一元多项式中的各项按照次数进行分组，然后对每组的系数进行求和。
这种方法适用于项数较多或系数较复杂的一元多项式。
例如，对于一元多项式：P(x) = 2x^3 - 5x^2 + 3x - 1我们可以按次数分组得到：2x^3 + (-5x^2) + 3x + (-1)然后对每组的系数进行求和，得到求和结果为：2 + (-5) +3 + (-1) = -1利用求和公式法是根据一元多项式的特点，利用求和公式进行计算。
完整word版一元多项式求和实验报告范文_
完整word版一元多项式求和实验报告范文_实验一、线性结构综合应用一、实验题目：顺序表的应用二、实验内容：一元多项式求和。
把任意给定的两个一元多项式P(某),Q(某)输入计算机，计算它们的和并输出计算结果。
三、设计分析：实现要定义的一元多项式应采用链式存储结构。
根据一元多项式相加的运算法则，对于两个多项式中所有指数相同的项，对应系数相加，若其和不为零，则构成新多项式的一项；对于两个多项式中所有指数不同的项，分别复制到新多项式中。
新多项式不必另外生成，而是在原来的两个多项式中摘取结点即可。
采用顺序存储结构存储多项式系数A，使多项式的某些运算变得更简洁。
但在实际使用时，多项式的阶数可能很高，不同的多项式阶数可能相差很大，这使顺序存储结构的最大长度难以确定。
而且，最高次幂与最低次幂项之间缺项很多时，采用顺序存储结构显然十分浪费存储空间，因此，一般情况下多采用链式存储结构来存储高阶多项式。
在用线性链表来存储一个多项式时，多项式中的每个非零项系数对应一个结点，结点由数据元素项和指针组成。
数据元素项中包含系数和指数值，设计中先定义定义数据元素中的数据，其中有指数、系数级指针ne某t等。
并要先构造一元多项式。
在定义输出、删除、合并等模块。
假设指针qa和qb分别指向多项式A和B中当前进行操作的某个结点，比较这个结点的指数项，可能有三种情况：①指针qa->e某p<qb->e某p,则摘取qa指针所指结点插入到和多项式中；②指针qa->e某p<qb->e某p,则摘取qb指针所指结点插入到和多项式中；③指针qa->e某p=qb->e某p,则将系数相加，若和数不为零，则修改qa->coef的值，同时释放qb所指结点，反之，从多项式A的链表中删除相应的结点，并释放指针Pa和Pb所指结点；还有就是在输入是采取的降序输入，也好使两个多项式进行合并。
并输出。
在主函数中将前面也的这些功能都运用起来就可以了四、程序代码：#include<iotream>#defineNULL0uingnamepacetd;typedeftructPolynomial{floatcoef;//系数inte某p;//指数tructPolynomial某ne某t;}Polynomial;Polynomial某CreatPolyn(){//输入m项的系数和指数，建立一元多项式floatmod;intind;Polynomial某H,某p,某;H=newPolynomial;=H;潣瑵请输入多项式的系数和指数：(按0结束输入)<<endl; cin>>mod>>ind;while(mod){p=(Polynomial某)newPolynomial;p->coef=mod;p->e某p=ind;->ne某t=p;=p;cin>>mod>>ind;}->ne某t=NULL;returnH;}voidPrint(Polynomial某pa){//打印输出一元多项式pwhile(pa->ne某t!=NULL){pa=pa->ne某t;cout<<pa->coef<<某某^<<pa->e某p;if(pa->ne某t!=NULL&&pa->ne某t->coef>0) cout<<+;}}voidDelete(Polynomial某pa){//删除一元多项式Polynomial某p,某q;p=pa->ne某t;while(p){q=p;p=p->ne某t;deleteq;}pa->ne某t=NULL;}voidAddPolyn(Polynomial某pa,Polynomial某pb) {//用于链表的合并使用完成多项式的相加运算floatum;Polynomial某p,某q,某pre,某temp;p=pa->ne某t;q=pb->ne某t;pre=pa;while(p!=NULL&&q!=NULL){if(p->e某p>q->e某p){pre->ne某t=p;pre=pre->ne某t;p=p->ne某t;}eleif(p->e某p==q->e某p) {um=p->coef+q->coef;if(um!=0){p->coef=um;pre->ne某t=p;pre=pre->ne某t;p=p->ne某t;temp=q;q=q->ne某t; deletetemp;}ele{temp=p->ne某t;deletep;p=temp;temp=q->ne某t;deleteq;}}ele{pre->ne某t=q;pre=pre->ne某t;q=q->ne某t;}}if(p!=NULL)//将多项式A中剩余的结点加入到和多项式中pre->ne某t=p;elepre->ne某t=q;}intmain(){intc;intt=1;cout<<某某某某某某某某某某某某某某某某某某菜单某某某某某某某某某某某某某某某某某<<endl<<endl;cout<<.创建并显示一元多项式A和B，计算一元多项式A加B并显示和<<endl<<endl;cout<<.退出程序.<<endl;cin>>c;witch(c){cae1:Polynomial某p1,某p2;p1=CreatPolyn();潣瑵一元多项式A是:;Print(p1);cout<<endl;p2=CreatPolyn();潣瑵一元多项式B是:;Print(p2);cout<<endl;AddPolyn(p1,p2);潣瑵一元多项式A加B的和是:;Print(p1);cout<<endl;Delete(p1);break;cae2:t=0;break;}}ytem(paue);return0;}五、测试用例：六、实验总结通过这次实验，对于链表的应用知识有了更加深刻的认识，虽然中间出了很多问题，但是经过调试以后都得以解决。
一元多项式相加问题实验报告
一元多项式相加问题一．问题描述设计算法实现一元多项式的简单运算。
二．数据结构设计分析任意一元多项式的描述方法可知，一个一元多项式的每一个子项都由“系数---指数”两部分组成，所以可以将它抽象成一个由“系数----指数对”构成的线性表。
基于这样的分析，可以采用一个带有头结点的单链表来表示一个一元多项式。
具体数据类型定义为：typedef struct node{float cofe; //系数域int exp; //指数域struct node* next; //指针域指向下一个子项}*polynode,poly;Polynode head_a,head_b,head_c;这三个指针分别作为链表A，B和C的头指针。
三．功能设计1.输入并建立多项式的功能模块此模块要求按照“系数---指数对”的输入格式输入各个子项，输入一个子项，通过遍历链表比较指数的大小，将新结点插在合适的位置，使多项式的指数按递增的顺序存储。
当遇到输入结束标志是停止输入，而转去执行程序下面的部分。
具体函数构造为：polynode creat_polynode(){polynode A ,p,q,s; //建立这种类型的头指针，尾指针，遍历指针和动态指针float a;int b;A=new poly;A->next=NULL;q=A;p=A;cin>>a;cin>>b;while(a!=0||b!=0){s=new poly;s->cofe=a;s->exp=b;while(q->next){if(q->next->exp<b)q=q->next; //遍历链表，若指数大于原链表指数，指针后移一个else{s->next=q->next;q->next=s;break; //若不是，将结点插入指针后面}}if(q->next==NULL){s->next=p->next;p->next=s;p=s; //q遍历到链表尾仍未插入，将结点插入最后，改变尾指针使其指向新结点}q=A; //让q返回头指针处，以便下一次遍历链表cin>>a;cin>>b;}if(p!=NULL)p->next=NULL;return A;}2.多项式相加的功能模块此模块根据在1中建立的两个多项式进行相加运算，并存放在以C为头指针的一个新链表中。
线性表——一元多项式的求和
线性表——⼀元多项式的求和♥注：未经博主同意，不得转载。
多项式的表⽰与求和是线性表应⽤的典型案列。
在数学上，⼀元多项式P（x）的表⽰为：P（x）=a0+a1x+a2x2+…+anxn其中，n为⼤于或等于0的整数，表⽰x的幂：a o,a1,…a n为系数，a n≠0,a0，a1，…，a n-1可以为0，也可以不为0。
⼀元多项式的表⽰ 为了表⽰⼀元多项式，可以将其所有项的系数⽤⼀个线性表来表⽰：（a0,a1,…，a n）。
这个线性表可以使⽤顺序存储结构或链式存储结构来存储，从⽽进⾏多项式的有关运算。
若采⽤顺序存储结构，可使⽤⼀个⼀维数组存储这个线性表，即多项式的系数，⽽相应的幂则使⽤数组下标来表⽰。
⼀元多项式的顺序存储结构如下：1 typedef int DataType;2const int MaxPolySize=100;34class Polyn5 {6private:7 DateType data[MaxPolySize];8int size; //元素的个数910public:11 Polyn(){size = 0;} //构造⼀个空多项式12 ~Polyn();1314void Clear(){size=0;} //清空15 Polyn sum(Polyn a); //多项式相加16 Polyn sub(Polyn a); //多项式相减17 }; 但多项式的顺序存储有⼀个缺点：当存储形如P(x)=1+10x99的多项式时，由于a1到a98均为0，所以⽤来存储⼀元多项式的⼀维数组中的绝⼤部分单元存储的值都是0，导致存储效率低下，造成存储空间的浪费。
因此，⼀般采⽤链式存储结构来描述⼀元多项式。
⼀元多项式的链式存储必须显式地表达系数值和幂值，这是由于链式存储打破了顺序存储中原有的幂与数组下标间的⼀⼀对应关系，⼀元多项式的项的结点结构表⽰如图所⽰。
⼀元多项式的链式存储结构表⽰如下：12struct term3 {4double coef; //系数5int expn; //指数6 };7struct PNode8 {9 term data;10 PNode *next;11 };12class Ployn13 {14 PNode *phead;15public:16 Polyn()17 { //构造函数18 phead =new PNoed;19if(phead= =NULL)20 exit(0);21 phead->next=NULL;22 }23 ~Polyn(); //析构函数2425void PolynAdd(Ployn Pa,Ployn Pb); //两个多项式相加26void Print(); //打印多项式27void Create(); //建⽴多项式28 };29⼀元多项式的求和 本节以多项式的加法为例，讲述⼀元多项式操作的实现。
一元多项式求和
实验二一．学生基本情况：专业班级：学号：姓名：二．实验题目、实验内容1、实验目的：（1）熟练掌握链表结构及有关算法的设计；（3）掌握用链表表示特定形式的数据的方法，并能编写出有关运算的算法。
2、实验内容：一元多项式求和。
把任意给定的两个一元多项式P(x),Q(x)输入计算机，计算它们的和并输出计算结果。
三．设计分析先构造两个项链表，分别存储两个多项式的系数和指数，然后将每个链表按指数的大小从小到大排列，以便于后来的合并。
合并的伪代码如下：当然，多项式的输出也不简单，要考虑系数是否为1，为1时x前的系数不显示，指数是否为1，为1时也不显示。
还有最前面的项如果系数为正，则不显示+号。
四．源程序代码#include<stdio.h>#include<stdlib.h>#define M 50typedef struct node//项节点{float coef;//系数float exp;//指数node * next;//下一节点}Linode;void Initlinode(Linode * &L)//初始化{L=(Linode * )malloc(sizeof(Linode));L->coef=L->exp=0;L->next=NULL;}void Createlinode(Linode * &L,int n)//建立项链表{Linode * p,* s=L;int i;for(i=0;i<n;i++){printf("输入第%d个数的系数和指数:\n",i+1);p=(Linode * )malloc(sizeof(Linode));scanf("%f%f",&(p->coef),&(p->exp));s->next=p;p->next=NULL;s=p;}}void Destroylinode(Linode * &L)//销毁链表{Linode * p=L,* s=L->next;while(s!=NULL){free(p);p=s;s=s->next;}free(p);}bool Sort(Linode * &L)//排序{Linode * p, * pre,* q;if(L->next==NULL)return 0;p=L->next->next;L->next->next=NULL;while(p!=NULL){q=p->next;pre=L;while(pre->next!=NULL&&pre->next->exp<p->exp) pre=pre->next;p->next=pre->next;pre->next=p;p=q;}return 1;}bool Plus(Linode * &A,Linode * &B)//合并多项式{Linode * p=A->next, * q=B->next,* r=A,* s;if(q==NULL)return 0;while(p!=NULL&&q!=NULL){s=q->next;if(p->exp<q->exp){while(p!=NULL&&p->exp<q->exp){p=p->next;r=r->next;}}if(p!=NULL&&p->exp>q->exp){r->next=q;q->next=p;r=q;q=s;if(s!=NULL)s=s->next;}if(p!=NULL&&q!=NULL&&p->exp==q->exp){p->coef=p->coef+q->coef;if(p->coef==0){r->next=p->next;free(p);p=r->next;}else{p=p->next;r=r->next;}free(q);q=s;}}if(q!=NULL)r->next=q;return 1;}void Displinode(Linode * &L){Linode * p=L->next;while(p!=NULL){if(p->exp==0)printf("%.4f",p->coef);else if(p==L->next&&p->coef>=0){if(p->coef==1){if(p->exp==1)printf("x");elseprintf("x^%.2f",p->exp);}else{if(p->exp==1)printf("%.4fx",p->coef);elseprintf("%.4fx^%.2f",p->coef,p->exp);}}else{if(p->coef>=0){if(p->coef==1){if(p->exp==1)printf("+x");elseprintf("+x^%.2f",p->exp);}else{if(p->exp==1)printf("+%.4fx",p->coef);elseprintf("+%.4fx^%.2f",p->coef,p->exp);}}else{if(p->coef==-1){if(p->exp==1)printf("-x");elseprintf("-x^%.2f",p->exp);}else{if(p->exp==-1)printf("%.4fx",p->coef);elseprintf("%.4fx^%.2f",p->coef,p->exp);}}}p=p->next;}printf("\n");}void main(){int m,n;Linode* A;Linode* B;Initlinode(A);Initlinode(B);printf("输入P(x)的项数:");scanf("%d",&m);Createlinode(A,m);if(Sort(A)==1)printf("排序成功\n");printf("P(x)=");Displinode(A);printf("输入Q(x)的项数:");scanf("%d",&n);Createlinode(B,n);if(Sort(B)==1)printf("排序成功\n");printf("Q(x)=");Displinode(B);if(Plus(A,B)==1)printf("表达式为F(x)=");Displinode(A);Destroylinode(A);}五．测试用例（尽量覆盖所有分支）六．实验总结对于这个实验，我最开始的想法是输入字符串，然后将字符串拆分成几个项存入链表中，然后再排序，合并。
数据结构：一元多项式的表示与相加
实验一一元多项式的表示与相加实验目的：1.复习并熟练掌握数据结构所使用的程序设计语言——C语言；2.学会单步跟踪、调试自己的程序；3.加深对线性表特别是链表知识的理解和掌握，并能够运用相关知识来解决相关的具体问题，如一元多项式相加等；程序流程：1.定义一元多项式链表结构体类型；2.输入多项式项数以分配存储空间；3.输入多项式每项的系数和指数，将其插入当前多项式链表。
同时判断是否有与当前节点指数相同的项，若存在，则将两项系数相加合并。
此外，若存在系数为0的项，将其存储空间释放；4.进行多项数加法时，新建一个存储结果的链表，分别将两多项式各项依次插入结果多项式即完成多项式相加运算；5.进行多项数加法时，将减项多项式各项系数化为相反数后进行加法操作，即完成多项式相减运算；6.对x赋值后，将x值代入多项式进行运算得到多项式的值；7.输出多项式。
注意：进行完一次运算以后，应该及时销毁无用多项式以释放空间以便再次应用。
算法及注释：1）定义一元多项式链表结构体类型typedef struct Lnode{float cof; //定义系数int exp; //定义指数struct Lnode *next; //定义指针变量指向下一个节点}Lnode ,*Linklist; //定义新的变量类型2）建立多项式存储线性链表头结点void makehead(Linklist &head){ head=(Linklist)malloc(sizeof(Lnode)); //建立新的节点head->exp=-1; head->next=NULL; //指针赋空head->cof=1; }3）将输入的多项式信息存储于节点中void makelnode(Lnode *&p){ p=(Lnode*)malloc(sizeof(Lnode)); //建立新的节点printf(Input the cof and exp\n); scanf(%fx%d,&p->cof,&p->exp); //输入多项式底数指数信息p->next=NULL; //指针赋空}4）清除系数为零的多项式节点void clear(Linklist la){ Lnode *p,*q; //定义两个指向结构体的指针p=la; q=p->next; while (q){ if (fabs(q->cof)<=0.000001) { //判断系数为零p->next=q->next; //指针指向相隔的下一个节点free(q); //销毁系数为零的节点q=p->next; //指针后移一位} else { p=p->next; //p q分别后移一位q=q->next;} } }5）找到多项式中与当前节点同指数项位置int locate(Linklist l,Lnode *&p,Lnode*e){ p=l;//标记表头if (!l->next)return(0); while(p&&e->exp!=p->exp){//当p存在且指数不相等时指针后移p=p->next; } if(p) return(p);//当p存在时，返回p地址else {//没找到时寻找出插入位置p=l; while (p->next&&e->exp<=p->next->exp) p=p->next; if (!p->next){ p=p;return(0); } return(0); } }6）将多项式节点插入已有多项式链表中，同时完成系数运算void caseinsert(Linklist &l,Lnode *e){ Lnode *p;if (locate(l,p,e)){//指数相同项系数相加p->cof += e->cof; free(e); } else{//插入新的项e->next=p->next; p->next=e; } }7）创建新的多项式链表void creat(Linklist &head,int m){ Lnode *p;int i; makehead(head);//建立头结点for (i=1;i<=m;i++){ p=(Linklist)malloc(sizeof(Linklist));//建立新的多项式单个节点空间makelnode(p);//建立赋值caseinsert(head,p);//将多项式节点插入已有多项式链表中，同时完成系数运算} clear(head); }8）输入多项式项数并创建节点进行存储void input(Linklist &l){ int m; printf(Input the Poly numbers\n); scanf(%d,&m); creat(l,m);//建立一个l 指向的头指针有m项的多项式链表}9）输出多项式void print(Linklist l){ Lnode *p; p=l->next;printf(Poly：ox^%d,p->cof,p->exp); p=p->next; while (p){ if(p->cof>0) printf(+);//系数正负号if (fabs(p->cof)<=0.000001); break;//不输出系数为零的项printf(ox^%d,p->cof,p->exp); p=p->next;//指针后移} printf(\n); }10）进行多项式加法运算void add(Linklist la,Linklist lb,Linklist &lc) { Lnode *p,*q,*q1,*p1; p=la->next; q=lb->next; makehead(lc);//建立一个新的表头while(p){ p1=p->next; caseinsert(lc,p);//将多项式节点p插入已有多项式链表lc中，同时完成系数运算p=p1;//指针后移} while(q){ q1=q->next; caseinsert(lc,q);//将多项式节点q插入已有多项式链表lc中，同时完成系数运算q=q1; } }11）将减项多项式转化为系数为相反数的多项式便于转化为加法运算void reverse(Linklist &l){ Linklist p; p=l->next; while(p){ p->cof*=-1;//系数自乘-1p=p->next; } }12）进行多项式减法运算void sub(Linklist la,Linklist lb,Linklist &lc){ reverse(lb); add(la,lb,lc);clear(lc);//清除头结点}13）对x赋值进行多项式赋值运算float value(Linklist l,float x){ float sum=0,t; int i; Linklist p=l->next; while(p){t=1;for (i=p->exp;i>0;i--) t*=x; sum=sum+t*p->cof; p=p->next; } return(sum); }14）销毁已有多项式，清除已有多项式占用的存储空间void destroy(Linklist la){ Lnode *p,*q; p=la; while(p){ q=p; p=p->next; free(q); } }15）创建主程序即菜单界面void main(){ Linklist l[10]; int c,n,m,i; float a; printf(Choose the number to operate：\n); printf( 1：Creat a Poly\n); printf( 2：Poly Addition\n); printf( 3：Poly Substraction\n); printf( 4：Evaluation\n); printf( 5：Destroy a Poly\n); printf( 6：Print a Poly\n); printf( 0：Exit\n); printf(\nDestroy the Polys after used.\n); printf(\n*use ',' to separate\n);scanf(%d,&c); while (c){ switch (c){ case 1: printf(Input the Poly number 1~9\n);scanf(%d,&n); input(l[n]);break; case 2: printf( Input the Poly number to add,and the Poly number stored in\n); scanf(%d,%d,%d,&n,&m,&i); add(l[n],l[m],l[i]);break; case 3: printf( Input the Poly number to subtract,and the Poly number stored in\n); scanf(%d,%d,%d,&n,&m,&i);sub(l[n],l[m],l[i]);break; case 4: printf(Input the number to operate and the value of x:\n);scanf(%d,%f,&n,&a); printf(%f\n,value(l[n],a));break; case 5: printf(Input the Poly number:\n); scanf(%d,&n); destroy(l[n]);break; case 6: printf( Input the Poly number:\n); scanf(%d,&n); print(l[n]); case 0: n=0;break; default:printf(ERROR!); } printf(Choose the number to operate:\n); scanf(%d,&c); }printf(OK!\n);程序运行截图：实验总结：这次实验室数据结构第一次上机实验，由于与C语言课程的学习相隔已经一个学期，对C语言有些生疏和遗忘，在编程过程中出现很多错误。
数据结构-实验一-一元多项式相加
数据结构实验报告实验一：一元多项式相加姓名：周成学号： 13083511专业：软件工程任课教师：马慧珠2013年12 月01 日1.实验名称：一元多项式相加2.实验目的:如何使用C语言实现链表的说明、创建以及结点的插入和删除等操作。
3.实验要求：对一元多项式能实现输入、输出，以及两个一元多项式相加及结果显示。
4.实验内容：一元多项式的表示在计算机内用链表来实现，同时为了节省存储空间，只存储其中非零的项，链表中的每个节点存放多项式的系数非零项。
它包含三个域，分别存放多项式的系数，指数，以及指向下一个项的指针。
根据一元多项式相加的运算规则：对于两个一元多项式中所有指数相同的项，对应系数相加，若其和不为零，则构成“和多项式”中的一项，对于两个一元多项式中所有指数不相同的项，则分别复抄到“和多项式”中去。
核心算法PolyAdd是把分别由pa和pb所指的两个多项式相加，结果为pa所指的多项式。
运算规则如下：相加时，首先设两个指针变量qa和qb分别从多项式的首项开始扫描，比较qa和qb所指结点指数域的值，可能出现下列三种情况之一：（1）qa->exp大于qb->exp,则qa继续向后扫描。
（2）qa->exp等于qb->exp,则将其系数相加。
若相加结果不为零，将结果放入qa->coef中，并删除qb所指结点，否则同时删除qa和qb所指结点。
然后qa、qb继续向后扫描。
（3）qa->exp小于qb->exp,则将qb所指结点插入qa所指结点之前，然后qa、qb继续向后扫描。
扫描过程一直进行到qa或qb有一个为空为止，然后将有剩余结点的链表接在结果表上。
所得pa指向的链表即为两个多项式之和。
5.实验程序代码及运行结果：#include"stdafx.h"#include<stdio.h>#include<stdlib.h>#include<malloc.h>#include<stdio.h>#define NULL 0typedef struct NODE{float coef; //系¦Ì数ºyint expn; //指?数ºystruct NODE *next;}NODE;NODE *Creat(int n);void print(NODE *head);NODE *AddPolyn(NODE *head1, NODE *head2);NODE *Delfirst(NODE *head, NODE *q);void InsertBefore(NODE *p1, NODE *p2);int compare(int a, int b);/*创ä¡ä建¡§链¢¡ä表À¨ª*/NODE *Creat(int n){NODE *current, *previous, *head;int i;head = (NODE *)malloc(sizeof(NODE)); /*创ä¡ä建¡§头ª¡¤结¨¢点Ì?*/previous = head;for(i = 0; i < n; i++){current = (NODE *)malloc(sizeof(NODE));printf("请?输º?入¨?系¦Ì数ºy和¨ª指?数ºy : ");scanf("%f%d", ¤t->coef, ¤t->expn);previous->next = current;previous = current;}previous->next = NULL;return head;}/*一°?元a多¨¤项?式º?的Ì?想?加¨®，ê?总Á¨¹体¬?考?虑?，ê?可¨¦分¤?qa的Ì?指?数ºy比À¨¨qb小?，ê?或¨°等̨¨于®¨²pb(如¨?果?系¦Ì数ºy相¨¤加¨®等̨¨于®¨²0和¨ª不?等̨¨于®¨²0),或¨°大䨮于®¨²pb里¤?面?由®¨¦InsertBefore和¨ªDelfirst两¢?个?小?模¡ê块¨¦组Á¨¦成¨¦一°?部?分¤?*/ NODE *AddPolyn(NODE *head1, NODE *head2){NODE *ha, *hb, *qa, *qb;int a, b;float sum;ha = head1; /*ha和¨ªhb指?向¨°头ª¡¤结¨¢点Ì?*/hb = head2;qa = ha->next; /*qa和¨ªqb指?向¨°头ª¡¤结¨¢点Ì?的Ì?下?一°?个?结¨¢点Ì?*/qb = hb->next;while(qa && qb) /*qa和¨ªqb均¨´非¤?空?*/{a = qa->expn;b = qb->expn;switch(compare(a, b)) {case -1 : /*qa->expn < qb->expn*/ha = qa;qa = qa->next;break;case 0 :sum = qa->coef + qb->coef; /*系¦Ì数ºy的Ì?和¨ª*/if(sum != 0.0) { /*如¨?果?不?是º?0.0*/qa->coef = sum; /*改?变À?系¦Ì数ºy*/ha = qa;}else{free(Delfirst(ha, qa));}free(Delfirst(hb, qb));qa = ha->next;qb = hb->next; /*qb释º¨ª放¤?后¨®要°a重?新?赋3值¦Ì*/ break;case 1 : /*如¨?果?qa-> expn > qb -> expn*/Delfirst(hb, qb);InsertBefore(ha, qb); /*把ã?qb插?入¨?到Ì?ha下?一°?个?结¨¢点Ì?之?前¡ã*/qb = hb->next;ha = ha->next;break;}}if(qb)ha->next = qb; /*插?入¨?剩º¡ê余®¨¤的Ì?pb*/free(head2);return head1;}/*比À¨¨较?*/int compare(int a, int b){if(a < b)return -1;else if(a > b)return 1;elsereturn 0;}/*删¦?除y结¨¢点Ì?q*/NODE *Delfirst(NODE *p1, NODE *q){p1 -> next = q -> next;return (q);}/*插?入¨?结¨¢点Ì?,引°y入¨?结¨¢点Ì?p,可¨¦以°?让¨?p插?入¨?到Ì?p2和¨ªp1之?间?*/ void InsertBefore(NODE *p1, NODE *p2){NODE *p;p = p1->next;p1->next = p2;p2->next = p;}/*打䨰印®?,为a了¢?美¨¤观?程¨¬序¨°分¤?开a打䨰印®?*/void print(NODE *head){NODE *current;current = head->next;while(current->next != NULL){printf("%0.f * x^%d + ", current->coef, current->expn);current = current -> next;}printf("%0.f * x^%d", current->coef, current->expn);//system（ꡧ"pause");}int main(){NODE *head1, *head2, *head3;int n1, n2;printf("请?输º?入¨?你?需¨¨要°a的Ì?多¨¤项?式º?的Ì?项?数ºy n1 : "); scanf("%d", &n1);head1 = Creat(n1);printf("第̨²一°?个?多¨¤项?式º?的Ì?显?示º? : \n");print(head1);printf("\n请?输º?入¨?你?需¨¨要°a的Ì?多¨¤项?式º?的Ì?项?数ºy n2 : "); scanf("%d", &n2);head2 = Creat(n2);printf("\n第̨²二t个?多¨¤项?式º?的Ì?显?示º? : \n");print(head2);head3 = AddPolyn(head1, head2);printf("\n合?并¡é后¨®的Ì?多¨¤项?式º?的Ì?显?示º? : \n");print(head3);printf("\n");}运行结果：实验数据1如图：输入一个四次二项式X^3+2X^4，一个五次二项式X^4+2X^5，输出如图：实验数据2如图：输入一个五次四项式X^2+X^3+X^4+X^5，还有一个五次五项式1+X+X^3+2X^4+2X^5输出如图所示实验数据3如图：输入一个七次三项式1+2x^5+3X^7，还有一个五次四项式1+2X^2+3X^4+4X^5,输出如图：6.实验总结本来我对编程很没有信心，做这样一个课程设计感觉有点吃力，虽然有些人觉得很简单，但是我还是坚持做下来了，我不断的看书，翻阅资料，询问同学，上网搜索，总算有模有样地把这个程序编的能运行了。
c语言数据结构实现——一元多项式的基本运算
c语言数据结构实现——一元多项式的基本运算在C语言中，一元多项式的表示与运算是常见的数据结构操作之一。
一元多项式由一系列具有相同变量的单项式组成，每个单项式由系数和指数组成。
本文将介绍如何使用C语言实现一元多项式的基本运算，包括多项式的创建、求和、差、乘积等操作。
首先，我们需要定义一个结构体来表示单项式。
每个单项式由一个系数和一个指数组成，我们可以将其定义如下：```cstruct term{float coefficient; // 系数int exponent; // 指数};typedef struct term Term;```接下来，我们可以定义一个结构体来表示一元多项式。
一元多项式由一系列单项式组成，可以使用一个动态数组来存储这些单项式。
```cstruct polynomial{Term* terms; // 单项式数组int num_terms; // 单项式数量};typedef struct polynomial Polynomial;```现在，我们可以开始实现一元多项式的基本运算了。
1. 创建一元多项式要创建一元多项式，我们需要输入每个单项式的系数和指数。
我们可以使用动态内存分配来创建一个适应输入的单项式数组。
```cPolynomial create_polynomial(){Polynomial poly;printf("请输入多项式的项数：");scanf("%d", &poly.num_terms);poly.terms = (Term*)malloc(poly.num_terms * sizeof(Term));for(int i = 0; i < poly.num_terms; i++){printf("请输入第%d个单项式的系数和指数：", i+1);scanf("%f %d", &poly.terms[i].coefficient, &poly.terms[i].exponent);}return poly;}```2. 求两个一元多项式的和两个一元多项式的和等于对应指数相同的单项式系数相加的结果。
2.4 一元多项式的表示和相加
2.4 一元多项式的表示和相加一元多项式：P n（x）=p0+p1x+p2x2+ …+p n x n在计算机中，可以用一个线性表来表示：P = （p0， p1，…，p n）但是对于形如 S（x） = 1 + 3x10000– 2x20000 的多项式，上述表示方法是否合适？一般情况下的一元稀疏多项式可写成P n(x) = p1x e1 + p2x e2+ ┄ + p m x em其中：p i是指数为e i的项的非零系数，0≤ e1 < e2< ┄ < e m = n可以下列线性表表示：（（p1, e1）, (p2, e2), …, (p m,e m) ）例如:多项式P999(x) = 7x3 - 2x12 - 8x999可用线性表 ( （7, 3）, （-2, 12）, （-8, 999））) 表示抽象数据类型一元多项式的定义如下：ADT Polynomial {数据对象：D＝{ a i | a i∈TermSet, i=1,2,...,m, m≥0TermSet 中的每个元素包含一个表示系数的实数和表示指数的整数 } 数据关系：R1＝{ <a i-1 ,a i >|a i-1，a i∈D， i=2,...,n且a i-1中的指数值＜a i中的指数值 }基本操作：多项式的有关操作} ADT Polynomial一元多项式的实现：typedef OrderedLinkList polynomial； // 用带表头结点的有序链表表示多项式结点的数据元素类型定义为：typedef struct { // 项的表示float coef； // 系数int expn； // 指数} term, ElemType；void CreatPolyn (polynomail &p, int m); {//输入m项的系数和指数，建立表示一元多项式的有序链表P InitList (P)； h = GetHead (P)；e.coef = 0.0； e.expn = -1； SetCurElem (h, e)；//设置头结点的数据元素for ( i=1; i<=m; ++i) { //依次输入m个非零项scanf (e.coef, e.expn)；if (!LocateElem (P, e, q,(* cmp)())) {//当前链表中不存在该指数项 if (MakeNode (s, e)) InsFirst (q, s)；//生成结点并插入链表}}}//CreatPolyn算法：2.22void AddPolyn (polynomial &Pa, polynomial &Pb) { // 多项式加法：Pc = Pa＋Pb，利用两个多项式的结//点构成“和多项式”ha = GetHead (La)； hb = GetHead (Lb)；//ha和hb分别指向La和Lb的头结点pa = NextPos ( La, ha)； pb = NextPos ( Lb, hb)； //pa和pb分别指向La和Lb中当前结点while ( pa && pb ){ // La和Lb均非空a = GetCurElem ( pa )；b = GetCurElem ( pb )； //a和b为两表中当前比较元素switch (*cmp(e1, e2)) {case -1：{ // 多项式PA中当前结点的指数值小ha=qa； qa = NextPos ( Pa, qa)； break；case 0： { // 两者的指数值相等sum= a.coef + b.coef ;if ( sum != 0.0 ) {//修改多项式PA中当前结点的系数值 SetCurElem (qa, sum)； ha=qa；}else { //删除多项式PA中当前结点DelFirst (ha, qa)； FreeNode (qa)；}DelFirst(hb, qb)； FreeNode(qb)；qb=NextPos ( Pb, qb)； qa = NextPos ( Pa, qa)； break；case 1: { //多项式PB中当前结点的指数值小 DelFirst (hb, qb)； InsFirst (ha, qb)；qb =NextPos ( Pb, qb)；ha = NextPos ( Pa, qa)；break； }//switch}//whileif (!ListEmpty (Pb)) Append (Pa, qb)；//链接Pb中剩余结点 FreeNode (hb)； // 释放Pb的头结点} // AddPolyn算法：2.23本章小结1、了解线性表的逻辑结构特性，以及线性表的顺序存储结构和链式存储结构。
一元多项式表示与相加
系数 coef 指数 exp 指针 next
结点结构体定义如下： struct Polynode { int coef; int exp; Polynode *next; } Polynode , * Polylist;
例：建立一元多项式链式存储算法 【算法思想】通过键盘输入一组多项式的系数和指数，用尾插法建立一元 多项式的链表。以输入系数 0 为结束标志，并约定建立多项式链表时，总 是按指数从小到大的顺序排列。 【算法描述】
scanf(“%d,%d”,&c,&e);/*键入多项式的系数和指数项*/
while(c!=0)
/*若 c=0，则代表多项式的输入结束*/
{
s=(Polynode*)malloc(sizeof(Polynode)); /* 申 请 新
的结点*/
s->coef=c ;
s->exp=e ;
rear->next=s ;
① 若 p->exp< q->exp，则结点 p 所指的结点应是“和多项式”中的 一项，令指针 p 后移；
② 若 p->exp=q->exp，则将两个结点中的系数相加，当和不为零时 修改结点 p 的系数域，释放 q 结点；若和为零，则和多项式中无此项，从 A 中 删去 p 结点，同时释放 p 和 q 结点。
B(x)=8x+22x7-9x8
polya
-1
polyb
-1
70 81
31
98
5 17 ∧
22 7
-9 8 ∧
（2）多项式相加的运算规则 为了保证“和多项式”中各项仍按升幂排列，在两个多项式中： ①指数相同项的对应系数相加，若和不为零，则构成“和多项式”中的一 项； ②指数不相同的项仍按升幂顺序复抄到“和多项式”中。 【算法思想】以单链表 polya 和 polyb 分别表示两个一元多项式 A 和 B， A+B 的求和运算，就等同于单链表的插入问题（将单链表 polyb 中的结点插入 到单链表 polya 中），因此 “和多项式“中的结点无需另生成。 为实现处理，设 p、q 分别指向单链表 polya 和 polyb 的当前项，比较 p、q 结点的指数项，由此得到下列运算规则：
一元多项式相加
⼀元多项式相加描述：对于两个⼀元多项式，如果需要对他们进⾏多项式相加操作，常见的两种思路如下：(1)对于⼀个多项式，保存其最⾼项次数HighPowder，以及⼀个该多项式对应次数分别为0-HighPowder的各项的系数的数组()。
(2)多项式中系数不为零的每⼀项，保存其系数与该项的次数。
下⾯分别⽤这两种思路实现⼀元多项式加法操作。
思路⼀（数组实现）：数据结构定义：1 typedef struct Poly2 {3int CoeffArray[11];4int HighPower;5 } *Polynomial;实现：1 #include <stdio.h>2 #include <stdlib.h>34 typedef struct Poly5 {6int CoeffArray[11];7int HighPower;8 } *Polynomial;910void ZeroPolynomial(Polynomial Poly)11 {12int i;13for(i = 0; i < 11; i++)14 {15 Poly->CoeffArray[i] = 0;16 }17 Poly->HighPower = 0;18 }1920void AddPolynomial(Polynomial Poly1,Polynomial Poly2, Polynomial PolySum)21 {22int i;23 ZeroPolynomial(PolySum);24 PolySum->HighPower = Poly1->HighPower > Poly2->HighPower?25 Poly1->HighPower:Poly2->HighPower;26for(i = PolySum->HighPower; i >= 0 ; i--)27 {28 PolySum->CoeffArray[i] = Poly1->CoeffArray[i] + Poly2->CoeffArray[i];29 }30 }3132int main(void)33 {34int i,j,k;35 Polynomial P1,P2,Sum;36 P1 = malloc(sizeof(struct Poly));37 P2 = malloc(sizeof(struct Poly));38 Sum = malloc(sizeof(struct Poly));39//初始化40 ZeroPolynomial(P1);41 ZeroPolynomial(P2);42 P1->HighPower = 10;43for(i = 10; i >= 0; i--)44 {45 P1->CoeffArray[i] = i;46 }4748 P2->HighPower = 8;49for(j = 8; j >=0; j--)50 {51 P2->CoeffArray[j] = j;52 }53 P2->CoeffArray[8] = 8;54 AddPolynomial(P1,P2,Sum);5556 printf("The high power of the Polynomial is %d\n",Sum->HighPower); 57for(k = 0; k <= 10; k++)58 {59 printf("The Coeff of power %d is %d\n",k,Sum->CoeffArray[k]);60 }6162return0;63 }它适合⼤部分项都有的稠密多项式。
一元多项式相加 数据结构实验报告
南昌航空大学实验报告课程名称：数据结构实验名称：实验二线性表的链式存储结构班级：080611 学生姓名：学号：08指导教师评定：签名:题目：设计并实现以下算法：给出用单链表存储多项式的结构，利用后接法生成多项式的单链表结构，实现两个多项式相加的运算，并就地逆置相加后的多项式链式。
一、需求分析1.用户可以根据自己的需求分别输入两个一元多项式，并且能够实现输入的一元多项式的显示。
2.能够完成两个一元多项式的相加功能，而且还能显示相加后的逆置的一元多项式。
3.程序执行的命令包括：（1）构造链表A （2）构造链表B （3）两个链表的相加（4）求链表的长度（5）打印（显示）已有的链表（6）将已相加的链表进行逆序排列二、概要设计⒈为实现上述算法，需要线性表的抽象数据类型：ADT Polynomial {数据对象：D={a i:|a i∈TermSet,i=1…n,n≥0TermSet 中的每个元素包含一个表示系数的实数和表示指数的整数} 数据关系：R1={<a i-1,a i>|a i-1,a i∈D,且a i-1中的指数值< a i中的指数值i=2,…n≥0}基本操作:initlink(& L)操作结果：构造一个空的链表L。
Creatlink(&L,n)操作结果：输入n项的系数和指数，建立一个非空的一元多项式L。
LinkLength(L)初始条件：链表L已经存在。
操作结果：返回一元多项式L中的项数。
Displaylink（L）初始条件：链表L已经存在。
操作结果：打印输出一元多项式L。
Addpolyn(A,B,&C)初始条件：一元多项式A和B已存在。
操作结果：完成多项式相加运算，即：C=A+B，并且带回C。
subtracypolyn(&La,&Lb,)初始条件：一元多项式La和Lb已存在。
操作结果：完成多项式的相减运算La=La+Lb，并且销毁多项式Lb。
一元多项式的相加减
实验一一元多项式的表示和相减、相乘一、实验目的1.掌握链表的存储方式2.掌握一元多项式的存储及运算。
二、实验内容已知一元多项式P(x)和Q(x)已存在，求P(x)-Q(x)和P(x)* Q(x)并输出。
要求：1.通过键盘随机输入两多项式P(x)和Q(x)的内容。
2.输出结果要有P(x)和Q(x)的以及它们的差P(x)-Q(x)和乘积P(x)* Q(x)。
三、实验步骤：1.创建一元多项P(x)和Q(x)。
2.求P(x)-Q(x)，P(x)* Q(x)。
3.输出P(x)、Q(x)、P(x)-Q(x)，P(x)* Q(x)。
四、算法说明首先，定义一元多项式的存储方式，然后从键盘输入P(x)和Q(x)对应多项式的各对系数和指数，建立相应的一元多项式五、测试结果参考下图多项式相减多项式相乘六、源代码1.多项式的相减# include<stdio.h># include<malloc.h>typedef struct{float coef; //系数int expn; //指数}ElemType;typedef struct LNode{ //结点类型ElemType data;struct LNode *next;}*LinkList;void MakeNode(LinkList &s,ElemType e){ //生成结点s=(LinkList)malloc(sizeof(LNode));s->data=e;}void InsAfter(LinkList p,LinkList s){//插入结点s->next=p->next;p->next=s;}int compare(ElemType e1,ElemType e2){//比较if(e1.expn>e2.expn)return 1;else if(e1.expn<e2.expn)return -1;return 0;}void OrderInsert(LinkList &L,ElemType e,int(*compare)(ElemType,ElemType)){//有序插入LinkList p=L,q=p->next,s;while(q){int n=compare(e,q->data);if(n<0){MakeNode(s,e);InsAfter(p,s);break;}else if(n==0){q->data.coef=q->data.coef+e.coef;if(q->data.coef==0){p->next=q->next;free(q);} break;}p=p->next;q=p->next;}if(q==NULL){MakeNode(s,e);InsAfter(p,s); //最大，放在最后一个位置}}void InitList(LinkList &L){//初始化L=(LinkList)malloc(sizeof(LNode));L->next=NULL;}void SetCurElem(LinkList &p,ElemType e){ //设置结点p->data.coef=e.coef;p->data.expn=e.expn;}void CreatePolyn(LinkList &L,int m){InitList(L);ElemType e;e.coef=0.0;e.expn=-1;SetCurElem(L,e);//设置头结点的数据元素printf("请输入%d对多项式的值：\n",m);for(int i=1;i<=m;i++){scanf("%f%d",&e.coef,&e.expn); //输入值OrderInsert(L,e,compare);}}void show(LinkList L){//输出方法LinkList p=L->next;if(p){ //第一个输出printf("%.2fX^%d",p->data.coef,p->data.expn); p=p->next;}while(p){if(p->data.coef>0)printf("+");printf("%.2fX^%d",p->data.coef,p->data.expn); p=p->next;}printf("\n");}void ListDestroy(LinkList &L){//销毁LinkList p=L,q;while(p){q=p;p=p->next;free(q);}}void subtract(LinkList L1,LinkList L2,LinkList &L3){//多项式相减ElemType e;InitList(L3);e.coef=0.0;e.expn=-1;SetCurElem(L3,e);//设置头结点的数据元素LinkList p1=L1->next,p2=L2->next,q;//r1始终指向新建链表的尾部,p1和p2表示当前结点while(p2){p2->data.coef=-p2->data.coef;p2=p2->next;}p2=L2->next;while(p1&&p2){int n=compare(p1->data,p2->data);switch(n){case -1:{OrderInsert(L3,p1->data,compare);p1=p1->next;break;} //L1中的值小，插入之case 1:{OrderInsert(L3,p2->data,compare);p2=p2->next;break;} //L2中的值小，插入之case 0:{ //相同e.coef=p1->data.coef+p2->data.coef;e.expn=p1->data.expn;if(e.coef!=0){OrderInsert(L3,e,compare);}p1=p1->next;p2=p2->next;break;}}}if(p1){OrderInsert(L3,p1->data,compare);p1=p1->next;} //添加L1else if(p2){OrderInsert(L3,p2->data,compare);p2=p2->next;} //添加L2 }LinkList FindThan( LinkList X, LinkList L ){LinkList Tmp;Tmp = L;while( Tmp->next != NULL && Tmp->next->data.expn >= X->data.expn ) {Tmp = Tmp->next;}return Tmp;}int main(){LinkList L1,L2,L3,L4;int m,n;printf("请输入多项式P(X)的项数：");scanf("%d",&m);CreatePolyn(L1,m);printf("多项式P(X)为：\n");show(L1);printf("请输入多项式Q(X)的项数：");scanf("%d",&n);CreatePolyn(L2,n);printf("多项式Q(X)为：\n");show(L2);subtract(L1,L2,L3);printf("多项式P(X)-Q(X)为：\n");show(L3);return 0;}2.多项式的相乘# include<stdio.h># include<malloc.h>typedef struct{float coef; //系数int expn; //指数}ElemType;typedef struct LNode{ //结点类型ElemType data;struct LNode *next;}*LinkList;void MakeNode(LinkList &s,ElemType e){//生成结点s=(LinkList)malloc(sizeof(LNode));s->data=e;}void InsAfter(LinkList p,LinkList s){//插入结点s->next=p->next;p->next=s;}int compare(ElemType e1,ElemType e2){//比较if(e1.expn>e2.expn)return 1;else if(e1.expn<e2.expn)return -1;return 0;}void OrderInsert(LinkList &L,ElemType e,int(*compare)(ElemType,ElemType)){//有序插入LinkList p=L,q=p->next,s;while(q){int n=compare(e,q->data);if(n<0){MakeNode(s,e);InsAfter(p,s);break;}else if(n==0){q->data.coef=q->data.coef+e.coef;if(q->data.coef==0){p->next=q->next;free(q);} break;}p=p->next;q=p->next;}if(q==NULL){MakeNode(s,e);InsAfter(p,s); //最大，放在最后一个位置}}void InitList(LinkList &L){//初始化L=(LinkList)malloc(sizeof(LNode));L->next=NULL;}void SetCurElem(LinkList &p,ElemType e){ //设置结点p->data.coef=e.coef;p->data.expn=e.expn;void CreatePolyn(LinkList &L,int m){InitList(L);ElemType e;e.coef=0.0;e.expn=-1;SetCurElem(L,e);//设置头结点的数据元素printf("请输入%d对多项式的值：\n",m);for(int i=1;i<=m;i++){scanf("%f%d",&e.coef,&e.expn); //输入值OrderInsert(L,e,compare);}}void show(LinkList L){//输出方法LinkList p=L->next;if(p){ //第一个输出printf("%.2fX^%d",p->data.coef,p->data.expn); p=p->next;}while(p){if(p->data.coef>0)printf("+");printf("%.2fX^%d",p->data.coef,p->data.expn); p=p->next;}printf("\n");}void ListDestroy(LinkList &L){//销毁LinkList p=L,q;while(p){q=p;p=p->next;free(q);}}void Multiply(LinkList L1,LinkList L2,LinkList &L3){//多项式相乘ElemType e;InitList(L3);e.coef=0.0;e.expn=-1;SetCurElem(L3,e);//设置头结点的数据元素LinkList p1=L1->next,p2=L2->next,q;//r1始终指向新建链表的尾部,p1和p2表示当前结点while(p1){p2=L2->next;while(p2){e.coef=p1->data.coef*p2->data.coef;e.expn=p1->data.expn+p2->data.expn;OrderInsert(L3,e,compare);p2=p2->next;}p1=p1->next;} }int main(){LinkList L1,L2,L3;int m,n;printf("请输入多项式P(X)的项数：");scanf("%d",&m);CreatePolyn(L1,m);printf("多项式P(X)为：\n");show(L1);printf("请输入多项式Q(X)的项数：");scanf("%d",&n);CreatePolyn(L2,n);printf("多项式Q(X)为：\n");show(L2);Multiply(L1,L2,L3);printf("多项式P(X)*Q(X)为：\n");show(L3);return 0;}七、分析总结本程序从源代码开始经过多次调试，一开始创建多项式并没有遇到什么问题，但是减法开始遇到问题，好在经过调试和反复检验后问题都得以解决，在多项式相加的基础上修改，相减和相乘就容易得多。
一元多项式相加的实验报告
《数据结构》实验报告1、实验名称:实现一元多项式的加法2、实验日期: 2011-3-73、基本要求：1）编程实现一元多项式的加法；2）设计一个测试主函数。
4、实验目的：通过实验使学生掌握链表的最基本和最主要的操作：插入和删除操作。
5、测试数据：随意输入两个一元多项式的系数和指数：第一个：系数：4 8 6 7；指数：2 3 4 5第二个：系数：5 9 3 8；指数：1 3 5 6两式相加后输出结果。
6、算法思想或算法步骤:1）用尾插入法创建单链表（PLoy *create_Ploy_LinkList(void)）2）输出单链表中所有结点的值，得到一元多项式（void output_Ploy_LinkList(PLoy *L, char ch)）3）进行多项式的相加，采用链式存储表示加法，根据结点类型定义，若指数不同，则进行链表的合并；若指数相同，则进行系数相加；若和为0，则去掉结点；若和不为0，则修改结点的系数域。
（PLoy *add_ploy(PLoy *La, PLoy *Lb)）7、模块划分：1）头文件stdiob.h。
头文件stdiob.h中包括：结点结构体定义、一元多项式的系数和指数的输入、一元多项式的输出以及两式相加输出结果的操作等；2）实现文件yydxsxj.cpp。
包含主函数int main()，其功能是测试所设计的一元多项式加法的正确性。
8、数据结构：链表中的结点的结构体定义如下：typedef struct Node{float coef; /*系数部分*/int expn; /*指数部分*/struct Node *next ;} PloyNode;9、源程序：源程序存放在两个文件中，即头文件stdiob.h和实现文件yydxsxj.cpp。
//头文件stdiob.htypedef struct Node{float coef; /*系数部分*/int expn; /*指数部分*/struct Node *next ;} PloyNode;PloyNode *create_Ploy_LinkList(void){/* 尾插入法创建单链表,链表的头结点head作为返回值 */ float coef ; int expn ;PloyNode *head, *p, *q;head=p=(PloyNode *)malloc(sizeof(PloyNode));p->next=NULL; /* 创建单链表的表头结点head */while (1){printf("\n请输入一元多项式的系数(0表示结束): ") ;scanf("%f",&coef);if (coef==0) break ;else{printf("\n请输入一元多项式的指数: ") ;scanf("%d",&expn);q=(PloyNode *)malloc(sizeof(PloyNode));q->coef=coef ; /* 指数部分赋值 */q->expn=expn ; /* 系数部分赋值 */q->next=p->next; p->next=q; p=q ;/* 钩链，新创建的结点总是作为最后一个结点 */ }}return(head);}void output_Ploy_LinkList(PloyNode *L, char ch)/* 输出以L为头结点的单链表中所有结点的值 */ {PloyNode *p;p=L->next; /* 使p指向第一个结点 */if (p==NULL) printf("\n此多项式为空!!\n\n") ;else{printf("f(x)= \n",ch) ;while (p!=NULL){if (p->coef>0)printf("%+g",p->coef) ;else printf("%g",p->coef) ;if (p->expn!=0){printf("X^") ;printf("%d",p->expn);}p=p->next;}} /* 移动指针p */printf("\n\n") ;}PloyNode *add_Ploy(PloyNode *La, PloyNode *Lb){PloyNode *Lc , *pc , *pa , *pb ,*ptr ; float x ;Lc=pc=La ; pa=La->next ; pb=Lb->next ;if(pa==NULL&&pb==NULL)printf("两个式子之和也为空项");while (pa!=NULL&&pb!=NULL){if (pa->expn< pb->expn){pc->next=pa ; pc=pa ; pa=pa->next ; } else{if (pa->expn>pb->expn){ pc->next=pb ; pc=pb ; pb=pb->next ; }else{x=pa->coef+pb->coef ;if (x==0){ ptr=pa ; pa=pa->next ;ptr=pb ; pb=pb->next ;}else{ pc->next=pa ; pa->coef=x ;pc=pa ; pa=pa->next ;ptr=pb ; pb=pb->next ;}}}}if (pa==NULL) pc->next=pb ;else pc->next=pa ;return (Lc) ;}//实现文件yydxsxj.cpp#include<iostream>#include<malloc.h>#include"stdiob.h"using namespace std;int main(){PloyNode * pa,* pb;char pc,pd;cout<<"请输入第一个多项式(按指数递增顺序输入):"<<endl; pa=create_Ploy_LinkList();output_Ploy_LinkList(pa,pc);cout<<"请输入第二个多项式(按指数递增顺序输入):"<<endl; pb=create_Ploy_LinkList();output_Ploy_LinkList(pb,pd);cout<<"多项式相加结果是:"<<endl;add_Ploy(pa,pb);output_Ploy_LinkList(pa,pc);return 0;}10、测试情况：1）程序运行输出为：第一个多项式为：f(x)=+4x^2+8x^3+6x^4+7x^5第二个多项式为：f(x)=+5x^1+9x^3+3x^5+8x^6两式相加之和为：f(x)=+5x^1+4x^2+17x^3+6x^410x^5+8x^6 2）测试结果分析：程序运行结果和预测的完全相同，说明所设计的一元多项式的加法是正确的。
数据结构一元多项式的相加
B(x) 8x 22x7 9x8
C(x) A(x) B(x) 7 11x 22x7 5x17
A
-1
70
31
98
5 17 ^
B
-1
81
22 7 -9 8 ^
C
-1
70
11 1 22 7
5 17 ^
运算规则
设p,q分别指向A,B中某一结点，p,q初值是第一结点
p->exp < q->exp: p结点是结果多项式
•重点：线性表的顺序存储； 线性表的链式存储； 顺序表的插入、删除 单链表的插入、删除
•难点：双向链表的系列操作 线性表的应用。
if(x!=0){ p->coef=x; pre=p;} else { pre->next=p->next; free(p);}
p=pre->next; u=q; q=q->next; free(u); } else { u=q->next;q->next=p;pre->next=q;
pre=q; q=u; } } if(q!=NULL) pre->next=q; free(pb); }
算法描述
pre
p pre
p pre
pp
p
ppaa
--11
77 00
31111 111
99 88
55 1177 ^^
ppbb
--11
88 11
2222 77
--99 88 ^^ q=NULL
q
prqe
q
pa
-1
70
11 1
22 7
5 17 ^
Ch2_7.c
算法与数据结构实验一元多项式求和
《算法与数据结构》实验报告姓名：***班级：计科01学号：**********实验题目：链表的应用实验内容：一元多项式求和把任意给定的两个一元多项式P(x),Q(x)输入计算机，计算它们的和并输出计算结果。
设计分析：一元多项式可以用单链表表示，结点结构图示如下：Array一元多项式链表的结点结构一元多项式算法伪代码如下：源程序代码：#include"StdAfx.h"#include<stdlib.h>typedef struct LNode{int x,z;struct LNode *next;}LinkList;void OutLinkList(LinkList *L);void PutLinkList(LinkList *&L,int n);LinkList *AddLinkList(LinkList *a,LinkList *b);void OutXLinkList(LinkList *L);void OutZLinkList(LinkList *L);void main(){int n,m;LinkList *a,*b,*c;printf("\t\t\t本À?程¨¬序¨°可¨¦以°?完ª¨º成¨¦两¢?个?一°?元a多¨¤项?式º?的Ì?加¨®法¤¡§运?算?。
¡ê\n");printf("请?输º?入¨?一°?元a多¨¤项?式º?a的Ì?项?数ºym：êo");scanf("%d",&m);printf("请?按ã¡ä照?从䨮低̨ª次ä?到Ì?高?次ä?的Ì?顺3序¨°依°¨¤此ä?输º?入¨?一°?元a多¨¤项?式º?a的Ì?系¦Ì数ºy和¨ª指?数ºy：êo\n");PutLinkList(a,m);printf("a=");OutLinkList(a);printf("请?输º?入¨?一°?元a多¨¤项?式º?b的Ì?项?数ºyn：êo");scanf("%d",&n);printf("请?按ã¡ä照?从䨮低̨ª次ä?到Ì?高?次ä?的Ì?顺3序¨°依°¨¤此ä?输º?入¨?一°?元a多¨¤项?式º?b的Ì?系¦Ì数ºy和¨ª指?数ºy：êo\n");PutLinkList(b,n);printf("b=");OutLinkList(b);c=AddLinkList(a,b);printf("两¢?个?多¨¤项?式º?的Ì?和¨ª为a：êo\na+b=");OutLinkList(c);}void PutLinkList(LinkList *&L,int n){LinkList *s,*r;L=(LinkList *)malloc(sizeof(LinkList));r=L;for(int i=0;i<n;i++){s=(LinkList *)malloc(sizeof(LinkList));printf("请?输º?入¨?第̨²%d项?的Ì?系¦Ì数ºy：êo",i+1);scanf("%d",&s->x);printf("请?输º?入¨?第̨²%d项?的Ì?指?数ºy：êo",i+1);scanf("%d",&s->z);r->next=s;r=s;}r->next=NULL;}void OutLinkList(LinkList *L) {char FuHao;LinkList *p=L->next;FuHao=p->x>0? '+':'-';if(FuHao=='-'){printf("%c",FuHao);if(p->x==-1)printf("1");}OutXLinkList(p);OutZLinkList(p);p=p->next;while(p!=NULL){FuHao=p->x>0? '+':'-';printf("%c",FuHao);OutXLinkList(p);OutZLinkList(p);p=p->next;}printf("\n");}void OutXLinkList(LinkList *L) {int xi=L->x>0? L->x:-L->x;if(L->x==1||L->x==-1);elseprintf("%d",xi);}void OutZLinkList(LinkList *L) {if(L->z==0);else if(L->z==1||L->z==-1){if(L->z<0){if(L->x==1||L->x==-1)printf("1");printf("/");}printf("X");}else{if(L->z<0)printf("/");int zhi=L->z>0? L->z:-L->z;printf("X^%d",zhi);}}LinkList *AddLinkList(LinkList *a,LinkList *b){a=a->next;b=b->next;LinkList *c,*d,*s;c=(LinkList *)malloc(sizeof(LinkList));d=c;while(a!=NULL&&b!=NULL){if(a->z<b->z){s=(LinkList *)malloc(sizeof(LinkList));s->x=b->x;s->z=b->z;d->next=s;d=s;b=b->next;}else if(a->z>b->z){s=(LinkList *)malloc(sizeof(LinkList));s->x=a->x;s->z=a->z;d->next=s;d=s;a=a->next;}else{s=(LinkList *)malloc(sizeof(LinkList));s->x=a->x+b->x;s->z=a->z;if(s->x==0);else{d->next=s;d=s;}a=a->next;b=b->next;}}if(a!=NULL)d->next=a;else if(b!=NULL)d->next=b;elsed->next=NULL;return c;}测试用例：当a=3x^8-x^5+2x^3+7x^2+5x,b=5x^5+3x^4-7x^2-3x^(-3)时，运行结果如下：试验总结：通过本次试验，学会了链表的应用，加深了对链表的理解，知道了链表是把线性表中的元素按照链式储存方式到计算机中的一片连续的储存空间中。
一元多项式相加问题
一元多项式运算一、需求分析1．程序的功能一元稀疏多项式简单计算器的基本功能包括：1．按照指数升序次序，输入并建立多项式A与B，2．计算多项式A与B的和，即建立多项式A+B，3．按照指数升序次序，输出多项式A、B、A+B。
2．输入输出的要求输入要求：按照指数递增的顺序和一定的输入格式输入各个系数不为0的子项：“系数、指数对”。
输出要求：可以在文本界面下，采用类似于数学表达式的方式输出多项式，如多项式A 可显示为：A=3+6X∧3-2X∧8+12X∧20。
需要注意：1.系数值为1的非零次项的输出形式中略去系数1，如子项1x8的输出形式为x8，项－1x3的输出形式为－x3；2.多项式的第一项的系数符号为正时，不输出“+”，其它项要输出“+”、“-”符号。
3．测试数据1．(x+3x6－8.6x11)+(6－3x6+21x9)=6+x+21x9－8.6x112．(3x－3－x+4.1x2－1.2x9)＋(―3x―3－5.1x2 +7.8x12)=－x－x2－1.2x9+7.8x123．(x+x3)+(―x―x3)=04．(x+x100)+(x100+x200)=(x+2x100+x200)5．(x+x2+x3)+0=x+x2+x3二、概要设计1．本程序所用的抽象数据类型的定义一元n次多项式：P(x,n)=P0+P1X1+P2X2+…+P n X n，其每一个子项都是由“系数”和“指数”两部分来组成的，因此可以将它抽象成一个由“系数、指数对”构成的线性表，其中，多项式的每一项都对应于线性表中的一个数据元素。
由于对多项式中系数为0的子项可以不记录它的指数值，对于这样的情况就不再付出存储空间来存放它了；基于此，可以采用一个带有头结点的单链表来表示一个一元多项式。
2．主模块的流程及各子模块的主要功能主模块的主要流程如下：（1）输入多项式，建立多项式链表；（2）多项式相加，进行多项式的相加工作；（3）完成多项式的输出；3．模块之间的层次关系该模块的层次关系如下：首先建立两个多项式，并将其储存，接下来调用多项式的加法函数对其进行相加的操作，最后，在屏幕上显示多项式相加的结果。
一元多项式的求和
一元多项式的求和一元多项式的求和是数学中的一个重要概念，它涉及到对多个项的系数进行加法运算，从而得到一个结果。
在代数学中，一元多项式是由一个变量和它的各次幂所组成的表达式。
求和则是将多个项相加的过程。
本文将围绕一元多项式的求和展开讨论，介绍求和的基本概念、求和的性质以及求和的应用。
一、求和的基本概念在数学中，求和是将一系列数值按照一定规则相加的运算。
对于一元多项式的求和，我们需要先了解一元多项式的基本结构。
一元多项式由一个变量和它的各次幂所组成，例如：2x^2 + 3x + 1。
其中，2、3、1是各项的系数，x^2、x、1是各项的幂次。
一元多项式的求和就是将这些项的系数相加得到的结果。
二、求和的性质求和具有以下几个重要的性质：1. 求和是可交换的：对于任意两个多项式f(x)和g(x)，有f(x)+g(x)=g(x)+f(x)。
这意味着求和的顺序可以改变，不影响最终的结果。
2. 求和是可结合的：对于任意三个多项式f(x)、g(x)和h(x)，有(f(x)+g(x))+h(x)=f(x)+(g(x)+h(x))。
这意味着多个多项式相加时，可以先将前两个多项式相加，再与第三个多项式相加，结果是一样的。
3. 求和的零元素：对于任意一个多项式f(x)，存在一个称为零多项式的多项式0(x)，使得f(x)+0(x)=f(x)。
这意味着将零多项式与任意多项式相加，结果仍然是原来的多项式。
三、求和的应用求和在数学中有着广泛的应用，尤其在代数学、概率论、统计学等领域具有重要作用。
下面以几个具体的例子来说明求和的应用：1. 等差数列求和：对于一个等差数列a，其通项公式为an=a1+(n-1)d，其中a1为首项，d为公差，n为项数。
等差数列的求和公式为Sn=(a1+an)n/2，其中Sn为前n项的和。
通过等差数列的求和公式，我们可以方便地计算出一个等差数列的和。
2. 等比数列求和：对于一个等比数列b，其通项公式为bn=b1*q^(n-1)，其中b1为首项，q为公比，n为项数。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
一元多项式求和——链表编程一．实验名称：一元多项式求和——链表编程。
二．实验环境：Windows Xp ,Vc++6.0。
三．实验目的：1.掌握一元多项式的链表式存储算法；2.掌握链表的结构定义；3.采用尾插法生成单链表。
四．实验内容：1.一元多项式的表示：一元多项式可按升幂的形式表示为12012()n e e e n n P x p p x p x p x =++++……其中：i e 为第i 项的指数，i p 是指数i e 的项的系数，且121i n e e e e <=<=<=<=<=<=……。
则多项式()n P x 可以用一个线性表P 来表示：01(,)m P p p p =,?,；同理，多项式()n Q x 可表示为01(,,)n Q q q q =…（m<n ）。
其和多项式可表示为00111(,,,)m m m n R p q p p q q +=+++q ,?,?,q 。
2.一元多项式的链式存储：1）链式存储的结点结构：一元多项式中每一个非零项都由两部分构成——指数项和系数项。
下面为结点结构的定义：struct polynode{ int coef;int exp;polynode *next;} polynode, *polylist;2)建立一元多项式链式存储的算法：【算法思想】运用尾插法建立一元多项式的链表。
以输入系数0为结束标准，并约定建立一元多项式时，总是按指数从小到大的顺序排列。
算法如下：polylist polycreate(){ polynode *head,*rear,*s;int c,e;head=(polynode *)malloc(sizeof(polynode));rear=head;scanf("%d,%d",&c,&e);while(c!=0){ s=(polynode *)malloc(sizeof(polynode));s->codf=c;s->exp=e;rear->next=s;rear=s;scanf("%d,%d"&c,&e);}rear->next=NULL;return(head);}3.多项式相加的运算规则：【算法思想】以单链表polya和polyb分别表示两个一元多项式A和B，A+B，求和运算，就等同于单链表的插入问题。
为实现处理，设p、q分别指向单链表polya和polyb的当前项，比较它们结点的指数项，得到下列规则：1）若(p->exp)<(q->exp)，则结点p所指的结点应是“和多项式”中的一项，令指针p后移；2）若(p->exp)=(q->exp)，则将两个结点中的系数相加，当和不为0时修改结点p的系数域，释放q结点；若和为0，则多项式中无此项，从A中删去p结点，同时释放p和q结点；3）若(p->exp)>(q->exp)，则结点q所指的结点应是“和多项式”中的一项，将结点q插入在结点p之前，且令指针在原来的链表上后移。
算法如下：void polyadd(Polylist polya,Polylist polyb){Polynode *p,*q,*tail,*temp;int sum;p=polya->next;q=polyb->next;tail=polya;while(p!=NULL&&q!=NULL){ if(p->exp<q->exp){ tail->next=p;tail=p;p->next; }elseif(p->exp==q->exp){ sum=p->coef+q->coef;if(sum!=0){p->coef=sum;tail->next=p;tail=p;p=p->next;temp=q;q=q->next;free(temp); }else{ temp=p;p->next;free(temp);temp=q;q->next;free(temp); }}else{ tail->next=q;tail=q;q=q->next; }if(p!=NULL)tail->next=p;elsetail->next=q;}五．程序及其运行结果：#include<stdio.h>#include<malloc.h>#include<stdlib.h>typedef struct Polynode //定义链表节点的数据类型{int coe;int exp;struct Polynode * next;}Polynode,*Polylist;Polylist polycreate() //创建一元多项式的链表{Polynode *r,*s,*h;int c,e,i=1;r=(Polynode*)malloc(sizeof(Polynode)); //建立多项式结点h=r;printf("第%d项的系数和指数分别为:",i);scanf("%d,%d",&c,&e); i++; //键入多项式的系数和指数项while(c!=0) //若c=0,则代表多项式的输入结束{s=(Polynode *)malloc(sizeof(Polynode)); //申请新的结点s->coe=c;s->exp=e;h->next=s; //做插入h=s;printf("第%d项的系数和指数分别为:",i);scanf("%d,%d",&c,&e); i++;}h->next=NULL;return(r);}void polyadd(Polylist polya,Polylist polyb) //将两个多项式相加，然后将多项式存放在多项式polya中，并将多项式polyb删除{Polynode *p,*q,*pre,*temp;int sum;p=polya->next;q=polyb->next;pre=polya;while(p!=NULL&&q!=NULL){if(p->exp<q->exp) //如果p所指多项式项的指数小于q的,则将p结点加入到和多项式中{pre->next=p; //将p所指的结点赋给和多项式所在的链表pre=pre->next;p=p->next; //p继续指向下一个结点}else if(p->exp==q->exp)//若p和q的指数相等,则相应系数相加{sum=p->coe+q->coe; //系数相加if(sum!=0) // 若系数和非零,则系统和置入结点p,释放结点q,并将指针后移{p->coe=sum; //p所指结点的系数改为sumpre->next=p; pre=p;pre=pre->next;p=p->next;temp=q;q=q->next;free(temp); //释放结点q}else //若系数和为零,则删除结点p和q,并将指针指向下一个结点{temp=p;p=p->next;free(temp);temp=q;q=q->next;free(temp);}}else // p所指结点指数大于q 所指结点指数{pre->next=q; //将q所指结点赋给和多项式链表pre=pre->next;q=q->next; //q指向下一个结点}}if(p!=NULL) //若多项式中还有剩余,则将剩余的结点加入到和多项式中pre->next=p;else //否则,将B中的结点加入到和多项式中pre->next=q;}void print(Polylist p) //输出所有的项{while(p->next!=NULL){p=p->next;printf(" %d*x^%d+",p->coe,p->exp);}printf("\n");}main(){Polylist polya,polyb;printf("\n请输入第一个多项式各项的系数和指数,系数和指数为0表示输出完毕:\n");polya=polycreate();print(polya);printf("\n请输入第二个多项式各项的系数和指数，系数和指数0表示输出完毕:\n");polyb=polycreate();print(polyb);printf("\n两多项式的和是:\n");polyadd(polya,polyb);print(polya);printf("\n");}六．试验小结与交流：通过这次“多项式求和”实验，我熟悉并掌握了链表的建立，以及利用尾插法对初始化后的链表进行赋值操作。
但在将编好的程序在Vc6.0中运行时，常常会出错，以致不能运行出结果。
然后再回过头来认真检查程序，以期修改正确。
在该错中学习编程序的快乐。
［附带运行结果］：。