一元多项式加减乘除运算
一元多项式的定义和运算讲解
令f (x)是F [x]的一个次数大于零的多项式，并且
此处
定理 2.4.2
例 在有理数域上分解多项式 为不可约因式的乘积.容易看出
（2）
一次因式x + 1自然在有理数域上不可约.我们证明， 二次因式 也在有理数域上不可约.不然的话, 将能写成有理数域上两个次数小于2的因式 的乘积，因此将能写成
这个定义的条件也可以用另一种形式来叙述
若多项式 有一个非平凡因式 而 ，那么 与 的次数显然都小于 的次数.反之，若 能写成两个这样的多项式的乘积，那么 有非平凡因式.因此我们可以说：
这里
多项式的减法
2.1.5 多项式加法和乘法的运算规则
（1）加法交换律:
（2）加法结合律:
（3）乘法交换律:
（4）乘法结合律:
（5）乘法对加法的分配律:
注意：
要把一个多项式按“降幂”书写
当
时，
叫做多项式的首项.
2.1.6 多项式的运算性质
定理
是数环R上两个多项式,并且
定义 2
设 是多项式 与 的一个公因式.若是 能被 与 的每一个公因式整除,那么 叫做 与 的一个最大公因式.
定义 1
的任意两个多项式 与 一定有最大公因式.除一个零次因式外, 与 的最大公因式是唯一确定的,这就是说，若 是 与 的一个最大公因式，那么数域F的任何一个不为零的数 c与 的乘积 ，而且当 与 不全为零多项式时，只有这样的乘积是 与 的最大公因式.
由此得出，
是
与
的最大公因式，而
定理 2.3.3
的两个多项式 与 互素的充分且必要条 件是：在 中可以求得多项式 与 ，使
课程设计说明书一元多项式的代数运算.(DOC)
《数据结构》课程设计说明书题目一元多项式的代数运算学号1376807331姓名武飞指导教师康懿日期2015/6/27内蒙古科技大学课程设计任务书课程名称数据结构课程设计设计题目一元多项式的代数运算指导教师康懿时间2015 年春学期第 17 周至第 19 周一、教课要求1.掌握数据结构与算法的设计方法，具备初步的独立剖析和设计能力2.初步掌握软件开发过程的问题剖析、系统设计、程序编码、测试等基本方法和技术3.提升综合运用所学的理论知识和方法独立剖析和解决问题的能力4.训练用系统的看法和软件开发一般规范进行软件开发，培育软件工作者所应具备的科学的工作方法和作风二、设计资料及参数每个学生在教师供给的课程设计题目中随意选择一题，独立达成，题目选定后不行改换。
一元多项式的代数运算以链表储存一元多项式，在此基础上达成对多项式的操作。
要求设计类（或类模板）来描绘一元多项式，包含必需的结构函数和析构函数，以及实现以下要求：输入多项式、输出多项式多项式加法（重载运算符“+”）、多项式乘法（重载运算符“* ”）多项式中无重复阶项和无零系数项要求输出结果的升幂和降幂两种摆列状况并设计主函数测试该类。
三、设计要求及成就1.剖析课程设计题目的要求2.写出详细设计说明3.编写程序代码，调试程序使其能正确运转4.设计达成的软件要便于操作和使用5.设计达成后提交课程设计报告四、进度安排资料查阅与议论（ 1 天）系统剖析（ 2 天）系统的开发与测试（ 5 天）编写课程设计说明书和查收（ 2 天）五、评分标准1.依据平常上机考勤、表现和进度，教师将每日点名和检查2.依据课程设计达成状况，一定有可运转的软件。
3.依据课程设计报告的质量，若有相同，则全部相同的全部人均判为不及格。
4.依据辩论的状况，应能够以清楚的思路和正确、精练的语言表达自己的设计和回答教师的发问六、建议参照资料1．《数据结构（C 语言版）》严蔚敏、吴伟民主编清华大学第一版社 2004.11 2．《数据结构课程设计事例精编（用C/C++描绘）》，李建学等编著，清华大学第一版社2007.2目录第 1 章需求剖析 (3)第 2 章整体设计 (4)2.1 多项式双链循环链表的生成函数 (4)2.2 实现两个一元多项式的加法函数 (5)2.3 实现两个一元多项式的乘法函数 (7)2.4 将结果按幂的升序办理函数 (8)2.5 输出函数 (9)第 3 章详细设计 (12)3.1 主程序流程图 (12)3.2 主要算法的流程图 (13)第 4 章测试 (17)第 5 章总结 (20)参照文件 (20)附录：程序代码 (21)第 1章需求剖析两个一元多项式加法与乘法的实现，顾名思义，本程序的主要功能就是对两个一元多项式进行代数上的加法与乘法运算。
一元符号多项式的四则运算讲解
C++开放项目实验报告题目：一元符号多项式四则运算姓名：指导老师：学号：班级：一、内容总结1.功能要求用所学C++知识编程实现两个一元符号多项式的加法，减法和乘法运算。
2.算法概要设计①结点插入函数void Insert (PNode *temp);②多项式的创建函数void CreatPoly();③赋值运算符的重载Polynomail& operator = (const Polynomail &p1);④一元符号多项式的加法Polynomail& operator + (const Polynomail &p);⑤一元符号多项式的减法Polynomail& operator - (Polynomail &p);⑥一元符号多项式的乘法Polynomail& operator * (const Polynomail &p);3.应用技巧①利用Insert（）插入函数规范多项式的输入问题，进行同类项的合并和不同类项间的排序问题，使得到有序的链表，方便后续的运算②对赋值、加、减和乘运算符进行重载，赋予其新的意义，进行多项式间的四则运算。
③发现函数间联系，可以减少代码的长度。
巧妙利用Insert()函数和加运算符重载函数，方便乘法和减法等代码编写。
二、实验成果1.输入要求按提示一次输入多项式各项的系数和指数，建立多项式。
如下所示: 系数，指数：1,2系数，指数：3,4系数，指数：0 4（以输入系数为零的项结束创建）创建结果为：1x^2+3x^4进行加法运算2根据自己的需要选择输入功能序号进行运算，如选择数字2.输出样例总体上各项是按照输入的方法进行输出，如果指数为零只输出系数，如果系数为零，那么该项不输出，如果系数为负数，那么两项间“+”变“-”。
以上述输入为例创建的结果为：1x^2+3x^4。
如果另一个多项式为：-1-2x^6，那么加法运算后的结果为：-1+1x^2+3x^4-2x^6：主要代码展示 3.//**** c++开放实验项目****//一元符号多项式的四则运算#include <iostream>using namespace std;struct PNode{PNode(double c=0,int e=-1){ coef=c; expn=e; next=NULL;}double coef;int expn;PNode *next;};class Polynomial{public:Polynomial(){poly=new PNode;}Polynomial(Polynomial &p);void Print();~Polynomial();void Insert (PNode *temp);void CreatPoly();Polynomial& operator = (const Polynomial &p);Polynomial& operator + (const Polynomial &p);Polynomial& operator - (Polynomial &p);Polynomial& operator * (const Polynomial &p);private:PNode *poly;};//析构函数Polynomial::~Polynomial(){PNode *pt=poly->next;while (pt){poly->next=pt->next;delete pt;pt=poly->next;}delete poly;poly=NULL;}//赋值运算符的重载Polynomial& Polynomial::operator = (const Polynomial &p){ this->~Polynomial();poly=new PNode;PNode *pt=poly,*qt=p.poly->next;while(qt){PNode *s=new PNode(qt->coef,qt->expn);pt->next=s;pt=s;qt=qt->next;}return *this;}//复制构造函数Polynomial::Polynomial(Polynomial &p){poly=new PNode;*this=p;}//遍历void Polynomial::Print(){if(poly->next==NULL){cout<<empty!\n;return;}PNode *pt=poly->next;if(pt){if(pt->expn==0){cout<<pt->coef;}else {潣瑵?瑰?潣晥?硜属?瑰?硥湰※}pt=pt->next;}while (pt){if(pt->expn==0){cout<<pt->coef;}else {if(pt->coef<0){潣瑵?瑰?潣晥?硜属?瑰?硥湰※}else {潣瑵???瀼?挾敯?尼幸?瀼?放灸?}}pt=pt->next;}cout<<endl;}//结点插入函数void Polynomial::Insert (PNode *temp){ if(poly->next==NULL){poly->next=temp;return;}PNode *pt=poly;PNode *qt=pt->next;while(qt&&qt->expn<temp->expn){ pt=qt;qt=pt->next;}if(qt==NULL||qt->expn>temp->expn){ temp->next=qt;pt->next=temp;}else {qt->coef+=temp->coef;if(qt->coef==0){pt->next=qt->next;delete qt;}}}//多项式的构建函数void Polynomial::CreatPoly(){double c;int e;潣瑵?系数，指数：;cin>>c>>e;while (c){PNode *p=new PNode(c,e);Insert(p);潣瑵?系数，指数：;cin>>c>>e;}}//多项式的加法Polynomial& Polynomial::operator + (const Polynomial &q){ Polynomial *PC=new Polynomial;PNode *ta=poly->next,*tb=q.poly->next, *tc=PC->poly; while(ta&&tb){int a=ta->expn;int b=tb->expn;int t=a>b?1:(b>a?-1:0);switch(t){case -1:{PNode *s=new PNode(ta->coef,ta->expn);tc->next=s;tc=s;ta=ta->next;break;}case 0:{double sum=ta->coef+tb->coef;if(sum==0){ta=ta->next;tb=tb->next;}else {PNode *s=new PNode(sum,ta->expn);tc->next=s;tc=s;ta=ta->next;tb=tb->next;}break;}case 1:{PNode *s=new PNode(tb->coef,tb->expn);tc->next=s;tc=tc->next;tb=tb->next;break;}} //switch} //whilewhile (ta){PNode *s=new PNode(ta->coef,ta->expn);tc->next=s;tc=s;ta=ta->next;}while (tb){PNode *s=new PNode(tb->coef,tb->expn);tc->next=s;tc=s;tb=tb->next;}return *PC;}//多项式的减法Polynomial& Polynomial::operator - (Polynomial &p){//复制取反相加Polynomial P(p),*PC=new Polynomial;PNode *pt=P.poly->next;while(pt){pt->coef=-pt->coef;pt=pt->next;}*PC=*this+P;return *PC;}//多项式的乘法Polynomial& Polynomial:: operator * (const Polynomial &p){ Polynomial *PC=new Polynomial;PNode *pt=poly->next,*qt;for(;pt;pt=pt->next){for(qt=p.poly->next;qt;qt=qt->next){PNode *s=new PNode(pt->coef*qt->coef,pt->expn+qt->expn);PC->Insert(s);}}return *PC;}//主函数int main(){Polynomial PA,PB,PC;int index;cout<< //------一元符号多项式的表示及运算------// <<endl;潣瑵?本函数的功能列表：<<endl;cout<<.多项式的加法:<<endl;cout<<.多项式的减法:<<endl;cout<<.多项式的乘法:<<endl;cout<<.选择重建多项式:<<endl;cout<<_x0005_.结束运算\n<<endl;潣瑵?依次输入PA各项系数和指数(以输入系数0项结束)，建立多项式：<<endl;PA.CreatPoly();PA.Print();潣瑵?依次输入PB各项系数和指数(以输入系数0项结束)，建立多项式：<<endl;PB.CreatPoly();PB.Print();cout<<\请输入功能序号进行多项式的运算：;cin>>index;while(index){switch(index){case 1:{PC=PA+PB;cout<<PC=PA+PB:;PC.Print();break;}case 2:{PC=PA-PB;cout<<PC=PA-PB:;PC.Print();break;}case 3:{PC=PA*PB;cout<<PC=PA*PB:;PC.Print();break;}case 4:{int flag;潣瑵?输入0修改多项式PA,其他数字保留多项式PA:;cin>>flag;if(!flag){PA.CreatPoly();PA.Print();}潣瑵?输入0修改多项式PB,其他数字保留多项式PB:;cin>>flag;if(!flag){PB.CreatPoly();PB.Print();}break;}case 5:{潣瑵?运算结束<<endl;return 0;}}//switchcout<<\是否需要继续，请再次输入选择：;cin>>index;}//whilereturn 0;}4.项目结果展示实践体会三、在此次的C++开放项目试验中，我承担了用C++实现一元符号多项式的四则运算，将所学C++知识运用实战编程中去，并及时进行知识的查缺补漏，帮助我更好的掌握了C++这门语言。
一元多项式的运算
数据结构课程设计实验报告专业班级：学号：姓名：2011年1月1日题目：一元多项式的运算1、题目描述一元多项式的运算在此题中实现加、减法的运算，而多项式的减法可以通过加法来实现（只需在减法运算时系数前加负号）。
在数学上，一个一元n次多项式P n(X)可按降序写成：P n(X)= P n X^n+ P(n-1)X^(n-1)+......+ P1X+P0它由n+1个系数惟一确定，因此，在计算机里它可以用一个线性表P来表示：P=(P n，P(n-1)，......，P1，P0)每一项的指数i隐含在其系数P i的序号里。
假设Q m(X)是一元m次多项式，同样可以用一个线性表Q来表示：Q=(q m,q(m-1)，.....，q1，q0)不是一般性，假设吗吗m<n，则两个多想是相加的结果：R n(X)= P n(X)+ Q m(X)很显然，可以对P,Q和R采用顺序存储结构，使得多项式相加的算法定义和实现简单化。
然而，在通常的应用中，多项式的次数可能变化很大而且很高，使得顺序存储结构的最大长度很难确定。
特别是在处理项数少且次数特别高的情况下，对内存空间的浪费是相当大的。
因此，一般情况下，都采用链式存储结构来处理多项式的运算，使得两个线性链表分别表示一元多项式P n(X)和Q m(X)，每个结点表示多项式中的一项。
通过分析多项式的特征，不难看出多项式是由单项式构成的，而每个单项式都具有系数和指数，当系数为0时，该项就是去了意义，在计算机内要表示一个多项式，至少具有以下数据信息：系数信息、指数信息和指向下一个单项式的指针。
通过指针，我们就可以把多个单项式连接起来，形成一个多项式。
2、任务要求系数定义的是float型，范围是3.4*10^-38~3.4*10^38;指数定义的是int型，范围是-2147483648~+2147483647；输入多项式系数及指数，系统会自动将系数转化为浮点型。
功能：（1）．提示输入数据。
一元多项式的乘法与加法运算
一元多项式的乘法与加法运算
一元多项式的乘法与加法运算
一、乘法运算
1、定义
一元多项式的乘法运算是指在一元多项文的基础上的乘法运算，其中
乘数和被乘数均为一元多项式。
2、运算规则
（1）同序项相乘：两个一元多项式的相同次方项，按照乘法规则运算，系数相乘，指数相加。
（2）求和：将相乘之后的项按次方合起来，系数相加，指数相同。
二、加法运算
1、定义
一元多项式的加法运算是指在一元多项式的基础上的加法运算，其中
加数和被加数均为一元多项式。
2、运算规则
（1）同序项相加：两个一元多项式的相同次方项，按照加法规则运算，系数相加，指数相同。
（2）求和：将相加之后的项按次方合起来，系数相加，指数相同。
以上就是一元多项式的乘法与加法运算，总之，一元多项式的乘法与加法运算主要有以下几点：
（1）乘法运算：同序项相乘，求和，系数相乘，指数相加。
（2）加法运算：同序项相加，求和，系数相加，指数相同。
数据结构课程设计—一元多项式加法、减法、乘法运算的实现
1.一元多项式加法、减法、乘法运算的完成 1)设计内容〔1〕使用顺序存储结构完成多项式加、减、乘运算。
例如：10321058)(2456+-+-+=x x x x x x f ,x x x x x x g +--+=23451020107)( 求和结果：102220128)()(2356++-+=+x x x x x g x f 〔2〕使用链式存储结构完成多项式加、减、乘运算，10305100)(1050100+-+=x x x x f ，x x x x x x g 320405150)(10205090+++-= 求和结果：1031040150100)()(102090100++-++=+x x x x x x g x f 2〕设计要求〔1〕用C 语言编程完成上述实验内容中的结构定义和算法。
〔2〕要有main()函数，并且在main()函数中使用检测数据调用上述算法。
〔3〕用switch 语句设计如下选择式菜单。
***************数据结构综合性实验**************** *******一、多项式的加法、减法、乘法运算********** ******* 1.多项式创立 ********** ******* 2.多项式相加 ********** ******* 3.多项式相减 ***************** 4.多项式相乘 ********** ******* 5.清空多项式 ********** ******* 0.退出系统 ********** ******* 请选择〔0—5〕 ********** ************************************************* *请选择〔0-5〕:根据下面给出的存储结构定义：#define MAXSIZE 20 //定义线性表最大容量 //定义多项式项数据类型 typedef struct{float coef; //系数int expn; //指数}term,elemType;typedef struct{term terms[MAXSIZE]; //线性表中数组元素int last; //指向线性表中最后一个元素位置}SeqList;typedef SeqList polynomial;根本操作函数说明polynomial*Init_Polynomial();//初始化空的多项式int PloynStatus(polynomial*p)//推断多项式的状态int Location_Element(polynomial*p,term x)在多项式p中查找与x项指数相同的项是否存在int Insert_ElementByOrder(polynomial*p,term x)//在多项式p中插入一个指数项xint CreatePolyn(polynomial*P,int m)//输入m项系数和指数，建立表示一元多项式的有序表pchar compare(term term1,term term2)//比拟指数项term1和指数项term2polynomial*addPloyn(polynomial*p1,polynomial*p2)//将多项式p1和多项式p2相加，生成一个新的多项式polynomial*subStractPloyn(polynomial*p1,polynomial*p2)//多项式p1和多项式p2相减，生成一个新的多项式polynomial*mulitPloyn(polynomial*p1,polynomial*p2)//多项式p1和多项式p2相乘，生成一个新的多项式void printPloyn(polynomial*p) //输出在顺序存储结构的多项式p#include<stdlib.h>#include<stdio.h>#include<iostream.h>#define NULL 0#define MAXSIZE 20typedef struct{float coef;int expn;}term,elemType;typedef struct{term terms[MAXSIZE];int last;}SeqList;typedef SeqList polynomial; void printPloyn(polynomial*p); int PloynStatus(polynomial*p) {if(p==NULL){return -1;}else if(p->last==-1){return 0;}else{return 1;}}polynomial*Init_Polynomial() {polynomial*P;P=new polynomial;if(P!=NULL){P->last=-1;return P;}else{return NULL;}}void Reset_Polynomial(polynomial*p){if(PloynStatus(p)==1){p->last=-1;}}int Location_Element(polynomial*p,term x){int i=0;if(PloynStatus(p)==-1)return 0;while(i<=p->last && p->terms[i].expn!=x.expn) {i++;}if(i>p->last){return 0;}else{return 1;}}int Insert_ElementByOrder(polynomial*p,term x) {int j;if(PloynStatus(p)==-1)return 0;if(p->last==MAXSIZE-1){cout<<"The polym is full!"<<endl;return 0;}j=p->last;while(p->terms[j].expn<x.expn && j>=0){p->terms[j+1]=p->terms[j];j--;}p->terms[j+1]=x;p->last++;return 1;}int CreatePolyn(polynomial*P,int m){float coef;int expn;term x;if(PloynStatus(P)==-1)return 0;if(m>MAXSIZE){printf("顺序表溢出\n");return 0;}else{printf("请依次输入%d对系数和指数...\n",m);for(int i=0;i<m;i++){scanf("%f%d",&coef,&expn);x.coef=coef;x.expn=expn;if(!Location_Element(P,x)){Insert_ElementByOrder(P,x);}}}return 1;}char compare(term term1,term term2){if(term1.expn>term2.expn){return'>';}else if(term1.expn<term2.expn){return'<';}else{return'=';}}polynomial*addPloyn(polynomial*p1,polynomial*p2){int i,j,k;i=0;j=0;k=0;if((PloynStatus(p1)==-1)||(PloynStatus(p2)==-1)){return NULL;}polynomial*p3=Init_Polynomial();while(i<=p1->last && j<=p2->last){switch(compare(p1->terms[i],p2->terms[j])){case'>':p3->terms[k++]=p1->terms[i++];p3->last++;break;case'<':p3->terms[k++]=p2->terms[j++];p3->last++;break;case'=':if(p1->terms[i].coef+p2->terms[j].coef!=0){p3->terms[k].coef=p1->terms[i].coef+p2->terms[j].coef;p3->terms[k].expn=p1->terms[i].expn;k++;p3->last++;}i++;j++;}}while(i<=p1->last){p3->terms[k++]=p1->terms[i++];p3->last++;}return p3;}polynomial*subStractPloyn(polynomial*p1,polynomial*p2){int i;i=0;if((PloynStatus(p1)!=1)||(PloynStatus(p2)!=1)){return NULL;}polynomial*p3=Init_Polynomial();p3->last=p2->last;for(i=0;i<=p2->last;i++){p3->terms[i].coef=-p2->terms[i].coef;p3->terms[i].expn=p2->terms[i].expn;}p3=addPloyn(p1,p3);return p3;}polynomial*mulitPloyn(polynomial*p1,polynomial*p2){int i;int j;int k;i=0;if((PloynStatus(p1)!=1)||(PloynStatus(p2)!=1)){return NULL;}polynomial*p3=Init_Polynomial();polynomial**p=new polynomial*[p2->last+1];for(i=0;i<=p2->last;i++){for(k=0;k<=p2->last;k++){p[k]=Init_Polynomial();p[k]->last=p1->last;for(j=0;j<=p1->last;j++){p[k]->terms[j].coef=p1->terms[j].coef*p2->terms[k].coef;p[k]->terms[j].expn=p1->terms[j].expn+p2->terms[k].expn;}p3=addPloyn(p3,p[k]);}}return p3;}void printPloyn(polynomial*p){int i;for(i=0;i<=p->last;i++){if(p->terms[i].coef>0 && i>0)cout<<"+"<<p->terms[i].coef;elsecout<<p->terms[i].coef;cout<<"x^"<<p->terms[i].expn;}cout<<endl;}void menu(){cout<<"\t\t*******数据结构综合性实验*********"<<endl;cout<<"\t\t***一、多项式的加、减、乘法运算***"<<endl;cout<<"\t\t******* 1.多项式创立 *********"<<endl;cout<<"\t\t******* 2.多项式相加 *********"<<endl;cout<<"\t\t******* 3.多项式相减 *********"<<endl;cout<<"\t\t******* 4.多项式相乘 *********"<<endl;cout<<"\t\t******* 5.清空多项式 *********"<<endl;cout<<"\t\t******* 0.退出系统 *********"<<endl;cout<<"\t\t****** 请选择(0-5) ********"<<endl;cout<<"\t\t***********************************"<<endl; }void main(){int sel;polynomial*p1=NULL;polynomial*p2=NULL;polynomial*p3=NULL;while(1){menu();cout<<"\t\t*请选择(0-5):";cin>>sel;switch(sel){case 1:p1=Init_Polynomial();p2=Init_Polynomial();int m;printf("请输入第一个多项式的项数:\n");scanf("%d",&m);CreatePolyn(p1,m);printf("第一个多项式的表达式为p1=");printPloyn(p1);printf("请输入第二个多项式的项数:\n");scanf("%d",&m);CreatePolyn(p2,m);printf("第二个多项式的表达式为p2=");printPloyn(p2);break;case 2:printf("p1+p2=");if((p3=subStractPloyn(p1,p2))!=NULL)printPloyn(p3);break;case 3:printf("\np1-p2=");if((p3=subStractPloyn(p1,p2))!=NULL)printPloyn(p3);break;case 4:printf("\np1*p2=");if((p3=mulitPloyn(p1,p2))!=NULL)printPloyn(p3);case 5:Reset_Polynomial(p1);Reset_Polynomial(p2);Reset_Polynomial(p3);break;case 0:return;}}return;}1〕设计内容以一个m*n的长方阵表示迷宫，0和1分别表示迷宫中的通路和障碍。
数据结构课程设计报告一元多项式加减乘除精
数据结构课程设计报告一元多项式加减乘除精多项式想加减与乘与升降序学院计算机科学与技术专业信息安全学号 12070学生姓名陶宝中辅导教师姓名12月 22 日一、设计目的与内容了解数据结构的与算法的设计方法，独立分析和设计一元多项式加减与乘除的程序编码，经过程序编写掌握软件开发过程的问题分析，系统设计，程序编码，测试等基本方法和技能，提高综合运用所学理论知识和方法独立分析和解决问题的能力，经过这次实践将实验问题中的所涉及的对象在计算机中表示出来并对她们进行处理，掌握线除。
任务与分析本课题主要的目的是分别采用顺序和动态存储结构实现一元多项式的加法、减法和乘法。
并将操作结果分别按升序和降序输出程序的主要功能一元多项式创立建立一元多项式的顺序表和链式表，按程序提示输入每个项数据结束创立。
借助元素在存储器中的相对位置来表示数据元素之间的关系，顺序表中第i个位置表示一元多项式的第i项的系数为第i个位置存放的内容，指数为i-1。
创立一个一元多项式顺序表，对一元多项式的运算中会出现的各种情况进行分析，实现一元多项式的相加、相减、相乘操作。
用链表来表示只存储多项式中系数非零的项。
链表中的每一个结点存放多项式的一个term项结构和指向下一个节点的指针域，term又包括系数和指数两个域分别存放该项的系数、。
创立一元多项式链表，对一元多项式的运算中会出现的各种可能情况进行分析，实现一元多项式的相加、相减、相乘操作。
一元多项式的加法对于两个一元多项式中所有指数相同的项，对应系数相加，若其和不为零，则构成“和多项式”中的一项；对于两个一元多项式中所有指数不相同的项，则分别复抄到和多项式中去。
一元多项式的减法对于两个一元多项式中所有指数相同的项，对应系数相减，若其差不为零，则构成“和多项式”中的一项；对于两个一元多项式中所有指数不相同的项，将其按减法规则复抄到差多项式中去。
一元多项式的乘法将乘法运算分解为一系列的加法运算利用两个一元多项式相加的算法实现。
一元多项式环的概念及其通用性质
03 一元多项式的加法与减法
加法规则
设两个一元多项式为$P(x) = a_0 + a_1x + a_2x^2 + ldots + a_nx^n$和$Q(x) = b_0 + b_1x + b_2x^2 + ldots + b_mx^m$， 则它们的和$P(x) + Q(x)$定义为系数相加，即$(a_0 + a_1x + a_2x^2 + ldots + a_nx^n) + (b_0 + b_1x + b_2x^2 + ldots + b_mx^m) = (a_0+b_0) + (a_1+b_1)x + (a_2+b_2)x^2 + ldots + (a_n+b_n)x^n$。
一元多项式环的概念及其通用性质
目录
• 一元多项式环的定义 • 一元多项式环的基本性质 • 一元多项式的加法与减法 • 一元多项式的乘法 • 一元多项式的除法 • 一元多项式环的特殊性质
01 一元多项式环的定义
定义
一元多项式环是由所有一元多项式构 成的环，其中加法、减法和乘法运算 封闭。
一元多项式环中的元素称为一元多项 式。
THANKS FOR WATCHING
感谢您的观看
举例说明：$(x^2+3x+2) - (x+1) = (1-1)x^2 + (3-1)x + (2-1) = 0x^2 + 2x + 1$。
04 一元多项式的乘法
单项式与多项式相乘
定义
举例
单项式与多项式相乘是指将单项式的每一项 分别与多项式的每一项相乘，并合并同类项。
数据结构课程设计-一元多项式的加法、减法、乘法的实现
一、设计题目一元多项式的加法、减法、乘法的实现。
二、主要内容设有一元多项式A m(x)和B n(x).A m(x)=A0+A1x1+A2x2+A3x3+… +A m x mB n(x)=B0+B1x1+B2x2+B3x3+… +B n x n请实现求M(x)= A m(x)+B n(x)、M(x)= A m(x)-B n(x)和M(x)= A m(x)×B n(x)。
要求：1) 首先判定多项式是否稀疏2) 采用动态存储结构实现；3) 结果M(x)中无重复阶项和无零系数项；4) 要求输出结果的升幂和降幂两种排列情况三、具体要求及应提交的材料1．每个同学以自己的学号和姓名建一个文件夹，如：“312009*********张三”。
里面应包括：学生按照课程设计的具体要求所开发的所有源程序（应该放到一个文件夹中）、任务书和课程设计说明书的电子文档。
2．打印的课程设计说明书（注意：在封面后夹入打印的“任务书”以后再装订）。
四、主要技术路线提示为把多个小功能结合成一个完整的小软件，需使用“菜单设计”技术（可以是控制台方式下的命令行形式，若能做成图形方式则更好）。
五、进度安排共计两周时间，建议进度安排如下：选题，应该在上机实验之前完成需求分析、概要设计可分配4学时完成详细设计可分配4学时调试和分析可分配10学时。
2学时的机动，可用于答辩及按教师要求修改课程设计说明书。
注：只用课内上机时间一般不能完成设计任务，所以需要学生自行安排时间做补充。
六、推荐参考资料(不少于3篇)［1］苏仕华等编著，数据结构课程设计，机械工业出版社，2007［2］严蔚敏等编著，数据结构（C语言版），清华大学出版社，2003［3］严蔚敏等编著，数据结构题集（C语言版），清华大学出版社，2003指导教师签名日期年月日系主任审核日期年月日摘要分析了matlab，mathmatic，maple等数学软件对一元多项式的计算过程，步骤后。
由于这些软件比较大功能齐全，但是实用性不强。
一元多项式计算课程设计
一元多项式计算课程设计一、课程目标知识目标：1. 理解一元多项式的概念，掌握其标准形式和各项系数的含义。
2. 学会使用合适的方法进行一元多项式的加、减、乘运算，并能够准确写出结果。
3. 掌握一元多项式的除法法则，能对给定的一元多项式进行长除法运算。
技能目标：1. 能够运用所学知识解决实际问题中涉及一元多项式的计算问题。
2. 培养学生运用代数运算解决复杂问题的能力，提高逻辑思维和运算准确性。
3. 通过一元多项式的运算，提升学生的数学表达和推理能力。
情感态度价值观目标：1. 培养学生对数学学习的兴趣，激发学生主动探索一元多项式运算规律的积极性。
2. 培养学生团队合作意识，通过小组讨论与合作，共同解决一元多项式运算中的问题。
3. 引导学生认识到数学知识在实际生活中的应用，体会数学学习的实用价值。
课程性质：本课程为初中数学课程，旨在帮助学生掌握一元多项式的运算方法，提高数学思维和解决问题的能力。
学生特点：初中年级的学生已经具备一定的代数基础，但运算技巧和逻辑思维能力有待提高。
教学要求：注重理论与实践相结合，通过具体例题和练习，使学生熟练掌握一元多项式的计算方法，并能应用于实际问题。
在教学过程中，关注学生的个体差异，提供个性化指导，确保每个学生都能达到课程目标。
二、教学内容本课程依据课程目标，结合教材内容，组织以下教学重点：1. 一元多项式的定义与表示：介绍一元多项式的概念，包括常数项、一次项、二次项等，并学习其标准形式。
2. 一元多项式的加减法：讲解同类项合并原则，通过实例演示和练习，使学生掌握一元多项式的加减运算。
3. 一元多项式的乘法：教授多项式乘法法则，运用分配律进行展开，并通过典型例题强化学生乘法运算技巧。
4. 一元多项式的除法：详细讲解长除法运算步骤，以及商和余数的概念，通过实际操作和练习，提高学生除法运算能力。
教学内容安排如下：第一课时：一元多项式的定义与表示，同类项的合并。
第二课时：一元多项式的加法和减法运算。
多项式的四则运算
摘要在算法程序的设计与编写过程中，根据对本题的要求分析，结合设计对象的特点，实现一元多项式的加、减、乘、除以及对多项式求导、求值的相关计算。
根据一元多项式的结构特点和运算规则。
本程序中采用了链表的存储与实现，采用链表可以很方便的对其中的结点进行插入、删除等操作。
通过链表的合并即可完成多项式的四则运算。
1 引言：1.1 待处理问题的问题背景：本题要求对从键盘上输入的任意两个一元多项式，能够分别对每个多项式进行降幂排序并输出，实现对这两个多项式的加、减、乘、除等相关运算。
在具体实现时，可采用链式存储结构将多项式中的每一项连接起来，从而表达出整个多项式，其中每一项是一个一元多项式，通过每一项系数与指数的输入设定，可以实现对整个多项式的设定，再通过建立单链表，结点来存储每一项的系数与指数，通过链表完成多项式的存储，对每个多项式分别建立一个链表，通过链表的加减乘除运算规则实现连标的合并，最终得到计算结果。
2需要完成的任务：根据题目要求，本程序需要实现对两个一元多项式的四则运算以及对多项式进行赋值求值运算、求导运算等相关计算，要求正确输出运算结果，对不满足输入要求的数据有一定的反应。
3设计：3.1核心算法的设计与说明：3.1.1 一元多项式的定义：有多个单项式的代数和就构成了多项式，一元多项式就是只含有一个变元的多项式。
所以由定义可知有n个单项式组成的一元多项式来说，它的运算是满足交换率的，所以可进行降幂排序，只需将它的所有指数相比较，然后将指数大的放前面，小的放后面即可完成排序。
3.1.2本题的核心算法：首先调用建表函数，CreatePolyn建立两个一元多项式，然后对两个一元多项式进行降幂排序，该过程的实现主要由insert（）函数实现，然后调用相应的计算函数: 加（AddPolyn）、减（SubtractPolyn）、（MultiplyPolyn）、除（DevicePolyn）、导数（Derivative）、求值（ValuePolyn）。
数据结构课程设计-一元多项式的四则运算
一元多项式的四则运算学生姓名：指导老师：摘要本课程设计主要解决一元多项式的运算问题，通过链表的使用，实现对一元多项式的构建、录入、存储、打印、以及之间的运算。
在本课程设计中，程序设计语言为C++语言，程序运行平台为Windows/98/2000/XP，程序采用了链表存储方法以及结构化和模块化的设计方法，通过调试运行，可以进行多项式的加、减、乘运算，勉强实现了设计目标，并且经过适当完善后，将可应用到实际中解决某些问题。
关键词程序设计； C++ ；一元多项式；运算1 引言一般来说，我们只知道数学上的一元多项式的运算，这一般都是用笔来进行运算的，然而此课程设计将一元多项式的运算用电脑来进行，只需要将多项式输入，然后就可以出结果，速度快，省去了认为计算的环节，在现实中带来不少方便。
1.1 课题背景一元多项式的运算，虽然无法直接在除数学外的其他领域作出贡献，但是在数学上，它可以为人们解决一些自己动笔动手很难解决的问题，比如说那些很长很长的多项式，用笔算可能要算半天，但是用该程序，只需短短的几秒钟，所以它给人们带来了不少方便，同时相信它也能间接地为其他领域做出贡献。
1.2 课程设计目的个人觉得，该数据结构课程设计一方面可以让自己更加熟悉那些些常用的数据结构，掌握数据结构内在的逻辑关系，以及它们在计算机中的存储表示，和对它们实行的各种运算；另一方面，可以让自己对于整体和局部，以及结构化和模块化编程有一个更深层次的了解。
作为网络工程的学生，虽然之前有过一次Ｃ语言课程设计，但是深知自己编程能力尚为欠缺，所以这一次数据结构课程设计是对我的编程能力和组织能力的又一次考验。
1.3课程设计内容本课程设计是用链表实现一元多项式的存储及运算，其中包括多项式系数及指数的录入（即一元多项式的录入），以及储存、一元多项式的显示、一元多项式之间的加、减、乘法运算。
2 设计思路与方案2.1设计思路该系统使用Ｃ++语言进行开发和实现，程序中的各个功能分别由不同的的函数实现，然后在main函数中调用实现。
数据结构课程设计,一元多项式的加法、减法、乘法的实现
HUNAN CITY UNIVERSITY 数据结构课程设计报告设计题目：一元多项式的加法、减法、乘法的实现专业：计算机科学与技术（嵌入式）学生姓名：班级学号：分组成员：指导教师：陈强老师2012 年 6月 8日1006402《数据结构》课程设计报告一、设计时间2011年6月4日——6月8日二、设计地点湖南城市学院实验楼计算机房407三、设计目的《数据结构》主要介绍最常用的数据结构，阐明各种数据结构内在的逻辑关系，讨论其在计算机中的存储表示，以及在其上进行各种运算时的实现算法，并对算法的效率进行简单的分析和讨论，是介于数学、计算机软件和计算机硬件之间的一门计算机专业的核心课程，它是计算机程序设计、数据库、操作系统、编译原理及人工智能等的重要基础，广泛的应用于信息学、系统工程等各种领域。
该课程的特点是实践性较强，为了学好这门课程，需要在掌握理论知识的同时，加强上机实践。
本课程设计的目的就是要达到理论与实际应用相结合，使同学们能够根据数据对象的特性，学会数据组织的方法，能把现实世界中的实际问题在计算机内部表示出来，并培养基本的、良好的程序设计技能。
具体要求如下：1.了解并掌握数据结构与算法的设计方法，具备初步的独立分析和设计能力；2.初步掌握软件开发过程的问题分析、系统设计、程序编码测试等基本方法和技能;3.提高综合运用所学的理论知识和方法独立分析和解决问题的能力;4.训练用系统的观点和软件开发一般规范进行软件开发，培养软件工作者所应具备的科学的工作方法和作风。
四、设计小组成员五、指导教师：六、设计课题：顺序结构、动态链表结构下的一元多项式的加法、减法、乘法的实现设有一元多项式Am(x)和Bn(x).Am(x)=A0+A1x1+A2x2+A3x3+…+A m x mBn(x)=B0+B1x1+B2x2+B3x3+…+B n x n请实现求M(x)=Am(x)+Bn(x)、M(x)=Am(x)-Bn(x)和M(x)=Am(x)×Bn(x)。
一元多项式的加法、乘法运算的实现
数据结构课题设计报告设计题目：一元多项式的加、乘法的实现姓名：班级：学号：指导老师：目录一、实验题目 (4)二、设计内容 (4)三、设计实现 (4)四、概要设计 (5)1，按要求输入一元多项式的系数 (5)2，计算一元多项式的加法 (5)3，输出计算结果 (5)4，按要求输入一元多项式的系数 (5)5，计算一元多项式的乘法 (5)6，输出计算结果 (5)7，退出 (5)五、程序流程图 (6)1，加法运算 (6)2，乘法运算 (7)六、源程序 (8)七、程序运行界面图 (20)1，加法运行输入项数 (20)2，输入每一项的系数及指数 (20)3，算出加法运算结果及乘法运行输入项数 (21)4，入乘法运算每一项的系数及指数 (21)5，算出乘法运算的结果 (22)八、心得体会................................................. - 23 -课程设计评分表 (24)一、实验题目一元多项式加法、乘法运算的实现二、设计内容该程序的功能是实现一个一元多项式运算。
能够完成两个多项式的相加、相乘的运算并且输出正确的答案。
三、设计实现一元多项式加法，乘法运算的实现1.根据输入创建一元多项式，采用顺序和链表存储结构实现顺序存储结构：在计算机内部可以采用不同方式存储一个线性表，其中最简单的方式就是用一组地址连续的存储单元来依次存储线性表中的数据元素。
对一元多项式存储结构的选择，输入多项式采用头插法的方式，输入多项式中一个项的系数和指数，就产生一个新的节点，建立起它的右指针，并用头节点指向它；一元多项式可以用顺序和链表两种存储结构表示，顺序结构的最大长度很难确定。
单链表的结构体可以用来存储多项式的系数，指数，便于实现任意多项式的运算。
2．创建的的第个一元多项式用于实现加法的运算，第二个一元多项式用于实现乘法的运算。
3.运算完毕后，退出运行程序四、概要设计1，按要求输入一元多项式的系数2，计算一元多项式的加法3，输出计算结果4，按要求输入一元多项式的系数5，计算一元多项式的乘法6，输出计算结果7，退出五、程序流程图 1，加法运算2，乘法运算六、源程序#include <stdio.h>#include <stdlib.h>#include <string.h>#define NULL 0typedef struct Node{ //定义结构体类型float coef; //系数int expn; //指数struct Node *next; //结构体指针}Node,*Linklist;struct polynode{int c;int e;struct polynode *next;};struct polynode * creat(void){int c,e;struct polynode *head=NULL;struct polynode *p1,*p2,*l,*r;while(scanf("%d,%d%*c",&c,&e),c||e){p2=(struct polynode *)malloc(sizeof(struct polynode)); p2->c=c;p2->e=e;p2->next=NULL;if(head==NULL){head=p2;continue;}for(l=r=head;l!=NULL&&(l->e)<e;l=l->next) r=l;if(l==head&&l->e>e) head=p2;else r->next=p2;p2->next=l;}return head;}void output(struct polynode* head){struct polynode *p1;p1=head;if(p1==NULL){printf("\n multinomial is zero\n");return;}printf("\n");while(p1!=NULL){printf(p1!=head&&(p1->c)>0? "+%d":"%d",p1->c);printf(p1->e? "x^%d":"",p1->e);p1=p1->next;}printf("\n");}struct polynode * add(struct polynode *head1,struct polynode *head2) {struct polynode *p1,*p2,*r,*l,*h;h=r=p1=head1;p2=head2;if(head1==NULL){h=head2;return h;}while (p1!=NULL&&p2!=NULL) {if(p1->e==p2->e){p1->c+=p2->c;p2=p2->next;r=p1;p1=p1->next;continue;}if(p1->e<p2->e){r=p1;p1=p1->next;continue;}if(p1->e>p2->e){l=p2;p2=p2->next;if(p1==h) h=l;else r->next=l;l->next=p1;r=l;continue;}}if (p1==NULL) r->next=p2;return h;}struct polynode * mul(struct polynode *head1,struct polynode *head2) {struct polynode *p,*p1,*p2,*r,*t,*head;head=NULL;if(head1==NULL||head2==NULL) return head;for(p2=head2;p2!=NULL;p2=p2->next){for(p1=head1;p1!=NULL;p1=p1->next){p=(struct polynode *)malloc(sizeof(struct polynode));p->c=p1->c*p2->c;p->e=p1->e+p2->e;p->next=NULL;if(p1==head1) t=p;else r->next=p;r=p;}head=add(head,t);}// output(head);return head;}Linklist creatpolyn(Linklist L,int n){ //构造新的一元多项式int i;Linklist head,p;head=(Linklist)malloc(sizeof(Node)); //创建头结点head->next=NULL;L=head;for(i=n;i>0;i--){p=(Linklist)malloc(sizeof(Node));printf("请输入一元多项式的第%d项的系数和指数：",i);scanf("%f%d",&(*p).coef,&(*p).expn); //输入系数和指数p->next=L->next;L->next=p;}return(head); //返回头结点}//creatpolynint cmp(int a,int b){ //比较a,b的大小if(a>b)return(1);elseif(a==b)return(0);elsereturn(-1);}void print(Linklist L){ //显示一元多项式Linklist p;p=L->next;while(p->next!=NULL){printf("%f*x^%d+",(*p).coef,(*p).expn); //输出多项式的项p=p->next;}printf("%f*x^%d\n",(*p).coef,(*p).expn); //输出多项式最后一项}//PrintLinklist Addpolyn(Linklist pa,Linklist pb){ //多项式相加int a,b;float sum;Linklist ha,hb,qa,qb,p1,p2;ha=pa; //ha,hb分别指向pa和pb中当前结点hb=pb;qa=ha->next; //qa和qb分别指向pa和pb中当前结点qb=hb->next;while(qa!=NULL&&qb!=NULL){ //qa和qb均非空a=(*qa).expn;b=(*qb).expn;switch(cmp(a,b)){ //比较指数case -1:{ //a<bha->next=qa;ha=ha->next;qa=qa->next; break;}case 0:{ //a=b sum=(*qa).coef+(*qb).coef;if(sum!=0.0){(*qa).coef=sum;ha->next=qa;ha=ha->next;}else{p1=qa;free(p1);}p2=qb;qa=qa->next;qb=qb->next;free(p2);break;}case 1:{ //a>b ha->next=qb;ha=ha->next;qb=qb->next;break;}}//switch}//whilewhile(qa!=NULL){ //如果qb不为空ha->next=qa;ha=ha->next;qa=qa->next;}while(qb!=NULL){ //如果qb不为空ha->next=qb;ha=ha->next;qb=qb->next;}return(pa);}//Addpolynvoid main(){int m,n,i;char t;Linklist pa,pb;pa=(Linklist)malloc(sizeof(Node));pb=(Linklist)malloc(sizeof(Node));printf("请输入一元多项式pa的项数:\n"); //构造一元多项式pascanf("%d",&m);pa=creatpolyn(pa,m);printf("请输入一元多项式pb的项数:\n"); //构造一元多项式pbscanf("%d",&n);pb=creatpolyn(pb,n);printf("多项式pa为:"); //输出paprint(pa);printf("多项式pb为:"); //输出pbprint(pb);printf("多项式pa与pb的和为:"); //输出多项式pa和pb的和print(Addpolyn(pa,pb));struct polynode *head1=NULL,*head2=NULL,*head=NULL;logn: printf("请输入需要相乘的多项式个数,至少2个: ");scanf("%d%c",&n);printf("\n 输入一个多项式的方式为:系数,指数; 例如: 3,4;5,6;7,8;as0,0;结束\n");printf("\n 请输入第1个多项式的系数和指数: ");head1=creat();printf("\n 第1个多项式的为: ");output(head1);for(i=1;i<n;i++){printf("\n 请输入第%d个多项式的系数和指数 : ",i+1);head2=creat();printf("\n 第%d个多项式为: ",i+1);output(head2);if(i==1)head=mul(head1,head2);else head=mul(head,head2);}printf("\n 多项式相乘结果为 : ");output(head);printf("\n 是否继续(y/n)? ");scanf("%*c%c",&t);if(t=='y') goto logn;}七、程序运行界面图1，加法运行输入项数2，输入每一项的系数及指数3，算出加法运算结果及乘法运行输入项数4，入乘法运算每一项的系数及指数5，算出乘法运算的结果八、心得体会通过这次的课程设计，是我又温习了数组、循环结构以及嵌套以及分块模块等C语言知识。
题目一元多项式的加法减法乘法的实现
理学院课程设计说明书课程名称: 数据结构与算法A设计实践课程代码: 6015059 题目一:一元多项式加法、减法、乘法年级/专业/班: 2013/信科/2班学生姓名: 冯金慧学号: 3120130902209 开始时间:2015 年12月28日完成时间:2016 年01 月10 日课程设计成绩：学习态度及平时成绩（30）技术水平与实际能力（20）创新（5）说明书撰写质量（45）总分（100）指导教师签名：年月日数据结构与算法A 设计实践任务书 学院名称： 理学院 课程代码：_6015059________专业： 信科 年级： 2012一、 设计题目一元多项式的加法、减法、乘法的实现（限最多1人完成）二、 主要内容完成一无多项式的基本运算功能。
三、具体要求及提交的材料设有一元多项式A m (x)和B n (x).A m (x)=A 0+A 1x 1+A 2x 2+A 3x 3+… +A m x mB n (x)=B 0+B 1x 1+B 2x 2+B 3x 3+… +B n x n 请实现求M(x)= A m (x)+B n (x)、M(x)= A m (x)-B n (x)和M(x)= A m (x)×B n (x)。
要求： 1) 首先判定多项式是否稀疏2) 分别采用顺序和动态存储结构实现；3) 结果M(x)中无重复阶项和无零系数项；要求输出结果的升幂和降幂两种排列情况测试数据及测试结果请在上交的资料中写明；必须上机调试通过按《数据结构课程设计大纲》中的要求完成课程设计报告格式。
设计结束后，每个学生必须上交的材料有：1 《课程设计报告》打印稿一份 2．课程设计的源代码电子文档一份四、主要技术路线提示稀疏的多项式最好采用链式存储结构；两式相减与相加的算法是一致的，只是减式的数据项反号；两式相乘是两式相加的变形。
五、进度安排共计两周时间，建议进度安排如下：1． 选题，应该在上机实验之前完成 2. 需求分析、概要设计可分配4学时完成2． 详细设计可分配4学时 4. 调试和分析可分配10学时。
一元多项式的加法.减法.乘法的实现
一元多项式的加法. 减法 . 乘法的实现数学与计算机学院课程设计说明书课程名称:数据结构-课程设计课程代码: 8404181题目一元多项式的加法、减法、乘法的实现年级/专业/班: 2019/软件工程/4学生姓名:学号:开始时间:2019年6月20日完成时间:2019年6月29日课程设计成绩：指导教师签名：年月日数据结构课程设计任务书学院名称：数学与计算机学院课程代码：8404181专业：软件工程年级：2019 级一、设计题目一元多项式的加法、减法、乘法的实现。
二、主要内容设有一元多项式 A m (x) 和 B n (x). Am (x)=A0+A1x +A2x +A3x +, +Am x Bn(x)=B0+B1x +B2x +B3x +, +Bn x请实现求 M(x)= Am (x)+Bn (x) 、 M(x)= Am (x)-Bn (x) 和 M(x)= Am (x) ×B n (x) 。
要求： 1)首先判定多项式是否稀疏 2) 采用动态存储结构实现；3) 结果 M(x) 中无重复阶项和无零系数项； 4) 要求输出结果的升幂和降幂两种排列情况123n123m三、具体要求及应提交的材料1 ．每个同学以自己的学号和姓名建一个文件夹，如：“[**************]张三”。
里面应包括：学生按照课程设计的具体要求所开发的所有源程序（应该放到一个文件夹中）、任务书和课程设计说明书的电子文档。
2．打印的课程设计说明书（注意：在封面后夹入打印的“任务书”以后再装订）。
四、主要技术路线提示为把多个小功能结合成一个完整的小软件，需使用“菜单设计”技术（可以是控制台方式下的命令行形式，若能做成图形方式则更好）。
五、进度安排共计两周时间，建议进度安排如下：选题，应该在上机实验之前完成需求分析、概要设计可分配 4 学时完成详细设计可分配 4 学时调试和分析可分配10 学时。
2学时的机动，可用于答辩及按教师要求修改课程设计说明书。
一元多项式的计算,数据结构程序设计图形界面
一元多项式的计算,数据结构程序设计图形界面
对于一元多项式的计算,可以使用链表来存储每一项的系数和指数,然后进行加减乘除等运算。
具体实现的步骤如下：
1. 定义一个多项式节点的结构体,包含两个成员：系数和指数。
2. 定义一个链表结构体,包含两个成员：头节点和尾节点。
3. 实现链表的初始化函数、插入节点函数、删除节点函数、遍历链表函数等基本操作。
4. 实现多项式加法、减法、乘法、除法等运算函数。
对于加减法,可以遍历两个链表,依次将相同指数的项相加或相减；对于乘法,可以使用两个for循环遍历两个链表,将每一项相乘并按照指数相加；对于除法,可以使用辗转相除法,将被除数一部分一部分地减去除数,直到余数小于除数为止,每一部分的商可视为一项。
对于数据结构程序设计图形界面,可以使用Qt等UI框架来实现。
可以使用布局管理器来设计UI界面,使用信号与槽机制来处理用户的操作输入,将用户输入的参数传递给多项式计算函数,最终将计算结果显示在UI界面上。
数据结构一元多项式的运算-无删减范文
数据结构一元多项式的运算数据结构一元多项式的运算简介一元多项式是数学中常见的概念，用于表示一个变量的多项式表达式。
在计算机科学中，经常需要对一元多项式进行各种运算，如加法、减法、乘法等。
为了实现这些运算，可以使用数据结构来存储和操作一元多项式。
本文将介绍一元多项式的数据结构和常见的运算方法，并给出相应的代码示例。
数据结构一元多项式可以用链表来表示。
每个节点包含两个部分：系数（coefficient）和指数（exponent）。
系数表示该项的权重，指数表示该项的幂次。
链表的每个节点按照指数的升序排列。
以下是一个一元多项式的链表表示的示例：```markdown1.2x^2 + 3.7x^4 - 0.5x^3 -2.1x^1 + 4.0``````markdownNode 1: coefficient=1.2, exponent=2Node 2: coefficient=3.7, exponent=4Node 3: coefficient=-0.5, exponent=3Node 4: coefficient=-2.1, exponent=1Node 5: coefficient=4.0, exponent=0```运算方法加法运算两个一元多项式相加可以按照如下步骤进行：1. 遍历两个链表的节点，分别取出当前节点的系数和指数。
2. 如果两个节点的指数相等，将系数相加，并将其作为结果链表的节点。
3. 如果两个节点的指数不相等，将指数较小的节点插入结果链表，并继续遍历指数较大的节点。
4. 当其中一个链表遍历完后，直接将另一个链表的节点插入结果链表。
以下是加法运算的代码示例：```pythondef addPolynomials(p1, p2):result = Nonetl = Nonewhile p1 is not None and p2 is not None:if p1.exponent == p2.exponent:coef_sum = p1.coefficient + p2.coefficient if coef_sum != 0:node = Node(coef_sum, p1.exponent)if result is None:result = tl = nodeelse:tl.next = nodetl = nodep1 = p1.nextp2 = p2.nextelif p1.exponent > p2.exponent:node = Node(p1.coefficient, p1.exponent) if result is None:result = tl = nodeelse:tl.next = nodetl = nodep1 = p1.nextelse:node = Node(p2.coefficient, p2.exponent) if result is None:result = tl = nodeelse:tl.next = nodetl = nodep2 = p2.nextwhile p1 is not None:node = Node(p1.coefficient, p1.exponent)if result is None:result = tl = nodeelse:tl.next = nodetl = nodep1 = p1.nextwhile p2 is not None:node = Node(p2.coefficient, p2.exponent) if result is None:result = tl = nodeelse:tl.next = nodetl = nodep2 = p2.nextreturn result```减法运算减法运算可以看作加法运算的特殊情况，即将第二个多项式的系数取负数，再进行加法运算。
一元多项式的加法减法乘法和求导
一元多项式的加法、减法、乘法和求导一、【实验构思（Conceive）】(10%)（本部分应包括：描述实验实现的基本思路，包括所用到的离散数学、工程数学、程序设计、算法等相关知识）1、一元稀疏多项式的加法、减法、乘法和求导法则：假设：f(x) = 3 x^8 + 9 x^5g(x) = 7 x^9 + 3 x则：f(x) + g(x) = 7 x^9 + 3 x^8 + 9 x^5 + 3 xf(x) - g(x) = -7 x^9 + 3 x^8 + 9 x^5 - 3 xf(x) * g(x) = 21 x^17 + 63 x^14 + 9 x^9 + 27 x^6f'(x) = 24 x^7 + 45 x^42、基本思路：首先定义一个结构体，其中定义一元多项式中的两个参数:系数和指数和链表中结点的指针域；然后一一罗列每个在主程序中用到的函数，并一一实现；最后在主程序中主要完成用户的输入和相关函数的调用。
二、【实验设计(Design)】(20%)void insert(PLOYList *head,PLOYList *input)//查找位置插入新链节的函数，且让输入的多项式呈降序排列PLOYList *creat(char ch)//输入多项式PLOYList *add(PLOYList *head,PLOYList *pre)//多项式相加，head为第一个多项式建立的链表表头，pre为第二个多项式建立的链表表头PLOYList *sub(PLOYList *head,PLOYList *pre)//多项式相减PLOYList *mul(PLOYList *head,PLOYList *pre)//多项式相乘PLOYList *der(PLOYList *head)//多项式求导void print(PLOYList *fun)//输出多项式，fun指要输出的多项式链表的表头void start()//用户选择界面主程序：void main(){PLOYList *f,*g,*pf,*hf,*p;int sign=-1;start();while(sign!=0){scanf("%d",&sign);switch(sign){case 0:break;case 1://多项式相加{printf(" 你选择的操作是多项式相加:\n");printf(" 请输入第一个多项式f(x)：");f=creat('f');printf(" 第一个多项式为：f(x)=");print(f);printf(" 请输入第二个多项式g(x)：");g=creat('g');printf(" 第二个多项式为：g(x)=");print(g);printf(" 结果为：F(x)=f(x)+g(x)=");f=add(f,g);print(f);printf("\n\n");printf(" 继续请选择相应操作，退出请按0. ");break;}case 2://多项式相减{printf(" 你选择的操作是多项式相减:\n");printf(" 请输入第一个多项式f(x)：");f=creat('f');printf(" 第一个多项式为：f(x)=");print(f);printf(" 请输入第二个多项式g(x)：");g=creat('g');printf(" 第二个多项式为：g(x)=");print(g);printf(" 结果为：F(x)=f(x)-g(x)=");f=sub(f,g);print(f);printf("\n\n");printf(" 继续请选择相应操作，退出请按0. ");break;}case 3://多项式相乘{printf(" 你选择的操作是多项式相乘:\n");printf(" 请输入第一个多项式f(x)：");f=creat('f');printf(" 第一个多项式为：f(x)=");print(f);printf(" 请输入第二个多项式g(x)：");g=creat('g');printf(" 第二个多项式为：g(x)=");print(g);printf(" 结果为：F(x)=f(x) * g(x)=");pf=mul(f,g);print(pf);printf("\n\n");printf(" 继续请选择相应操作，退出请按0. ");break;}case 4://多项式求导{printf("您选择的是对一个一元多项式求导：\n");printf("请输入一个一元多项式：");f = creat('f');printf("这个多项式为：f(x)= ");print(f);printf("求导结果为：F(x)=f'(x)= ");f=der(f);print(f);printf("\n\n");printf(" 继续请选择相应操作，退出请按0. ");break;}case 5://帮助用户理解输入规则{printf("---------------------------帮助------------------------------\n");printf(" \n");printf(" 1.输入时只输入多项式的系数与指数\n");printf(" 2.输入多项式形式：系数1 指数1 系数2 指数2 …… ，以0 0 结束\n");printf(" 3.例如输入\"1 1 2 2 0 0\" 表示\"1*X^1+2*X^2\" \n");printf(" \n");printf("---------------------------帮助------------------------------\n");printf("\n\n");break;}default:{printf( "看完帮助信息后请重新选择操作\n");break;}}//swith}//while}//void三、【实现描述（Implement）】(30%)1.插入函数，用来对根据用户输入的项建立的单个结点进行排序，使其按照指数降序排列，此函数也可以用在多项式的加减法里，因为加减法实质上也是插入的过程。
一元多项式运算(包括加_乘_导)
信息科学与技术学院 《数据结构》课程设计报告完成日期：2012-12题目名称： 一元多项式运算 专业班级： 计算机科学与技术学生姓名： 11 学生学号： 11111111 指导教师： 11111111目录1 课程设计的目的 (4)1.1 课程设计的目的 (4)1.2 课程设计的题目 (4)1.3 题目要求 (4)2 概要设计 (5)2.1 存储结构 (5)2.2 基本操作 (5)3 详细设计 (6)3.1总体流程图 (6)3.2主模块 (7)3.3、查找位置插入链接模块 (7)3.3.1函数功能： (7)3.3.2函数入口： (8)3.3.3函数流程图： (8)3.4、创建多项式模块 (9)3.4.1函数功能： (9)3.4.2函数入口： (9)3.4.3函数流程图： (9)3.5、多项式相加模块 (10)3.5.1函数功能： (10)3.5.2函数入口： (10)3.5.3函数流程图 (10)3.6多项式相乘模块 (10)3.6.1函数功能： (10)3.6.2函数入口： (11)3.6.3函数流程图： (11)3.7多项式求导模块 (11)3.7.1函数功能： (11)3.7.2函数入口： (12)3.7.3函数流程图： (12)3.8输出多项式模块 (12)3.8.1函数功能： (12)3.8.2函数入口： (12)3.8.3函数流程图： (13)4 测试 (14)4. 1用户选择界面 (14)4. 2,两个一元多项式相加功能 (15)4.3两个一元多项式相乘功能 (16)4.4对一个一元多项式求导功能: (16)4.5帮助功能: (17)5 课程设计总结 (17)6参考书目： (27)1 课程设计的目的1.1 课程设计的目的本课程设计主要解决一元多项式的运算问题，通过链表的使用，实现对一元多项式的构建、录入、存储、打印、以及之间的运算。
在本课程设计中，程序设计语言为C++语言，程序采用了链表的存储方法以及结构化和模块化的设计方法，通过调试运行，可以进行多项式的相加、相乘和求导，勉强实现了设计目标，并且经过适当的完善后，将可运用到实际中解决某些问题。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
中国计量学院实验报告
实验课程：算法与数据结构实验名称：一元二项式班级：学号：
姓名：实验日期： 2013-5-7
一．实验题目：
①创建2个一元多项式
②实现2个多项式相加
③实现2个多项式相减
④实现2个多项式相乘
⑤实现2个多项式相除
⑥销毁一元多项式
实验成绩：指导教师：
二．算法说明
①存储结构：一元多项式的表示在计算机内可以用链表来表示，为了节省存储
空间，只存储多项式中系数非零的项。
链表中的每一个结点存放多项式的一个系数非零项，它包含三个域，分别存放该项的系数、指数以及指向下一个多项式项结点的指针。
创建一元多项式链表，对一元多项式的运算中会出现的各种可能情况进行分析，实现一元多项式的相加、相减操作。
②加法算法
三．测试结果
四．分析与探讨
实验数据正确，部分代码过于赘余，可以精简。
五．附录：源代码#include<>
#include<>
#include<>
typedef struct Polynomial {
float coef;
int expn;
struct Polynomial *next;
}*Polyn,Polynomial;
出多项式a和b\n\t2.多项式相加a+b\n\t3.多项式相减a-b\n");
printf("\t4.多项式相除a*b\n\t5.多项式相除a/b\n\t6.销毁多项式\n");
printf("\t7.退出
\n*********************************** ***********\n");
printf("执行:");
scanf("%d",&flag);
switch(flag)
{
case(1):
printf("多项式a：");PrintPolyn(pa); printf("多项式b：");PrintPolyn(pb);break;
case(2):
pc=AddPolyn(pa,pb);
printf("多项式a+b：");PrintPolyn(pc);
DestroyPolyn(pc);break;
case(3):
pd=SubtractPolyn(pa,pb);
printf("多项式a-b：");PrintPolyn(pd);
DestroyPolyn(pd);break;
case(4):
pf=MultiplyPolyn(pa,pb);
printf("多项式a*b：");PrintPolyn(pf); DestroyPolyn(pf);break;
case(5):
DevicePolyn(pa,pb);
break;
case(6):
DestroyPolyn(pa);
DestroyPolyn(pb);
printf("成功销毁2个一元二项式\n");
printf("\n接下来要执行的操作:\n1 重新创建2个一元二项式 \n2 退出程序\n");
printf("执行:");
scanf("%d",&i);
if(i==1)
{
// Polyn pa=0,pb=0,pc,pd,pf;//定义各式的头指针，pa与pb在使用前付初值NULL
printf("请输入a的项数:");
scanf("%d",&m);
pa=CreatePolyn(pa,m);//
建立多项式a
printf("请输入b的项
数:");
scanf("%d",&n);
pb=CreatePolyn(pb,n);//
建立多项式b
break;}
if(i==2)
return 0; case(7): return 0;
} } } }。