一元多项式的表示及相加
第1关：基于链表的两个一元多项式的基本运算
第1关：基于链表的两个一元多项式的基本运算在计算机科学中，一元多项式是常见的代数表达式形式，通常用来表示多项式函数。
虽然一元多项式的计算看似简单，但如果使用数据结构来实现，将会大大提高计算效率。
这篇文档将详细介绍基于链表的两个一元多项式的基本运算。
一元多项式的定义：在代数学中，一元多项式是一种含有一个未知数的代数多项式。
它是指一个代数式，它是由保持仅仅又有限个多项式的乘积。
此外，一元多项式在基本运算方面具有封闭性，这也是为什么它被广泛应用的原因之一。
在这里，我们将讨论在计算机科学中对一元多项式的实现。
链表的定义：链表是一种线性数据结构，其中数据元素不是常规的数组索引组织，而是通过信息存储元素之间的链来相互连接。
每个元素被称为节点，并且每个节点包含一个下一个节点的指针。
基于链表的一元多项式的实现：基于链表的一元多项式的实现涉及到将每个多项式的系数和指数存储为链表中的节点。
这种实现的主要优点是，它可以轻松地进行添加和删除操作，可以有效地分配内存，而不会浪费存储空间。
考虑到一元多项式的基本运算包括加法，减法和乘法，我们将详细介绍每种操作的实现。
一、基于链表的两个一元多项式的加法操作在实现一元多项式加法时，我们需要创建两个链表来存储两个多项式。
链表节点应该包含两个属性：系数和指数。
然后我们可以使用以下方法将两个多项式相加。
1. 定义两个指针p1和p2分别指向多项式链表的头部。
2. 定义一个新链表，用于存储相加的项。
3. 当p1和p2都不为空时循环进行以下操作：a. 如果p1当前节点的指数小于p2当前节点的指数，则将p1的节点添加到新链表中并将p1指针向下移动一个节点。
b. 如果p1当前节点的指数大于p2当前节点的指数，则将p2的节点添加到新链表中并将p2指针向下移动一个节点。
c. 如果p1和p2当前节点的指数相等，则将两个节点的系数相加，并将结果添加到新链表中，并将p1和p2指针都向下移动一个节点。
的所有剩余项添加到新链表中。
一元多项式的表示与相加
一元多项式的表示与相加
一元多项式是指只含有一个变量的多项式，其表示方式通常为：
f(x) = a0 + a1x + a2x^2 + …+ anxn
其中，a0、a1、a2……an是多项式的系数，n是多项式的次数，x是变量，^表示“次方”的意思。
一元多项式的相加可以通过对应同次幂的系数进行相加的方式实现。
例如，给定两个一元二次多项式：
f(x) = 2x^2 - 3x + 1
g(x) = x^2 + 2x - 3
我们可以将它们相加，得到下面的结果：
f(x) + g(x) = (2+1)x^2 + (-3+2)x + (1-3)
= 3x^2 - x - 2
因此，将两个一元多项式相加时，需要先确定它们的次数，并将同次幂的系数相加后得到新的系数。
如果某个多项式的次数高于另一个多项式，则需要在较低次数的多项式中补充0作为系数再进行相加。
一元多项式相加问题实验报告
一元多项式相加问题实验报告一元多项式相加问题一、问题描述通过键盘输入两个形如P 0 +P 1 X 1 +P 2 X 2 +…+P n X 的多项式，经过程序运后在屏幕上输出它们的相加和。
二、数据结构设计一个一元多项式的每一个子项都由“系数-指数”两部分组成，因此可将其抽象为包含系数coef、指数exp、指针域next 构成的链式线性表。
将两个多项式分别存放在两个线性表中，然后经过相加后将所得多项式存放在一个新的线性表中，但是不用再开辟新的存储空间，只依靠结点的移动来构成新的线性表，期间可以将某些不需要的空间回收。
基于这样的分析，可以采用不带头结点的单链表来表示一个一元多项式。
具体数据类型定义为：struct node {float coef;//系数域int exp;//指数域struct node *next; }; 三、功能函数设计1、输入多项式的系数和指数初始化多项式的功能模块具体函数为node *in_fun() 此函数的处理较为全面，要求用户按照指数递增的顺序和一定的输入格式输入各个系数不为0 的子项，输入一个子项建立一个相关结点，当遇到输入结束标志时停止输入。
关键步骤具体如下：⑴控制用户按照指数递增的顺序输入r=a; while(r!=q-next){if(y=r-exp){cout“请按照指数递增顺序输入,请重新输入“;cinxy;break;}r=r-next;} 从头开始遍历，若遇到目前输入的指数不是最大时，就跳出循环，让用户重新输入。
⑵当输入的系数为零时，不为其分配存储空间存储while(x==0) { cinxy; continue;} 即若系数为0，不再进行动态分配并新建结点，而是重新提取用户输入的下一个子项的系数和指数，利用continue 进入下一次循环。
⑶初始化完成后将最后一个结点的指针域置为空，并返回该新建链表的首地址。
if(q!=NULL)q-next=NULL;return a; ⑷动态分配空间新建结点存储系数和指数的代码如下：p=new node;p-coef=x;p-exp=y;if(a==NULL) a=p;else q-next=p;q=p; 2、多项式显示功能函数由于系数有正有负，故采取如下处理：对于正数，输出时在前面加“+”，头指针除外；对于负数，直接将系数输出即可，即：p=a;while(p){if(p==a)coutp-coef"*x^"p-else if(p-coef0)coutp-coef"*x^"p-else if(p-coef0)cout"+"p-coef"*x^"p-p=p-next;} 输出的多项式的形式形如：P 1 X^1+P 2 X^2+…+P n X^n 3、多项式相加的功能函数函数为：node *plus_fun(node *a,node *b) 此函数根据在 1 中初始化的两个多项式进行相加运算，并存放在以c 为头指针的一个新链表中。
一元多项式计算(数据结构课程设计)
一元多项式计算(数据结构课程设计)一、系统设计1、算法思想根据一元多项式相加的运算规则：对于两个一元多项式中所有指数相同的项，对应指数相加（减），若其和（差）不为零，则构成“和（差）多项式”中的一项；对于两个一元多项式中所有指数不相同的项，则分别写到“和（差）多项式”中去。
因为多项式指数最高项以及项数是不确定的，因此采用线性链表的存储结构便于实现一元多项式的运算。
为了节省空间，我采用两个链表分别存放多项式a 和多项式b，对于最后计算所得的多项式则利用多项式a进行存储。
主要用到了单链表的插入和删除操作。
(1)一元多项式加法运算它从两个多项式的头部开始，两个多项式的某一项都不为空时，如果指数相等的话，系数就应该相加；相加的和不为零的话，用头插法建立一个新的节点。
P 的指数小于q的指数的话就应该复制q的节点到多项式中。
P的指数大于q的指数的话，就应该复制p节点到多项式中。
当第二个多项式空，第一个多项式不为空时，将第一个多项式用新节点产生。
当第一个多项式空，第二个多项式不为空时，将第二个多项式用新节点产生。
(2)一元多项式的减法运算它从两个多项式的头部开始，两个多项式的某一项都不为空时，如果指数相等的话，系数就相减；相加的和不为零的话，用头插法建立一个新的节点。
p的指数小于q的指数的话，就应该复制q的节点到多项式中。
P的指数大于q的指数的话就应该复制p的节点到多项式中，并且建立的节点的系数为原来的相反数；当第二个多项式空，第一个多项式不为空时，将第一个多项式用新节点产生。
当第一个多项式空，第二个多项式不为空时，将第二个多项式用新节点产生，并且建立的节点的系数为原来的相反数。
2、概要设计(1)主函数流程图：（注：a代表第一个一元二次方程，b代表第二个一元二次方程）(2)一元多项式计算算法用类C语言表示：Typedef struct00{ //项的表示，多项式的项作为LinkList的数据元素Float coef；//细数Int expn；//指数}term，ElemType；//两个类型名：term用于本ADT，ElemType为LinkList的数据对象名Typedef LinkList polynomial：//用带表头的节点的有序链表表示多项式//基本操作的函数原型说明Void CreatePolyn（polynomail&P）；//输入n的系数和指数，建立表示一元多项式的有序链表P 销毁一元多项式P Void DestroyPolyn（polynomailP）；销毁一元多项式PvoidPrintPoly（polynomail P）；//打印输入一元多项式PIntPolynLength（polynnomail P);//返回一元多项式P中的项数void CreatPolyn（polynomail&Pa.polunomail&Pb);//完成多项式相加运算，即:Pa=Pa+Pb,并贤惠一元多项式Pb voidSubtractPolyn（polunomail&Papolunomail&Pb）；//完成多项式相减运算，即：Pa=Pa-Pb，并销毁一元多项式Pb//基本操作的算法描述Int cmp(tem a，temp b）；//依a的指数值<（或=）（或>b的住数值，分别返回-1、0和+1Void CreatePolyn（polynomail&P,int m){//输入m项的系数和指数，建立表示一元多项式的有序链表PInitList（P）；h=GetHead（P）；E.coef=0.0； e.expn=-1；S erCurElem（h，e）；//设置头结点的数据元素For （i=1；i<=m；++i）{ //依次输入m个非零项Scanf（e.coef，e.epn）；If（！LocateElem（P，e，q，（*cmp）（）））{//当前链表中不存在该指数项If(MakeNode（s，e））InsFirst（q，s）；//生成节点并插入链表}}}//CreatPolun二、详细设计1、算法实现(1)输入一元多项式函数：void shuchu(pnode *head){pnode *p;int one_time=1;p=head;while(p!=NULL) /*如果不为空*/{if(one_time==1){if(p->zhishu==0) /*如果指数为0的话，直接输出系数*/printf("%5.2f",p->xishu); /*如果系数是正的话前面就要加+号*/else if(p->xishu==1||p->xishu==-1)printf("X^%d",p->zhishu); /*如果系数是1的话就直接输出+x*//*如果系数是-1的话就直接输出-x号*/else if(p->xishu>0) /*如果系数是大于0的话就输出+系数x^指数的形式*/ printf("%5.2fX^%d",p->xishu,p->zhishu);else if(p->xishu<0) /*如果系数是小于0的话就输出系数x^指数的形式*/ printf("%5.2fX^%d",p->xishu,p->zhishu);one_time=0;}else{if(p->zhishu==0) /*如果指数为0的话，直接输出系数*/{if(p->xishu>0)printf("+%5.2f",p->xishu); /*如果系数是正的话前面就要加+号*/}else if(p->xishu==1) /*如果系数是1的话就直接输出+x号*/printf("+X^%d",p->zhishu);else if(p->xishu==-1) /*如果系数是-1的话就直接输出-x号*/printf("X^%d",p->zhishu);else if(p->xishu>0) /*如果系数是大于0的话就输出+系数x^指数的形式*/ printf("+%5.2fX^%d",p->xishu,p->zhishu);else if(p->xishu<0) /*如果系数是小于0的话就输出系数x^指数的形式*/printf("%5.2fX^%d",p->xishu,p->zhishu);}p=p->next; /*指向下一个指针*/}printf("\n");}(2)加法函数/*两个多项式的加法运算*/pnode * add(pnode *heada,pnode *headb){pnode *headc,*p,*q,*s,*r; /*headc为头指针，r,s为临时指针，p指向第1个多项式并向右移动，q指向第2个多项式并向右移动*/float x; /*x为系数的求和*/p=heada; /*指向第一个多项式的头*/q=headb; /*指向第二个多项式的头*/headc=(pnode *)malloc(sizeof(pnode)); /*开辟空间*/r=headc;while(p!=NULL&&q!=NULL) /*2个多项式的某一项都不为空时*/{if(p->zhishu==q->zhishu) /*指数相等的话*/{x=p->xishu+q->xishu; /*系数就应该相加*/if(x!=0) /*相加的和不为0的话*/{s=(pnode *)malloc(sizeof(pnode)); /*用头插法建立一个新的节点*/s->xishu=x;s->zhishu=p->zhishu;r->next=s;r=s;}q=q->next;p=p->next; /*2个多项式都向右移*/}else if(p->zhishu<q->zhishu) /*p的系数小于q的系数的话，就应该复制q节点到多项式中*/{s=(pnode *)malloc(sizeof(pnode));s->xishu=q->xishu;s->zhishu=q->zhishu;r->next=s;r=s;q=q->next; /*q向右移动*/}else/*p的系数大于q的系数的话，就应该复制p节点到多项式中*/{s=(pnode *)malloc(sizeof(pnode));s->xishu=p->xishu;s->zhishu=p->zhishu;r->next=s;r=s;p=p->next; /*p向右移动*/}}/*当第2个多项式空，第1个数不为空时，将第一个数剩下的全用新节点产生*/ while(p!=NULL){s=(pnode *)malloc(sizeof(pnode));s->xishu=p->xishu;s->zhishu=p->zhishu;r->next=s;r=s;p=p->next;}/*当第1个多项式空，第1个数不为空时，将第2个数剩下的全用新节点产生*/ while(q!=NULL){s=(pnode *)malloc(sizeof(pnode));s->xishu=q->xishu;s->zhishu=q->zhishu;r->next=s;r=s;q=q->next;}r->next=NULL; /*最后指向空*/headc=headc->next; /*第一个头没有用到*/return headc; /*返回头接点*/}(3)减法函数/*两个多项式的加法运算*/pnode * add(pnode *heada,pnode *headb){pnode *headc,*p,*q,*s,*r; /*headc为头指针，r,s为临时指针，p指向第1个多项式并向右移动，q指向第2个多项式并向右移动*/float x; /*x为系数的求和*/p=heada; /*指向第一个多项式的头*/q=headb; /*指向第二个多项式的头*/headc=(pnode *)malloc(sizeof(pnode)); /*开辟空间*/r=headc;while(p!=NULL&&q!=NULL) /*2个多项式的某一项都不为空时*/{if(p->zhishu==q->zhishu) /*指数相等的话*/{x=p->xishu+q->xishu; /*系数就应该相加*/if(x!=0) /*相加的和不为0的话*/{s=(pnode *)malloc(sizeof(pnode)); /*用头插法建立一个新的节点*/s->xishu=x;s->zhishu=p->zhishu;r->next=s;r=s;}q=q->next;p=p->next; /*2个多项式都向右移*/}else if(p->zhishu<q->zhishu) /*p的系数小于q的系数的话，就应该复制q节点到多项式中*/{s=(pnode *)malloc(sizeof(pnode));s->xishu=q->xishu;s->zhishu=q->zhishu;r->next=s;r=s;q=q->next; /*q向右移动*/}else/*p的系数大于q的系数的话，就应该复制p节点到多项式中*/{s=(pnode *)malloc(sizeof(pnode));s->xishu=p->xishu;s->zhishu=p->zhishu;r->next=s;r=s;p=p->next; /*p向右移动*/}}/*当第2个多项式空，第1个数不为空时，将第一个数剩下的全用新节点产生*/ while(p!=NULL){s=(pnode *)malloc(sizeof(pnode));s->xishu=p->xishu;s->zhishu=p->zhishu;r->next=s;r=s;p=p->next;}/*当第1个多项式空，第1个数不为空时，将第2个数剩下的全用新节点产生*/ while(q!=NULL){s=(pnode *)malloc(sizeof(pnode));s->xishu=q->xishu;s->zhishu=q->zhishu;r->next=s;r=s;q=q->next;}r->next=NULL; /*最后指向空*/headc=headc->next; /*第一个头没有用到*/return headc; /*返回头接点*/}2、程序代码/*一元多项式计算*//*程序功能：能够按照指数降序排列建立并输出多项式；能够完成两个多项式的相加、相减，并将结果输出；*//*提示：输入完一元多项式之后，输入“0 0”结束本一元多项式的输入*//*注意：系数只精确到百分位，最大系数只能为999.99,指数为整数.如果需要输入更大的系数，可以对程序中5.2%f进行相应的修改*/#include<stdio.h>#include<malloc.h>#include<stdlib.h>#include<conio.h>/*建立结构体*/typedef struct pnode{float xishu; /*系数*/int zhishu; /*指数*/struct pnode *next; /*下一个指针*/}pnode;/*用头插法生成一个多项式，系数和指数输入0时退出输入*/pnode * creat()int m;float n;pnode *head,*rear,*s; /*head为头指针，rear和s为临时指针*/ head=(pnode *)malloc(sizeof(pnode));rear=head; /*指向头*/scanf("%f",&n); /*系数*/scanf("%d",&m); /*输入指数*/while(n!=0) /*输入0退出*/{s=(pnode *)malloc(sizeof(pnode));s->xishu=n;s->zhishu=m;s->next=NULL;rear->next=s; /*头插法*/rear=s;scanf("%f",&n); /*输入系数*/scanf("%d",&m); /*输入指数*/}head=head->next; /*第一个头没有用到*/return head;}/*调整多项式*/void tiaozhen(pnode *head){pnode *p,*q,*t;float temp;p=head;while(p!=NULL){q=p;t=q->next;while(t!=NULL){if(t->zhishu>q->zhishu)q=t;t=t->next;}temp=p->xishu;p->xishu=q->xishu;q->xishu=temp;temp=p->zhishu;p->zhishu=q->zhishu;q->zhishu=temp;p=p->next;}/*显示一个多项式*/void shuchu(pnode *head){pnode *p;int one_time=1;p=head;while(p!=NULL) /*如果不为空*/{if(one_time==1){if(p->zhishu==0) /*如果指数为0的话，直接输出系数*/printf("%5.2f",p->xishu); /*如果系数是正的话前面就要加+号*/else if(p->xishu==1||p->xishu==-1)printf("X^%d",p->zhishu); /*如果系数是1的话就直接输出+x*//*如果系数是-1的话就直接输出-x号*/else if(p->xishu>0) /*如果系数是大于0的话就输出+系数x^指数的形式*/ printf("%5.2fX^%d",p->xishu,p->zhishu);else if(p->xishu<0) /*如果系数是小于0的话就输出系数x^指数的形式*/ printf("%5.2fX^%d",p->xishu,p->zhishu);one_time=0;}else{if(p->zhishu==0) /*如果指数为0的话，直接输出系数*/{if(p->xishu>0)printf("+%5.2f",p->xishu); /*如果系数是正的话前面就要加+号*/}else if(p->xishu==1) /*如果系数是1的话就直接输出+x号*/printf("+X^%d",p->zhishu);else if(p->xishu==-1) /*如果系数是-1的话就直接输出-x号*/printf("X^%d",p->zhishu);else if(p->xishu>0) /*如果系数是大于0的话就输出+系数x^指数的形式*/ printf("+%5.2fX^%d",p->xishu,p->zhishu);else if(p->xishu<0) /*如果系数是小于0的话就输出系数x^指数的形式*/ printf("%5.2fX^%d",p->xishu,p->zhishu);}p=p->next; /*指向下一个指针*/}printf("\n");/*两个多项式的加法运算*/pnode * add(pnode *heada,pnode *headb){pnode *headc,*p,*q,*s,*r; /*headc为头指针，r,s为临时指针，p指向第1个多项式并向右移动，q指向第2个多项式并向右移动*/float x; /*x为系数的求和*/p=heada; /*指向第一个多项式的头*/q=headb; /*指向第二个多项式的头*/headc=(pnode *)malloc(sizeof(pnode)); /*开辟空间*/r=headc;while(p!=NULL&&q!=NULL) /*2个多项式的某一项都不为空时*/{if(p->zhishu==q->zhishu) /*指数相等的话*/{x=p->xishu+q->xishu; /*系数就应该相加*/if(x!=0) /*相加的和不为0的话*/{s=(pnode *)malloc(sizeof(pnode)); /*用头插法建立一个新的节点*/s->xishu=x;s->zhishu=p->zhishu;r->next=s;r=s;}q=q->next;p=p->next; /*2个多项式都向右移*/}else if(p->zhishu<q->zhishu) /*p的系数小于q的系数的话，就应该复制q节点到多项式中*/{s=(pnode *)malloc(sizeof(pnode));s->xishu=q->xishu;s->zhishu=q->zhishu;r->next=s;r=s;q=q->next; /*q向右移动*/}else/*p的系数大于q的系数的话，就应该复制p节点到多项式中*/{s=(pnode *)malloc(sizeof(pnode));s->xishu=p->xishu;s->zhishu=p->zhishu;r->next=s;r=s;p=p->next; /*p向右移动*/}}/*当第2个多项式空，第1个数不为空时，将第一个数剩下的全用新节点产生*/ while(p!=NULL){s=(pnode *)malloc(sizeof(pnode));s->xishu=p->xishu;s->zhishu=p->zhishu;r->next=s;r=s;p=p->next;}/*当第1个多项式空，第1个数不为空时，将第2个数剩下的全用新节点产生*/ while(q!=NULL){s=(pnode *)malloc(sizeof(pnode));s->xishu=q->xishu;s->zhishu=q->zhishu;r->next=s;r=s;q=q->next;}r->next=NULL; /*最后指向空*/headc=headc->next; /*第一个头没有用到*/return headc; /*返回头接点*/}/*两个多项式的减法运算*/pnode * sub(pnode *heada,pnode *headb){pnode *headc,*p,*q,*s,*r;float x; /*x为系数相减*/p=heada; /*指向第一个多项式的头*/q=headb; /*指向第二个多项式的头*/headc=(pnode *)malloc(sizeof(pnode)); /*开辟空间*/r=headc;while(p!=NULL&&q!=NULL) /*两个多项式的某一项都不为空时*/{if(p->zhishu==q->zhishu) /*指数相等的话*/{x=p->xishu-q->xishu; /*系数相减*/if(x!=0) /*相减的差不为0的话*/{s=(pnode *)malloc(sizeof(pnode)); /*用头插法建立一个新的节点*/s->xishu=x;s->zhishu=p->zhishu;r->next=s;r=s;}q=q->next;p=p->next; /*2个多项式都向右移*/}else if(p->zhishu<q->zhishu) /*p的系数小于q的系数的话*/{s=(pnode *)malloc(sizeof(pnode));s->xishu=-q->xishu; /*建立的节点的系数为原来的相反数*/s->zhishu=q->zhishu;r->next=s;r=s;q=q->next;}else{s=(pnode *)malloc(sizeof(pnode));s->xishu=p->xishu;s->zhishu=p->zhishu;r->next=s;r=s;p=p->next; /*p向右移动*/}}while(p!=NULL) /*当第2个多项式空，第1个数不为空时，将第一个数剩下的全用新节点产生*/{s=(pnode *)malloc(sizeof(pnode));s->xishu=p->xishu;s->zhishu=p->zhishu;r->next=s;r=s;p=p->next;}while(q!=NULL) /*当第1个多项式空，第1个数不为空时，将第2个数剩下的全用新节点产生*/{s=(pnode *)malloc(sizeof(pnode));s->xishu=-q->xishu; /*建立的节点的系数为原来的相反数*/ s->zhishu=q->zhishu;r->next=s;r=s;q=q->next;}r->next=NULL; /*最后指向空*/headc=headc->next; /*第一个头没有用到*/return headc; /*返回头接点*/}void add_main(){pnode * a,*b,*c;printf("\n输入第一个一元多项式:\n系数指数\n");a=creat();tiaozhen(a);printf("\n输入第二个一元多项式:\n系数指数\n");b=creat();tiaozhen(b);c=add(a,b);printf("第一个一元多项式如下:");shuchu(a);printf("第二个一元多项式如下:");shuchu(b);printf("两式相加如下:");shuchu(c);}void sub_main(){pnode * a,*b,*c;printf("\n输入第一个一元多项式:\n系数指数\n");a=creat();tiaozhen(a);printf("\n输入第二个一元多项式:\n系数指数\n");b=creat();tiaozhen(b);c=sub(a,b);printf("第一个一元多项式如下:");shuchu(a);printf("第二个一元多项式如下:");shuchu(b);printf("两式相减如下:");shuchu(c);}void open(){printf("\n****************************************************\n");printf(" 功能项: * 1 两个一元多项式相加;2 两个一元多项式相减;0 退出*\n");printf("****************************************************\n\n请选择操作: ");}void main(){int choose;open();while(choose!=0){scanf("%d",&choose);getchar();switch(choose){case 0:return;case 1:printf("\n 两个一元多项式相加\n");add_main();choose=-1;open();break;case 2:printf("\n 两个一元多项式相减\n");sub_main();choose=-1;open();break;default:printf("没有该选项!请重新选择操作!\n\n");open();}}}三、测试方案及结果1、测试方案在Visual C++ 6.0环境中调试运行。
数据结构一元多项式的运算
目录一、问题分析.................................... 错误!未定义书签。
问题描述 ........................................................................ 错误!未定义书签。
问题的数学模型............................................................. 错误!未定义书签。
构造数据结构................................................................. 错误!未定义书签。
二、系统分析 ...................................................................... 错误!未定义书签。
可行性研究..................................................................... 错误!未定义书签。
系统结构与主要功能模块 ............................................. 错误!未定义书签。
三、系统设计 ...................................................................... 错误!未定义书签。
系统设计目的与要求 ....................................................... 错误!未定义书签。
系统设计内容................................................................... 错误!未定义书签。
功能算法描述与数据结构说明........................................ 错误!未定义书签。
高等代数课件 第二章
三、 多项式的带余除法定理
定理 设f x, gx F[x] ，且 gx 0，则存在
qx, rxF[x], 使得
f x gxqx rx
这里 rx 0，或者 0 rx 0 gx. 并且满足上述条件的 qx和r(x) 只有一对。
注1： qx, rx分别称为 gx除f (x)所得的商式和
余式
注2： gx 0, gx| f x rx 0.
使以下等式成立:
f xux gxvx dx
三、多项式的互素
1. 互素的定义
定义 3 如果 Fx 的两个多项式除零次多项式外
不再有其它的公因式，我们就说，这两个多项式互素.
2. 互素的性质
(1)定理 2.3.3 Fx的两个多项式 f x与gx 互素
的充分且必要条件是：在 Fx中可以求得多项式 ux
二.教学目的 1.掌握最大公因式,互素概念. 2.熟练掌握辗转相除法 3.会应用互素的性质证明整除问题
三.重点,难点 辗转相除法求最大公因式. 证明整除问题
一、最大公因式的定义
定义 1 令 f x和 gx是F [x]的两个多项式，若 是F [x]的一个多项式hx 同时整除 f x和gx ，那么 hx 叫做 f x与gx的一个公因式.
f1x, f2 x,, fk x,及 q1x, q2 x,, qk x,
使得
fk1x fk x qk1xgx
而
0 f x 0 f1x 0 gx
由于多项式 f1x, f2x,的次数是递降的, 故存在k使
fk x 0或0 fk x 0gx ，于是
qx q1x qk x及rx fk x
系数所在范围对整除性的影响
二、教学目的
1．掌握一元多项式整除的概念及其性质。 2．熟练运用带余除法。
一元多项式问题
一元多项式相加问题本实验的目的是进一步熟练掌握应用链表处理实际问题的能力。
一、问题描述：一元多项式相加是通过键盘输入两个形如p0+p1*x^1+p2*x^2+pn*x^n的多项式，经过程序运算后在屏幕上输出它们的相加和。
二、数据结构设计：分析任意一元多项式的描述方法可知，一个一元多项式的每一个子项都有“系数—指数”两部分组成，所以可以将它抽象成一个有“系数—指数对”构成的线性表，由于对多项式中系数为0的子项可以不记录它的指数值，对于这样的情况就不再付出存储空间来存放它了。
基于这样的分析，可以采用一个带有头结点的单链表来表示一个一元多项式。
具体数据类型定义为：typedef struct node{float coef;int exp;int flag;struct node *next;}PolyNode;三、功能（函数）设计：1、输入并建立多项式的功能模块PolyNode * create(){float A;int B;PolyNode *a=NULL;PolyNode *b=NULL;PolyNode *c=NULL;scanf("%f,%d",&A,&B);while(A!=0||B!=0){if(A!=0){c=new PolyNode;c->coef=A;c->exp=B;c->flag=0;c->next=NULL;if(a==NULL){a=c;b=a;}else{b->next=c;b=c;}}scanf("%f,%d",&A,&B);}return a;}2、多项式相加的功能模块PolyNode *add(PolyNode *p,PolyNode *q){PolyNode *x,*y;PolyNode *r=NULL;PolyNode *c=NULL;PolyNode *l=NULL;x=p;y=q;while(x&&y){r=new PolyNode;if(x->exp==y->exp){r->coef=x->coef+y->coef;r->exp=x->exp;r->flag=0;r->next=NULL;x->flag=1;y->flag=1;x=x->next;y=y->next;}else if(x->exp>y->exp){r->coef=y->coef;r->exp=y->exp;r->flag=0;r->next=NULL;y->flag=1;y=y->next;}else{r->coef=x->coef;r->exp=x->exp;r->flag=0;r->next=NULL;x->flag=1;x=x->next;}if(c==NULL){c=r;l=c;}else{l->next=r;l=r;}}if(x==NULL)x=y;while(x){r=new PolyNode;r->coef=x->coef;r->exp=x->exp;r->flag=0;r->next=NULL;if(c==NULL){c=r;l=c;}else{l->next=r;l=r;}x->flag=1;x=x->next;}return c;}3、多项式显示的功能模块int print(PolyNode *w){if(w==NULL){cout<<'0';return 0;}PolyNode *v;v=w;cout<<'(';if(v->coef<0)cout<<'-';cout<<v->coef<<'x'<<v->exp;v=v->next;while(v){if(v->coef>=0)cout<<'+';cout<<v->coef<<'x'<<v->exp;v=v->next;}cout<<')';}四、界面设计：注意提示用户每一步操作输入的格式和限制，指导用户按照正确的格式输入数据。
数据结构_一元多项式的表示与相加
实验一一元多项式的表示与相加实验目的：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语言有些生疏和遗忘，在编程过程中出现很多错误。
一元多项式环的概念及其通用性质
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 一元多项式的乘法
单项式与多项式相乘
定义
举例
单项式与多项式相乘是指将单项式的每一项 分别与多项式的每一项相乘，并合并同类项。
一元多项式表示与相加
系数 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 设Ｐ是由一些复数组成的集合，其中包括０与１.如果Ｐ中任意两个数（这两个数也可以相同）的和·差·积·伤（除数不为零）仍然是P 中的数，那么Ｐ就称为一个数域。
第二节 一元多项式 定义２ 设ｎ是一非负整数。
形式表达式110...nn n n a x a xa --+++（１），其中01,,...,na a a 全属于数域Ｐ，称为系数在数域Ｐ中的一元多项式，或者简称为数域P 上的一元多项式。
定义3 如果在多项式f （x ）与g （x ）中，除去系数为零的项外，同次项的系数全相等，那么f （x ）与g （x ）就称为相等，记为f （x ）=g （x ）系数全为零的多项式称为零多项式，记为0定义4 所有系数在数域P 中的一元多项式的全体，称为数域Ｐ上的一元多项式环，记为［Ｐ］，Ｐ称为［Ｐ］的系数域第三节 整除的概念带余除法 对于Ｐ［ｘ］中任意两个多项式ｆ（ｘ）与ｇ（ｘ），其中()0g x ≠，一定有Ｐ［ｘ］中的多项式ｑ（ｘ），ｒ（ｘ）存在，使()()()()fx q x g x r x =+成立，其中()()()()r x g x ∂<∂或者()0r x =，并且这样的ｑ（ｘ），ｒ（ｘ）是唯一决定的。
定义５ 数域Ｐ上的多项式ｇ（ｘ）称为整除ｆ（ｘ），如果有数域Ｐ上的多项式ｈ（ｘ）使等式()()()fx g x h x =成立。
我们用“()()|g x f x ”表示ｇ（ｘ）整除ｆ（ｘ），用“()|()g x f x ”表示ｇ（ｘ）不能整除ｆ（ｘ）定理１ 对于数域Ｐ上的任意两个多项式ｆ（ｘ），ｇ（ｘ），其中()()()0,|g x g x fx ≠的充分必要条件是ｇ（ｘ）除ｆ（ｘ）的余式为零。
第四节 最大公因式定义６ 设ｆ（ｘ），ｇ（ｘ）是Ｐ［ｘ］中两个多项式。
Ｐ［ｘ］中多项式ｄ（ｘ）称为ｆ（ｘ），ｇ（ｘ）的一个最大公因式，如果它满足下面两个条件：（１）ｄ（ｘ）是ｆ（ｘ），ｇ（ｘ）的公因式；（２）ｆ（ｘ），ｇ（ｘ）的公因式全是ｄ（ｘ）的因式。
一元多项式相加 数据结构实验报告
南昌航空大学实验报告课程名称：数据结构实验名称：实验二线性表的链式存储结构班级：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。
数据结构课后练习 - 第2章
的联系，所以可以从头结点开始查找任何一个元素。 （×） 4. 顺序存储的线性表可以实现随机存取。（√ ）
二、单项选择题
1. 用单链表方式存储的线性表，存储每个结点需要两个域， 一个数据域，另一个是______B。
A. 当前结点所在的地址域
B. 指针域
C. 空指针域
D. 空闲域
2. 在具有n个结点的单链表中，实现__A____的操作，其算法 的时间复杂度都是O(n)。
A. 遍历链表和求链表的第i个结点
B. 在地址为p的结点之后插入一个结点
C. 删除开始结点
D. 删除地址为p的结点的后继结点
二、单项选择题
3. 已知一个顺序存储的线性表，设每个结点需占m个存储单元，若第一
学习要点
3. 熟练掌握在顺序存储结构上线性表的基本操作，如查 找、插入和删除的算法。
4. 熟练掌握在各种链表结构中线性表的基本操作，能在 实际应用中选用适当的链表结构。
5. 能够从时间与空间复杂度方面综合比较线性表两种存 储结构的不同特点及其适用场合。
一、判断对错题
1. 线性表中的元素可以是各种各样的，但同一线性表中 的数据元素具有相同的特性，因此属于同一数据对象。 （ ）√
• 插入结点：移动元素次数n-i+1； • 删除结点：移动元素次数n-i。 • 决定因素：顺序表的长度以及插入、删除元素在表中
的位序。
4. 分析下述三个算法的具体功能。
ListNode *Demo1(LinkList L, ListNode *p)
{ //L是有头结点的单链表
ListNode *q=L->next;
一元稀疏多项式以循环单链表按降幂排列
一元稀疏多项式以循环单链表按降幂排列一元稀疏多项式是指只含有一种未知数的多项式，并且其中大部分系数为零。
在计算机科学和数学领域，如何高效地表示和计算一元稀疏多项式一直是一个重要的问题。
循环单链表作为一种数据结构，可以很好地解决这一问题。
本文将从深度和广度两个方面来探讨一元稀疏多项式以循环单链表按降幂排列的表示方法。
一、基本概念和原理1. 一元稀疏多项式的定义一元稀疏多项式是指形如P(x)=a0x^m0 + a1x^m1 + ... + anx^mn的多项式，其中ai为系数，mi为指数。
很显然，如果某些项的系数为0，那么这些项可以被省略，从而得到一元稀疏多项式。
2. 循环单链表的定义循环单链表是一种特殊的单链表，它的最后一个节点指向头节点，从而形成一个循环。
这种数据结构可以很好地表示具有环路特性的问题，如环形队列和循环链表。
二、一元稀疏多项式的表示在计算机中，一元稀疏多项式通常以循环单链表的形式进行表示。
每个节点表示多项式的一项，节点中包含系数和指数两个信息。
按降幂排列的循环单链表可以很好地反映多项式的次序关系，从而方便进行各种运算操作。
举例来说，对于多项式P(x)=3x^5 + 2x^3 - x^2 + 4的表示，可以使用如下的循环单链表结构：1. 指数为5，系数为32. 指数为3，系数为23. 指数为2，系数为-14. 指数为0，系数为4这样，通过循环单链表的方式，可以直观地展现出多项式的结构和内容。
三、如何操作循环单链表表示的一元稀疏多项式1. 多项式的相加当需要对两个一元稀疏多项式进行相加时，可以直接对对应指数的节点进行系数相加。
如果某一项在另一个多项式中不存在，则直接将这一项插入到结果多项式的对应位置。
2. 多项式的相乘多项式的相乘需要将一个多项式的每一项依次与另一个多项式的所有项进行相乘，并将结果按指数相加合并。
这个操作需要对循环单链表进行多次插入和删除操作，而循环单链表的特性能够很好地支持这种需求。
一元多项式计算与链表 概述及解释说明
一元多项式计算与链表概述及解释说明1. 引言1.1 概述在计算机科学和数学领域，一元多项式计算是一个重要的问题。
一元多项式是指包含一个未知数的多项式，它由各个项的系数和指数决定。
而链表作为一种常见的数据结构，具有灵活性和高效性，可以应用于各种问题的解决中。
1.2 文章结构本文将首先对一元多项式计算进行介绍，包括多项式的定义与表示方法、多项式加法运算以及多项式乘法运算。
然后，我们将详细探讨链表的概念、特点以及链表在一元多项式计算中的应用。
接下来，将通过实例演示来解释一元多项式计算，并说明链表结构在多项式计算中的优势。
最后，我们将分享解决一元多项式计算问题时相关的考虑事项与技巧，并对研究内容进行总结，并展望其可能的拓展方向。
1.3 目的本文旨在向读者介绍和解释一元多项式计算与链表之间的关系，并探讨链表在该问题中所起到的作用。
通过深入了解一元多项式及其计算方法，以及链表数据结构原理和应用场景，读者将能够更好地理解一元多项式的计算过程，并了解链表在提高计算效率和灵活性方面的重要作用。
同时，通过分享解决问题时的考虑事项与技巧，本文还有助于读者在实际应用中更好地利用链表结构来解决一元多项式计算问题。
2. 一元多项式计算：2.1 多项式定义与表示方法:一元多项式是由若干个单项式构成的代数表达式。
一个单项式由系数和指数组成，通常可以表示为a*x^b的形式，其中a为系数，x为未知数，b为指数。
而一个多项式则是由多个单项式相加得到。
在计算机中，可以用数组或链表来表示一元多项式。
使用数组时，每个元素可以存储一个单项式的系数和指数；而使用链表时，则可以将每个单项式作为节点存储在链表中。
2.2 多项式加法运算:两个多项式相加时，需要将同一个指数的单项式进行合并并对系数进行相加。
具体步骤如下：- 将两个多项式中所有的不同指数提取出来形成一个集合。
- 遍历集合中的每个指数，在两个多项式中查找该指数对应的单项式。
- 如果某个多项式不存在该指数的单项式，则该指数对应的系数为空。
数据结构实验 C语言版 线性表__C版
2. 求表长
L.length
3. 取第i个元素
L.elem[i-1]
(0<i<L.length+1)
18
4. 元素定位操作
分析：依次取出每个元素和给定值进行比较 int LocateElem_Sq (SqList L, ElemType e, Status (*compare)(ElemType, ElemType))
6. 删除操作
线性表的删除运算是指将表的第i(1≦i≦n)个元 素删除，使长度为n的线性表： (a1，…a i-1，ai，a i+1…，an) 变成长度为n-1的线性表 (a1，…a i-1，a i+1，…，an)
操作步骤： ① 判断线性表是否为空 ② 判断i值是否合法：1≦i≦n ③ 元素前移 ④ 表长减1
2
线性结构：数据元素之间存在1对1的关系。 四个特征： ① 存在惟一的一个“第一元素” ② 存在惟一的一个“最后元素” ③ 除最后元素外，其它元素均有惟一的“后继” ④ 除第一元素外，其它元素均有惟一的“前驱”
3
2.1 线性表的类型定义
一.定义
线性表(Linear List) ：由n(n≧0)个数据元素组成的 有限序列。记作： (a1，a2，…an) 其中数据元素的个数n定义为表的长度。当n=0时称 为空表 这里的数据元素ai(1≦i≦n)只是一个抽象的符号， 其具体含义在不同的情况下可以不同。 例1、26个英文字母组成的字母表 （A，B，C、…、Z） 例2、某校从1978年到1983年各种型号的计算机拥 有量的变化情况。 4 （6，17，28，50，92，188）
思考：若要直接查相等的呢？
19
5. 插入操作
线性表的插入运算是指在表的第i(1≦i≦n+1)个位置上，插 入一个新元素e，使长度为n的线性表(a1，…a i-1，ai，…，an) 变成长度为n+1的线性表 (a1，…a i-1，e，ai，…，an) 操作步骤： ① 判断i是否符合要求：1≦i≦n+1 ② 判断表长是否溢出 ③ 元素右移 ④ 插入 ⑤ 表长增1
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
3.能够从时间复杂度中比较线性表两种存储结构的不同特点及其 适用场合。
//多项式PA中当前结点的指数值小
ha = qa;
qa = NextPos (Pa, qa);
break;
case #43; b.coef;
if (sum != 0.0) {
//修改多项式PA中
//当前结点的系数值
SetCurElem (qa, sum);
//链接Pb中剩余结点 //释放Pb的头结点
} //AddPolyn
两个一元多项式相乘的算法，可以利用两个一元多项式相加的算法来实现， 因为乘法运算可以分解为一系列的加法运算。假设A(x)和B(x)为多项式：
Pn (x) p0 p1xe1 p2 xe2 pm xem
则：M(x) = A(x) × B(x)
一元多项式的实现：
typedef OrderedLinkList polynomial; // 用带表头结点的有序链表表示多项式
结点的数据元素类型定义为:
typedef struct { // 项的表示
float coef;
// 系数
int expn;
// 指数
} term, ElemType;
多项式相加 算法2.15如下：
ha = qa;
}
else {
//删除多项式PA中当前结点
DelFirst (ha, qa);
FreeNode (qa);
}
DelFirst (hb, qb);
FreeNode (qb);
qb = NextPos (Pb, hb);
qa = NextPos (Pa, ha);
break;
case 1:
= A(x) × [b1xe1 b2 xe2 bn xen ]
n
= bi A(x)xei 其中每一项都是一个一元多项式。 i 1
本章小结
1.了解线性表的逻辑结构特性是数据元素之间存在着线性关 系，在计算机中表示这种关系的两类不同的存储结构是顺序 存储结构和链式存储结构。用前者表示的线性表简称为顺序 表，用后者表示的线性表简称为链表。
//多项式PB中当前结点的指数值小
DelFirst (hb, qb);
InsFirst (ha, qb);
qb = NextPos (Pb, hb);
ha = NextPos (Pa, ha);
break;
} //switch
} //while
if (!ListEmpty (pb))
Append (Pa, qb); FreeNode (hb);
void AddPolyn (Polynomial &Pa, Polynomial &Pb) {
//多项式加法：Pa = Pa + Pb，利用两个多项式的结点构成“和多项式”。
ha = GetHead (Pa);
//ha和hb分别指向Pa和Pb的头结点
hb = GetHead (Pb);
qa = NextPos (Pa, ha);
假设 Qm (x)是一元m次多项式：Qm (x) q0 q1x q2x2 qmxm（m<n）。
则两个多项式相加的结果： Rn (x) Pn (x) Qm (x) 。用线性表可表示 为：R ( p0 q0, p1 q1,, pm qm, pm1,, pn) 。
若对P,Q,R采用顺序存储结构，则问题很简单：
为此我们可以用单链表来实现。在单链表中每个结点有两个数据项（系数项和 指数项）。
例如： A17 (x) 7 3x 9x8 5x17 和 B8 (x) 8x 22 x7 9x8 相加。
A
-1
70
31
98
5 17 ^
B
-1
81
22 7
-9 8 ^
C
-1
70
11 1
5 17 ^
22 7
图2.14 多项式相加链式存储结构示例
p0
q0
p0 + q0
p1
q1 p1 + q1
…+…
…
pm
qm
…
pm + qm …
pn
pn
但是对于形如
S(x) = 1 + 3x10000 – 2x20000
的多项式，上述表示方法是否合适？
然而，在通常的应用中，多项式的次数可能很高且变化很大，使得顺序存储结 构的最大长度很难确定。例如：。就要用一长度为20001的线性表来表示，而表中 仅有3个非零元素，这种对内存空间的浪费是应该避免的。
第二章 线性表
2.1 线性表的类型定义 2.2 线性表的顺序表示和实现 2.3 线性表的链式表示和实现 2.4 一元多项式的表示及相加
￡2.4 一元多项式的表示及相加
在数学上，一个多项式可表示为： Pn(x) p0 p1x p2x2 pnxn。用 线性表可表示为 P ( p0, p1, p2,, pn ) 。
//qa和qb分别指向Pa和Pb中当前结点
qb = NextPos (Pb, hb);
while (qa && qb) {
//qa和qb均非空
a = GetCurElem (qa);
//a和b为两表中当前比较元素
b = GetCurElem (qb);
switch (*cmp(a, b)) {
case -1: