数据结构-多项式
多项式运算(数据结构C++描述)
{
now = pre->next;
while(signal == 0)
{
if(inpt->expn < now->expn)//当新链节小于现在的连接时向后移一个链节
{
if(now->next == NULL)
{
now->next = inpt;
insert(res,inpt);//把当前"g(x)"的链节插入到"y(x)"中
}
return res;
}
node *list::diffnode(node *head) //多项式微分
{
node *pre;
int flag = 0;
pre = head->next;
#include<iostream>
using namespace std;
struct node //定义节点类型
{
float coef;
int expn;
node * next;
};
class list
{
public:
list();
{
node *inpt,*res,*pre;
int flag = 0;
res = new node;//创建链表头
res->next = NULL;
head1 = head1->next;
pre = head2;
while(flag == 0)
{
if(pre->next == NULL)
{
数据结构之多项式创建输出等操作
#include<stdlib.h>#include<malloc.h>typedef struct polynomial {int coef,ex;struct polynomial *next;}POL Y *create_poly(void);POL Y *mul_poly(POLY *,POL Y *);void print_poly(POLY *);int main(void) {POL Y *heada=NULL,*headb=NULL,*headmul=NULL;printf("create the first multinomial:\n"); heada=create_poly();printf("create the second multinomial:\n"); headb=create_poly();printf("The first multinomial:\n");print_poly(heada);printf("The second multinomial:\n");print_poly(headb);headmul=mul_poly(heada, headb);printf("The mul multinomial:");print_poly(headmul);return 0;}//创建多项式POL Y *create_poly() {int iA=0,iE=0;POL Y *head=NULL,*s=NULL,*r=NULL; head=(POLY *)malloc(sizeof(POLY));r=head;printf("please input coef and exponent:\n"); scanf("%d%d",&iA,&iE);while(iA != 0){s=(POLY *)malloc(sizeof(POLY));s->coef=iA, s->ex=iE;r->next=s;r=s;scanf("%d%d",&iA,&iE);}r->next=NULL;return head;}//相乘POL Y *mul_poly(POLY *p1, POL Y *p2) {POL Y *head;POL Y *t,*q,*s,*r;head=(POLY *)malloc(sizeof(POLY)); head->next=NULL;r=(POLY *)malloc(sizeof(POL Y));r->next=NULL;for(t=p1->next;t;t=t->next){for(q=p2->next;q;q=q->next){s=(POLY *)malloc(sizeof(POLY));r->next=s;s->coef=q->coef * t->coef;s->ex=q->ex + t->ex;s->next=NULL;head=add_poly(r,head);}}return head;}//输出void print_poly(POLY *head) {POL Y *p=NULL;p=head->next;if(p == NULL)printf("The multinomial is NULL.\n"); else {do {if(p->coef>=0)printf("+%dx^%d",p->coef,p->ex);elseprintf("%dx^%d",p->coef,p->ex);p=p->next;}while(p != NULL);printf("\n"); }}。
【数据结构算法】实验1 线性表应用-多项式计算(附源代码)
浙江大学城市学院实验报告课程名称数据结构与算法实验项目名称实验一线性表应用---多项式计算实验成绩指导老师（签名）日期一.实验目的和要求1．进一步掌握线性表的的基本操作。
2．掌握线性表的典型应用----多项式表示与计算。
二. 实验内容1．设用线性表( (a1, e1), (a2, e2), ……, (am, em) ) 表示多项式P(x) = a1*x e1 + a2*x e2+…+ am*x em，其中：a1～am为非零系数，0≤e1＜e2＜…..＜em，请编写用链式存储结构（带表头附加结点的单链表）存储该多项式时，多项式基本操作的实现函数。
多项式基本操作应包括初始化多项式、清除多项式、输出多项式、插入一项、删除一项、多项式求值、多项式相加等。
要求：把多项式线性表的结构定义及多项式基本操作实现函数存放在头文件Linkpoly.h中，主函数存放在主文件test6_1.cpp中，在主函数中通过调用Linkpoly.h中的函数进行测试。
2．选做：编写用顺序存储结构存储多项式时，多项式基本操作的实现函数。
要求：把多项式线性表的结构定义及多项式基本操作实现函数存放在文件Seqpoly.h中，在主文件test6_1.cpp中增加测试语句对Seqpoly.h中的函数进行测试。
3．填写实验报告，实验报告文件取名为report1.doc。
4．上传实验报告文件report1.doc与源程序文件test6_1.cpp及Linkpoly.h、Seqpoly.h（若有）到Ftp服务器上自己的文件夹下。
三. 函数的功能说明及算法思路包括每个函数的功能说明，及一些重要函数的算法实现思路※注1：除了[多项式求值]与[多项式相加]两个函数外，线性表的基本操作函数，大部分沿用上学期[线性表的链式/顺序表示和实现]两个实验中的函数。
※注2：选作部分函数功能与思路与非选作部分基本一致，略去思路描述函数：void InitList(LNode *&H)功能：初始化单链表思路：使用附带头结点的方式初始化单链表函数：int LengthList (LNode *H)功能：求单链表长度思路：遍历整个单链表，设置变量记录并返回它的长度函数：bool EmptyList (LNode *H)功能：判断单链表是否为空表思路：判断头结点的后一结点是否为空，若空则为空表函数：void TraverseList(LNode *H)功能：遍历单链表思路：遍历整个单链表，输出所含所有元素函数：bool InsertList ( LNode *&H, ElemType item, int pos)功能：向单链表插入一个元素思路：创建新结点，根据pos的值来确定位置并向单链表中插入新元素。
数据结构一元多项式的运算
目录一、问题分析.................................... 错误!未定义书签。
问题描述 ........................................................................ 错误!未定义书签。
问题的数学模型............................................................. 错误!未定义书签。
构造数据结构................................................................. 错误!未定义书签。
二、系统分析 ...................................................................... 错误!未定义书签。
可行性研究..................................................................... 错误!未定义书签。
系统结构与主要功能模块 ............................................. 错误!未定义书签。
三、系统设计 ...................................................................... 错误!未定义书签。
系统设计目的与要求 ....................................................... 错误!未定义书签。
系统设计内容................................................................... 错误!未定义书签。
功能算法描述与数据结构说明........................................ 错误!未定义书签。
数据结构_一元多项式运算器_cpp代码(visual c++)
multinomialDestroy(L1); //清空L1，用以作为下一轮的存储
multinomialMultiply(La,L2,L1);
multinomialDestroy(L2);
}
multinomialMultiply(La,L1,L2);
if(p->cof > 0)
printf("%c%.3lf",c,p->cof);
else
printf("%.3lf",p->cof);
}
else{
if(p->cof > 0)
printf("%c%.3lfx^%d",c,p->cof,p->ind);
ElemType cof; //多项式系数
int ind; //多项式次幂
struct LNode* next;
} * LinkList;//LinkList是指向LNode的指针！！！！
//多项式的创建(OK)
void multinomialCreat(LinkList &L){
scanf("%d",&L->ind);//用头结点的ind保存多项式项数
for(int i = 0;i < L->ind;i++){
s = (LNode*)malloc(sizeof(LNode));
printf("Please input the multinomial in descending order, every term\'s coefficent and index in form\"a,b\".\n");
数据结构 多项式乘法
实习报告一、实习题：请写出计算两个以单链接表表示的多项式相乘的程序。
1．需求分析和说明两个多项式相乘，可以利用两个多项式的加法来实现，因为乘法运算可以分解为一系列的加法运算：C(x)=A(x)*B(x)=A(x)*(b1x+b2x2+…+b n x n)=∑=niii xbxA1)(先用其中一个多项式去乘以另一个多项式的每一项，得出的若干个多项式按照一定的顺序相加，即幂不同的按照升幂排列，幂相同的将系数相加。
例如：对于(X->1+2X->2)*(2X->2+4X->3).X->1*(2X->2+4X->3)=2X->3+4X->4;2X->2*(2X->2+4X->3)=4X->4+8X->5;排列结果：2X->3+8X-4+8X->52．设计用两个单链表的存储两个多项式，每个结点包含单项式的系数，幂和指向下一个元素地址的指针。
用其中的一个多项式乘以另一个多项式的每一项，随后将所得结果按照升幂顺序排列，最后得到结果。
存储结构：//单项式结构struct Term {float coef; // 系数。
int exp; // 幂指数。
Term( float c, int e) { coef = c; exp = e;}Term( ) { }friend int operator == (const Term & L, const Term & T ) { return L.exp == T.exp; }friend int operator > (const Term & L, const Term & T ) { return L.exp > T.exp; }friend int operator < (const Term & L, const Term & T ) { return L.exp < T.exp; }friend Term & operator += ( Term & L, const Term & T ){ L.coef += T.coef; return L; } //幂指数相同，则系数相加。
数据结构_一元多项式的表示与相加
实验一一元多项式的表示与相加实验目的：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：%6fx^%d",p->cof,p->exp);p=p->next;while (p){if(p->cof>0) printf("+");//系数正负号if (fabs(p->cof)<=0.000001); break;//不输出系数为零的项printf("%6fx^%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语言有些生疏和遗忘，在编程过程中出现很多错误。
数据结构课程方案一元稀疏多项式计算
#include<stdio.h>#include<malloc.h>#include<stdlib.h>//定义多项式的项typedef struct Polynomial{float coef。
int expn。
struct Polynomial *next。
}*Polyn,Polynomial。
void Insert(Polyn p,Polyn h>{if(p->coef==0> free(p>。
//系数为0的话释放结点else{Polyn q1,q2。
q1=h。
q2=h->next。
while(q2&&p->expn<q2->expn>{//查找插入位置q1=q2。
q2=q2->next。
}if(q2&&p->expn==q2->expn>{//将指数相同相合并q2->coef+=p->coef。
free(p>。
if(!q2->coef>{//系数为0的话释放结点q1->next=q2->next。
free(q2>。
}}else{//指数为新时将结点插入p->next=q2。
q1->next=p。
}}}Polyn CreatePolyn(Polyn head,int m>{//建立一个头指针为head、项数为m的一元多项式Polyn p。
p=head=(Polyn>malloc(sizeof(struct Polynomial>>。
head->next=NULL。
for(i=0。
i<m。
i++>{p=(Polyn>malloc(sizeof(struct Polynomial>>。
//建立新结点以接收数据 printf("请输入第%d项的系数与指数:",i+1>。
数据结构多项式相加实验报告doc
数据结构多项式相加实验报告篇一：数据结构实验多项式加法数据结构实验报告实验名称：多项式加减法学号：1XX10419姓名：林强实验日期：XX.5.05一、实验目的通过实现多项式的加减法，对链表有更深入的了解二、实验具体内容1、实验题目1：（1）题目设计一个一元稀疏多项式简单的加减法计算器实现要求：一元稀疏多项式简单计算器的基本功能是：（1）输入并建立多项式：A(x)?7?3x?9x8?5x17；B(x)?8x?22x7?9x8（2）输出多项式（3）多项式A和B相加，建立多项式C＝A＋B，并输出相加的结果多项式C（4）选作：多项式A和B相减，建立多项式C＝A－B，并输出相加的结果多项式D（2）分析1：本程序的任务是实现两个多项式的加法其中多项式的系数为浮点型，指数为整数，输出的结果也为系数和指数。
（1）输入的形式和输入值的范围：输入多项式的系数a和未知数X的指数b，当a和b都为零时，输入结束。
输入值的范围：a为实数，b为整数。
（2）输出形式：输出多项式的系数和多项式未知数X 的指数即(a,b)形式。
（3）程序所能达到的功能，实现两个多项式的加法，并输出最后的结果2：整个程序运行期间实行动态创建节点，一边输入数据，一边创建节点当将全部数据输入到单链表中后再调用多项式加法这个函数，并一边实现多项式的相加，一边释放节点，有效防止了在程序反复运行过程中可能出现系统空间不够分配的现象（3）实验代码typedef int Status;#define OVERFLOW -1#define null 0typedef struct Lnode{float coef; //存储项系数int expn;//存储项指数struct Lnode *next;}Lnode,*LinkList;typedef LinkList polynomial;Status InitList_L(LinkList &L) {//初始化头节点L=(LinkList)malloc(sizeof(Lnode));if(!L)return(-1);L->next=null;return 1;}void AddPolyn(polynomial pa, polynomial pb){ //实现两个多项式相加的算法float x;polynomial qa;polynomial qb;polynomial s;polynomial u;qa=pa->next; qb=pb->next; s=pa;while(qa&&qb){if(qa->expnexpn){s=qa;qa=qa->next;}else if(qa->expn==qb->expn){x=qa->coef+qb->coef;if(x!=0){qa->coef=x;s=qa;qa=qa->next;u=qb;qb=qb->next;free(u);}else{s->next=qa->next;free(qa);qa=s->next;u=qb;qb=qb->next;free(u);}}else if(qa->expn>qb->expn){ u=qb->next;s->next=qb;s=qb;qb->next=qa;qb=u;}}if(qb)qa->next=qb;free(pb);}void main(){float a;int b;polynomial L1;polynomial L2; LinkList q;LinkList p;LinkList m;LinkList n;InitList_L(L1);q=L1;InitList_L(L2);p=L2;cout 请输入数据：" for(;;){ cin>>a;cin>>b;if(a==0&&b==0) break;m=new Lnode;m->coef=a;m->expn=b;q->next=m;q=m;q->next=null;}//循环输入第一个多项式的系数与指数for(;;){cin>>a;cin>>b;if(a==0&&b==0)break;n=new Lnode;n->coef=a;n->expn=b;p->next=n;p=n;p->next=null;}//循环输入第二个多项式的系数与指数AddPolyn(L1,L2);//调用多项式相加的算法while((L1->next)!=null){coutnext->coefnext->expn L1=L1->next;}//输出计算结果}三、实验小结通过编写多项加法这个程序，我将自己所学到的创建链表，初始化链表和多项式加法算法都应用了一次，这使我们不仅仅只是理论化的学习书本上的知识，而是将学习到的理论知识应用到实际的操作中来增强我们的实际操作能力，这使我增加了实际操作经验，也使我通过实际操作来认识到自己在程序编写上的不足从而增强了我的实际编写程序的能力。
数据结构课程设计——一元多项式计算
数据结构课程设计——一元多项式计算一、课程设计题目及要求二、设计思路和方法三、程序流程图四、程序代码及注释五、测试结果及分析六、结论七、参考文献本次课程设计的题目为“一元多项式计算”，要求设计一个程序，能够实现一元多项式的加、减、乘、求导和求值等操作。
在设计思路和方法上，我们采用了链表的数据结构来存储多项式，同时设计了相应的函数来实现各种操作。
程序的流程图如下所示：插入流程图）程序的代码及注释如下所示：插入代码及注释）在测试结果及分析方面，我们对程序进行了多组测试，并对其进行了详细的分析和比较。
结果表明，我们的程序能够正确地实现各种操作，并且具有较高的效率和稳定性。
综上所述，本次课程设计的目标已经得到了圆满地实现，我们对于所取得的成果感到非常满意。
同时，我们也希望能够通过这次课程设计，加深对于数据结构及其应用的理解和掌握，为今后的研究和工作打下坚实的基础。
设计目标：本课程设计旨在结合理论与实际应用，提高学生组织数据及编写大型程序的能力。
通过掌握数据组织、算法设计和算法性能分析的方法，培养学生良好的程序设计能力。
具体实现是利用单链表表示一元多项式，实现多项式的输入、建立、输出、相加、相减和相乘。
总体设计：2.1 数据结构描述与定义：一元多项式定义系数和指数结构如下：coef，expn和next。
定义多项式的结构为线性链表的存储结构，每个结点包含三个元素：系数coef，指数expn和指向下一个结点的指针*next。
多个单项式通过指针连接起来，形成一个多项式。
2.2 模块设计：从实现多项式运算过程的角度来分析，至少需要以下子功能模块：多项式创建、销毁、输出、相加、相减和相乘。
定义并调用的函数有：Insert、CreatePolyn、DestroyPolyn、PrintPolyn、AddPolyn、SubtractPolyn、XXX和main函数。
注：该文章中没有明显的格式错误和需要删除的段落，因此没有进行小幅度改写。
数据结构_用堆栈知识实现简单的多项式计算问题
/*jisuanqi_head.h*/
/*2012年4月15日
made by liuhui*/
#define MAX 1000
struct save1
{
float n[MAX];
int top;
}stack1;
structsave2
{
char n[MAX];
int top;
}stack2;
说明几个函数：
bool stackempty(save1 s)用来判断操作数栈s是否为空。
void push(save1 &s,char e)若栈满则输出“栈已满”，否则将元素e入栈
void pop(save1 &s, char &e)若栈为空则输出“栈为空”，否则将栈顶元素赋给e
bool stackempty2(save2 s)用来判断运算符栈s是否为空。
{
cout<<"栈已满"<<endl;
return ;
}
s.top++;
s.n[s.top]=e;
}
void push2(save2 &s,char e)//将e入栈
{
if(s.top==MAX-1)
{
cout<<"栈已满"<<endl;
void pop(save1 &s,float &e);//将栈顶元素出栈，存到e中
void pop2(save2 &s,char &e);//将栈顶元素出栈，存到e中
int in(char e);//e在栈内的优先级别
int out(char e);//e在栈外的优先级别
数据结构 多项式的表示和实现方法
数据结构多项式的表示和实现方法摘要：1.多项式的基本概念2.多项式的表示方法a.系数矩阵表示b.字符串表示c.列表表示3.多项式的基本操作a.加法b.减法c.乘法d.除法4.多项式的实现方法a.递归实现b.循环实现c.迭代实现5.多项式的应用场景a.数值计算b.符号计算c.算法设计分析6.多项式的优缺点分析7.总结与展望正文：一、多项式的基本概念多项式作为数学中的重要概念，广泛应用于各个领域。
它是由一系列项组成的代数式，其中每个项包含一个常数系数和一个或多个变量，这些变量之间的运算符为加法或减法。
多项式的项按照幂次从高到低排列，同一幂次的项按照系数从大到小排列。
二、多项式的表示方法1.系数矩阵表示：将多项式的系数组成一个矩阵，其中行表示多项式的次数，列表示多项式的项数。
例如，二次多项式f(x)=ax+bx+c可以表示为：| a b c || 0 1 0 |2.字符串表示：将多项式的各项用字符串表示，如f(x)=ax+bx+c可以表示为"a*x+b*x+c"。
3.列表表示：将多项式的各项用列表表示，如[a, b, c, 0]。
三、多项式的基本操作1.加法：将两个多项式对应的项相加，保持幂次不变，系数相加。
2.减法：将两个多项式对应的项相减，保持幂次不变，系数相减。
3.乘法：将两个多项式按照乘法法则相乘，得到一个新的多项式。
4.除法：将一个多项式除以另一个多项式，得到一个新的多项式。
四、多项式的实现方法1.递归实现：利用多项式的定义，将多项式分解为单项式，然后通过递归实现加法、减法、乘法和除法。
2.循环实现：利用循环结构，如for循环或while循环，遍历多项式的各项，实现加法、减法、乘法和除法。
3.迭代实现：利用迭代器，如ListIterator，遍历多项式的各项，实现加法、减法、乘法和除法。
五、多项式的应用场景1.数值计算：多项式在数值计算中具有重要作用，如求解线性方程组、非线性方程组和微分方程等。
数据结构习题：一元多项式的加法乘法实现
求解思路
1.多项式表示 2. 程序框架 3. 读多项式 4. 加法实现 5. 乘法实现 6. 多项式输出
多项式的表示
仅表示非零项
数组： 编程简单、调试容易
需要事先确定数组大小
一种比较好的实现方法是: 动态数组
链表：
动态性强 编程略为复杂、调试比较困难
2.逐项插入
将P1当前项(c1i,e1i)乘P2当前项（c2i,e2i),并插入到结果多项式 中。关键是要找到插入位置
初始结果多项式可由P1第一项乘P2获得（如上）
如何将两个多项式相乘
Polynomial Mult( Polynomial P1, Polynomial P2 )
{
…….
t1 = P1; t2 = P2;
return 0; }
如何读入多项式
Polynomial ReadPoly() {
…… scanf("%d", &N); …… while ( N-- ) {
scanf("%d %d", &c, &e); Attach(c, e, &Rear); } ….. return P; }
4 3 4 -5 2 6 1 -2 0
Attach
ce
*pRear
P *pRear
(当前结果表达式尾项指针) (新节点)
如何读入多项式
Polynomial ReadPoly() {
Polynomial P, Rear, t; int c, e, N;
scanf("%d", &N);
P = (Polynomial)malloc(sizeof(struct PolyNode)); /* 链表头空结点 */
数据结构--线性表的基本运算及多项式的算术运算
数据结构:线性表的基本运算及多项式的算术运算一、实验目的和要求实现顺序表和单链表的基本运算，多项式的加法和乘法算术运算。
要求：能够正确演示线性表的查找、插入、删除运算。
实现多项式的加法和乘法运算操作。
二、实验环境(实验设备)X64架构计算机一台，Windows 7操作系统，IDE: Dev C++ 5.11编译器: gcc 4.9.2 64bit二、实验原理及内容程序一：实现顺序表和单链表的实现本程序包含了四个文件，分别是LinearListMain.cpp，linearlist.h，seqlist.h，singlelist.h。
分别是主程序，线性表抽象类，顺序储存线性表的实现，链表储存顺序表的实现。
文件之间的关系图：本程序一共包含了三个类：分别是LinearList（线性表抽象类），SeqList（顺序储存的线性表），SingleList（链表储存的线性表）。
类与类之间的关系图如下：其实，抽象类LinearList规定了公共接口。
分别派生了SeqList类和SingleList。
SingleList类与SingleList类分别实现了LinearList类中的所有接口。
程序代码以及分析：Linearlist类：#include <iostream>using namespace std;template <class T>class LinearList{protected:int n; //线性表的长度public:virtual bool IsEmpty() const=0; //判读是否是空线性表virtual int Length() const=0; //返回长度virtual bool Find(int i,T& x) const=0; //将下标为i的元素储存在x中，成功返回true，否则返回falsevirtual int Search(T x) const=0; //寻找值是x的元素，找到返回true，否则返回falsevirtual bool Insert(int i,T x)=0; //在下标为i的元素后面插入xvirtual bool Delete(int i)=0; //删除下标为i的元素virtual bool Update(int i,T x)=0;//将下标为i的元素更新为x virtual void Output(ostream& out)const=0; //将线性表送至输出流};包含了一个保护数据成员n，和8种运算，具体说明见注释。
数据结构 多项式乘法
数据结构多项式乘法数据结构之多项式乘法
⒈引言
⒉基本概念
⑴多项式及其表示
⑵多项式的系数与次数
⑶多项式相乘的定义
⒊多项式乘法算法
⑴暴力法
⑵ Karatsuba算法
⑶快速傅里叶变换法
⒋算法实现及优化
⑴暴力法的实现
⑵ Karatsuba算法的实现
⑶快速傅里叶变换法的实现
⑷优化方案
⒌实验及性能评估
⑴实验设计
⑵实验结果及分析
⑶算法性能比较
⒍应用场景与案例
⑴多项式求解问题
⑵数据压缩与编码
⑶计算机图形学中的应用⒎实际应用中的注意事项
⑴数据规模与性能的平衡
⑵浮点数运算的精度问题⒏结论与展望
⑴本文的主要贡献
⑵未来工作的方向
⒐附件
⑴代码实现
⑵实验数据
⑶相关论文
⒑法律名词及注释
⑴版权法
⑵计算机软件保护相关法规
⑶专利法和专利申请程序
⑷商标法
附件：
⒈代码实现：包括暴力法、Karatsuba算法和快速傅里叶变换法的多项式乘法实现代码。
⒉实验数据：包含了多种数据规模下的实验数据，用于验证算法的正确性和性能。
⒊相关论文：列出了本文涉及到的相关论文及其或引用信息。
法律名词及注释：
⒈版权法：指保护原创作品的法律法规，包括著作权和相关权益的保护。
⒉计算机软件保护相关法规：指保护计算机软件的法律法规，包括软件著作权法等。
⒊专利法和专利申请程序：指保护发明创造的专利法律法规，包括专利的申请、审查、授权和实施等。
⒋商标法：指保护商标的法律法规，包括商标的注册、使用和保护等。
数据结构课程设计-一元多项式计算器
一、需求分析1. 问题描述设计一个一元稀疏多项式简单计算器。
2. 基本要求一元稀疏多项式简单计算器的基本功能是：(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 。
3. 测试数据(1) (2x++(7-5x8+11x9)=+11x9+2x+7)(2) (6x-3-x+ (3) (1+x+x2+x3+x4+x5)+(-x3-x4)=(1+x+x2+x5)(4) (x+x3)+(-x-x3)=0(5) (x+x100)+(x100+x200)=(x+2x100+x200)(6) (x+x2+x3)+0=(x+x2+x3)(7) 互换测试数据的前后两个多项式。
4. 实现提示用带表头结点的单链表存储多项式。
二、概要设计为实现上述程序功能，应用带头结点的单链表存储多项式。
为此需要一个抽象数据类型：一元多项式。
1.抽象数据类型一元多项式定义为：ATD Ploynomial{数据对象：D={ai|ai∈Termset, i=1,2,3···，m,m≥0 Termset中的每个元素包含一个表示系数的实数和表示指数的整数}数据关系：R1={<ai-1,ai>ai-1,ai∈D,且ai-1中的指数<ai中的指数的值，i=1,2,3···n}基本操作：Insert(p,h)初始条件：h已存在。
操作结果：插入p项。
CreateLinklist(head, m)操作结果：建立一个头指针为head、项数为m的一元多项式。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
一.实验目的：
理解线性表的基本逻辑结构，完成链表及循环链表的实现
通过实验进一步理解线性表的逻辑结构和存储结构，提高使用理论知识指导解决实际问题的能力，熟练掌握链表的实际应用。
二.实验内容：
题目：一元多项式运算
问题描述：
设计算法实现一元多项式的简单运算。
基本要求：
（1）输入并建立多项式;
（2）输出多项式;
（3）多项式加法
（4）多项式减法。
测试数据：
（1）(2x+5x8－3.1x11)+(7－5x8+11x9)=(－3.1x11+11x9+2x+7)
（2）(6x－3－x+4.4x2－1.2x9)－(―6x―3－+5.4x2－x2+7.8x15) =(―7.8x15―1.2x9+12x―3―x)
（3）(1+x+x2+x3+x4+x5)+(―x3―x4)=(1+x+x2+x5)
（4）(x+x3)+(―x―x3)=0
（5）(x+x100)+(x100+x200)=(x+2x100+x200)
（6）(x+x2+x3)+0=x+x2+x3
三. 实验方案（程序设计说明）
（一）算法设计思路：
1.将两个多项式的系数和指数分别存放在新建的两个链表中；
2.其中一个链表A的指针不动，遍历另一个链表B，指数相等
时系数相加，删除该数，链表B从头开始,链表A移向下个
数据域；
3.直到链表B为空或者链表A遍历完成结束。
（二）算法流程图：
（三）界面设计说明：
请输入多项式的长度： 开始
输入多项式长
度N 以及系数
m,指数n
A →n=
B →n? Y
N
j++
系数相加存放在A 表
i++ 结束
创建链表A ，B ，链表A 从i=0
开始循环，链表B 从j=0开始
i>N?
N
Y
i>N?
N
Y
请输入第一个多项式的系数、指数：
请输入另一个多项式的系数、指数：
加法按1，减法按2
（四）使用模块及变量的说明
实验：m→系数；n→指数；A、B链表
四. 实验步骤或程序（经调试后正确的源程序）实验二：（多项式）
#include "stdafx.h"
#include <iostream>
#include "conio.h"
using namespace std;
typedef struct lnode
{
int m;//系数
int n;//指数
struct lnode*next;
} LNode, *LinkList;
LinkList Creat(LinkList L, int i)
{
LNode *r = NULL, *s;
int m, n;
for (int j = 0; j<i; j++)
{
scanf_s("%d%d", &m, &n);
s = new LNode;
s->m = m;
s->n = n;
if (L == NULL) L = s;
else r->next = s;
r = s;
}
if (r != NULL)
r->next == NULL;
return L;
}
void Combine(LinkList p, LinkList q, int x, int i, int j) {
LinkList s = p, a = q;
LNode*pre;
pre = s;
int k = 0, r = 0;
for (; r<i; r++)
{
if (s->n == q->n)
{
switch (x)
{
case 1:q->m += s->m; break;
case 2:q->m -= s->m; break;
}
q = q->next;
if (s == p)
{
p = p->next;
free(s);
s = p;
pre = s;
}
else
{
pre->next = s->next;
delete s;
s = p;
pre = s;
}
}
else
{
pre = s;
s = s->next;
}
k++;
if (k >= j)
s = p;
}
/*
if (r >= i&&p != NULL)
{
p->next = q->next;
q->next = p;
free(p);
p = p->next;
}
*/
for (; i > 0; i--)//while (a->next!=NULL) {
cout << a->m << "\t" << a->n << endl;
a = a->next;
}
}
int main()
{
LinkList A = NULL, B = NULL;
int x;
printf("\n请输入多项式的长度:");
scanf_s("%d", &x);
printf("\n请输入第一个多项式系数、指数:\n");
A = Creat(A, x);
printf("\n请输入另一个多项式系数、指数:\n");
B = Creat(B, x);
int ch;
printf("\n加法按1，减法按2\t");
scanf_s("%d", &ch);
Combine(A, B, ch, x, x);
_getch();
}
五．程序运行结果
六．实验总结
通过完成此次实验，我对链表有了进一步的理解。
我体会到编程不仅需要c语言及数据结构知识，还需要对实验目的有清楚的理解、对目的的实现有清晰的思路，只有这样，才有可能更快更好地完成任务。