单链表实现一元多项式的相加和相减
一元多项式相加 数据结构实验报告
南昌航空大学实验报告课程名称：数据结构实验名称：实验二线性表的链式存储结构班级：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。
(2023)数据结构利用链表计算一元多项式课程设计实验报告(一)
(2023)数据结构利用链表计算一元多项式课程设计实验报告(一)2023数据结构课程设计实验报告——利用链表计算一元多项式实验背景和目的在本课程设计实验中，我们旨在通过使用链表数据结构，实现对一元多项式的计算功能。
通过本次实验，我们将深入学习和掌握链表的基础知识和应用技能，掌握实现链表操作的代码实现方式，提高编程实践能力和解决问题的能力。
思路和方法首先，我们需要定义链表节点数据结构，包含多项式中的系数和指数两个数据成员。
然后，我们需要实现一元多项式的相加、相减、求导、求值等基本操作。
其中，相加和相减操作需要利用链表遍历的方式，比较两个多项式中的指数，进行对应系数的加减，并将结果存储到新的链表中。
求导操作只需要遍历链表，将每一项的指数减一，系数乘以指数值，再将其插入到新的链表中即可。
求值操作仅需要遍历链表，根据指数和系数计算多项式值即可。
在具体实现过程中，我们需要注意边界条件的判断和处理，如何处理空链表、单项式情况等。
还需要精细设计代码逻辑，避免重复遍历链表，浪费时间和空间资源。
结果分析和展示经过数次测试和调试，我们最终实现了一元多项式的链表计算功能。
我们在终端输入多项式的系数和指数，再根据指令进行相应的操作。
结果能够准确输出，并且经过大量数据测试，程序运行稳定，没有出现崩溃和错误的情况。
总结和反思通过本次实验，我们进一步深入学习了链表数据结构的应用方法和相关算法。
我们学会了如何通过遍历链表实现复杂计算操作，如一元多项式的求导、求值等。
在实现过程中，我们对代码结构和逻辑设计进行反复思考和优化，提高了自己的编程能力和解决问题的能力。
同时，我们也需要进一步加强数据结构的学习，提升自己的算法水平，为后续的专业学习和职业发展打下坚实的基础。
可能的改进和优化方案虽然我们已经实现了一元多项式链表计算功能，但是我们也发现了以下几点可以改进和优化的方案：•异常处理：在用户输入有误或者数据不规范的情况下，程序可能会出现崩溃或者不符合预期的结果。
数据结构课程设计-一元多项式的加法、减法、乘法的实现
一、设计题目一元多项式的加法、减法、乘法的实现。
二、主要内容设有一元多项式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等数学软件对一元多项式的计算过程，步骤后。
由于这些软件比较大功能齐全，但是实用性不强。
数据结构（C语言）用单链表存储一元多项式,并实现两个多项式的相加运算
#include<stdio.h>#include<stdlib.h>#include<malloc.h>typedef int ElemType;/*单项链表的声明*/typedef struct PolynNode{int coef; // 系数int expn; // 指数struct PolynNode *next;}PolynNode,*PolynList;/*正位序(插在表尾)输入n个元素的值，建立带表头结构的单链线性表*/ /*指数系数一对一对输入*/void CreatePolyn(PolynList &L,int n){int i;PolynList p,q;L=(PolynList)malloc(sizeof(PolynNode)); // 生成头结点L->next=NULL;q=L;printf("成对输入%d个数据\n",n);for(i=1;i<=n;i++){p=(PolynList)malloc(sizeof(PolynNode));scanf("%d%d",&p->coef,&p->expn); //指数和系数成对输入q->next=p;q=q->next;}p->next=NULL;}// 初始条件：单链表L已存在// 操作结果: 依次对L的每个数据元素调用函数vi()。
一旦vi()失败,则操作失败void PolynTraverse(PolynList L,void(*vi)(ElemType, ElemType)){PolynList p=L->next;while(p){vi(p->coef, p->expn);if(p->next){printf(" + "); //“+”号的输出，最后一项后面没有“+” }p=p->next;}printf("\n");}/*ListTraverse()调用的函数(类型要一致)*/void visit(ElemType c, ElemType e){if(c != 0){printf("%dX^%d",c,e); //格式化输出多项式每一项}}/* 多项式相加，原理：归并 *//* 参数：两个已经存在的多项式 *//* 返回值：归并后新的多项式的头结点 */PolynList MergeList(PolynList La, PolynList Lb){PolynList pa, pb, pc, Lc;pa = La->next;pb = Lb->next;Lc = pc = La; // 用La的头结点作为Lc的头结点while(pa&&pb){if(pa->expn < pb->expn){pc->next = pa; //如果指数不相等，pc指针连上指数小的结点，pc = pa;pa = pa->next; //指向该结点的指针后移}else if(pa ->expn > pb->expn ){pc->next = pb; //pc指针连上指数小的结点，pc = pb;pb = pb->next; //指向该结点的指针后移}else//(pa ->expn = pb->expn ){pa->coef = pa->coef + pb->coef; //指数相等时，系数相加 pc->next = pa;pc = pa;pa = pa->next; //两指针都往后移pb = pb->next;}}pc->next = pa ? pa:pb; // 插入剩余段return Lc;}void main(){PolynList ha,hb,hc;printf("非递减输入多项式ha， ");CreatePolyn(ha,5); // 正位序输入n个元素的值printf("非递减输入多项式hb， ");CreatePolyn(hb,5); // 正位序输入n个元素的值printf("多项式ha :");PolynTraverse(ha, visit); printf("\n");printf("多项式hb :"); PolynTraverse(hb, visit); printf("\n");hc = MergeList(ha,hb); PolynTraverse(hc, visit); }。
Java用单链表实现多项式加减乘
Java用单链表实现多项式加减乘用单链表来实现多项式的加减乘，除就不做了，代码如下publicclassPolynomial{privateMonomialfirst;//首项//添加单项式publicvoidappend(Monomialmonomial){if(monomial==null){//donothing}elseif(first==null){first=monomial;}else{Monomialcurrent=first;while(current!=null){//Examda提示:如果指数相同，则相加if(current.index==monomial.index){current.coefficient+=monomial.coefficient;break;}elseif(current.next==null){//否则直接扔到最后current.next=monomial;break;}current=current.next;}}}publicvoidappend(doublec,inti){append(newMonomial(c,i));}publicStringtoString(){StringBuffersb=newStringBuffer();Monomialcurrent=first;while(current.next!=null){sb.append("("+current.coefficient+"x^"+current.index+")+");current=current.next;}sb.append("("+current.coefficient+"x^"+current.index+")");returnsb.toString();}//两个多项式相加publicPolynomialadd(Polynomialp2){Polynomialresult=newPolynomial();Monomialcurrent=this.first;while(current!=null){result.append(current.coefficient,current.index);//Examda提示:注意这里current=current.next;}current=p2.first;while(current!=null){result.append(current.coefficient,current.index);current=current.next;}returnresult;}//两个多项式相减this-p2publicPolynomialsubstract(Polynomialp2){Polynomialresult=newPolynomial();Monomialcurrent=this.first;while(current!=null){result.append(current.coefficient,current.index);//注意这里current=current.next;}current=p2.first;while(current!=null){result.append(-current.coefficient,current.index);current=current.next;}returnresult;}/***this*p2**@return*/publicPolynomialmultiply(Polynomialp2){ Polynomialresult=newPolynomial();Monomialc1=this.first;Monomialc2=p2.first;while(c1!=null){while(c2!=null){result.append(c1.coefficient*c2.coefficient,c1.index +c2.index);c2=c2.next;}c1=c1.next;c2=p2.first;}returnresult;}publicPolynomialdivide(Polynomialp2){//todo实现相除returnnull;}publicstaticvoidmain(String[]args){Polynomialp1=newPolynomial();p1.append(2.2,1);p1.append(3.3,2);p1.append(4.111,7);System.out.println("p1:"+p1);Polynomialp2=newPolynomial();p2.append(2.232,5);p2.append(3.444,6);p2.append(5.777,1);System.out.println("p2:"+p2); Polynomialresult=p1.add(p2); System.out.println("加:"+result); result=p1.substract(p2); System.out.println("减:"+result); result=p1.multiply(p2);System.out.println("乘:"+result); }}/***单项式*/classMonomial{doublecoefficient;//系数intindex;//指数Monomialnext;//后继结点publicMonomial(){}publicMonomial(doublec,inti){ this.coefficient=c;this.index=i;}}。
C语言单链表实现多项式相加
C语⾔单链表实现多项式相加本⽂实例为⼤家分享了C语⾔单链表实现多项式相加的具体代码，供⼤家参考，具体内容如下//多项式的相加和相乘#include<stdio.h>#include<stdlib.h>#pragma warning(disable:4996)//兼容scanftypedef struct node {int coef;int expon;struct node* link;}Polynode,*Polynomial;Polynomial InsertPolyLinklist(Polynomial in,Polynomial Pread) {Pread->link = in;Pread = in;in->link = NULL;return Pread;}Polynomial ReadPoly(void) {Polynomial Pread = (Polynomial)malloc(sizeof(Polynode));Pread->link = NULL;Polynomial H = Pread;int N;scanf("%d ", &N);while (N--) {Polynomial p = (Polynomial)malloc(sizeof(Polynode));scanf("%d %d", &p->coef, &p->expon);Pread= InsertPolyLinklist(p,Pread);}Polynomial F;F = H->link;free(H);return F;}void PrintPoly(Polynomial F) {while(F != NULL) {printf("%d %d ", F->coef, F->expon);F = F->link;}printf("\n");}Polynomial Add(Polynomial p1, Polynomial p2) {Polynomial t1=p1,t2=p2;Polynomial p=(Polynomial)malloc(sizeof(Polynode));p->link = NULL;Polynomial q = p;Polynomial read;while (t1&&t2) {if (t1->expon == t2->expon) {if (t1->coef + t2->coef) {t1->coef = t1->coef + t2->coef;t1->expon = t1->expon;read = t1;q->link = read;q = read;t1 = t1->link;t2 = t2->link;}}else {if (t1->expon > t2->expon){read = t1;q->link = read;q = read;t1 = t1->link;}else {if (t1->expon < t2->expon) {read = t2;q->link = read;q = read;t2 = t2->link;}}}}if (t1) {q->link = t1;}if (t2) {q->link = t2;}Polynomial F = p->link;free(p);return F;}int main(void) {Polynomial p1, p2, pp, ps;p1 = ReadPoly();PrintPoly(p1);p2 = ReadPoly();PrintPoly(p2);pp = Add(p1, p2);PrintPoly(pp);// ps = Mult(p1, p2);// PrintPoly(ps);return 0;}参考MOOC 浙⼤数据结构以上就是本⽂的全部内容，希望对⼤家的学习有所帮助，也希望⼤家多多⽀持。
数据结构C语言实现之一元多项式的表示及相加(2)
数据结构 C 语言实现之一元多项式的表示及相加（2）
一元多项式的表示及相加 对于符号多项式的各种操作，实际上都可以利用线性表来处理。比较典型的是关于一元多项式的处理。在
} } e>next; /*将 q 结点加入到和多项式中*/ q =q->next; } }
} if(p!=NULL)/*多项式 A 中还有剩余，则将剩余的结点加入到和多项式中*/
pre->next=p;
else /*否则，将 B 中的结点加入到和多项式中*/ pre->next=q; }
算法 2.24 多项式相加 假设 A 多项式有 M 项，B 多项式有 N 项，则上述算法的时间复杂度为 O(M+N) 图 2.20 所示为图 2.19 中两个多项式的和，其中孤立的结点代表被释放的结点。
通过对多项式加法的介绍，我们可以将其推广到实现两个多项式的相乘，因为乘法可以分解为一系列的加 法运算。
“中的结点无需另生成，则可看成是将多项式 B 加到多项式 A 中，由此得到下列运算规则（设 p、q 分别 指向多项式 A，B 的一项，比较结点的指数项）
若 p->exp< q->exp，则结点 p 所指的结点应 是“和多项式”中的一项，令指针 p 后移；若 p>exp>q->exp，则结点 q 所指的结点应是“和多项式”中的一项，将结点 q 插入在结点 p 之前， 且令指针 q 在原来的链表上后移；
（1）用单链表存储多项式的结点结构如下： struct Polynode { int coef; int exp; Polynode *next; } Polynode , * Polylist;
一元多项式的各种运算实现(c++,c)
float a=1.0;
for(int i=1;i<=k;i++)
a=a*1e-1;
return a;
}
//赋值，参数是指向头结点的指针
void fuzhi(node *&toup)
{
float fumi(int k);
void init(node *&toup);
if(!toup) init(toup);
if(toup) destory(toup);//假如有头结点或元素节点，销毁结点
toup=(node*)malloc(sizeof(node));
if(!toup){cout<<"溢出错误"<<endl;exit(0ext=NULL;
}
//销毁全部，包括头结点
cout<<"*******************************************************************************"<<endl;
cout<<"举例:3 x3 9.3x-3 -x....."<<endl;
}
//求未知数指数是-k时的值
float fumi(int k)
while(p)
{
if(p->data ==0)
{
if(!pr)
{
tem=p;
toup->next =p->next ;
p=p->next ;
toup->length--;
free(tem);
tem=NULL;
一元多项式(用其中的一个链表存储)
int ceof; //系数
int expn; //指数
struct ploynode *next;
}node,*Linklist;
/*创建链表*/
Linklist creat(int n)
{
Linklist p,newnode,head;
int i;
p->next=newnode;
p=newnode;
}
p->next=NULL;
return head;
}
/*输出链表*/
void print(Linklist h)
{
Linklist p,q;
q=h;
p=q->next;
if(p)
while(p!=NULL)
{
printf("%dX^%d",p->ceof,p->expn);
p=p->next;
if(p!=NULL)
printf("+");
}
}
/*相加函数*/
void ploy_add(Linklist La,Linklist Lb) //将所加的函数保存到La中
Linklist list2=creat(4);
printf("第一个一元多项式为:");
print(list1);
printf("\n第二个一元多项式为:");
print(list2);
printf("\n相加为");
ploy_add(list1,list2);
{
c++一元多项式相加减 链表
C++一元多项式相加减链表一、介绍1. 什么是一元多项式一元多项式是指只含有一个变量的多项式，例如3x^3 + 2x^2 - 5x + 7。
2. 链表的概念链表是一种数据结构，由一系列节点组成，每个节点包含数据和指向下一个节点的指针。
3. 本文内容本文将介绍如何使用C++实现一元多项式的相加和相减运算，同时利用链表来存储和操作多项式的数据。
二、实现思路1. 链表的设计我们可以设计一个节点类来表示多项式的每一项，节点包括系数和指数两个成员变量，同时包括一个指针指向下一个节点。
2. 多项式的输入和输出用户可以逐项输入多项式的系数和指数，也可以将多项式输出至屏幕或文件。
3. 多项式的相加和相减我们需要同时遍历两个多项式的链表，根据指数的大小进行相应的相加或相减操作，并将结果存储到一个新的链表中。
三、代码实现1. 定义节点类```class Node {public:int coefficient; // 系数int exponent; // 指数Node* next; // 指向下一个节点的指针};```2. 多项式的输入```void inputPolynomial(Node* &head) {// 逐项输入多项式的系数和指数，并将其存储为一个链表 }```3. 多项式的输出```void outputPolynomial(Node* head) {// 遍历链表，并将多项式的每一项输出至屏幕或文件}```4. 多项式的相加```Node* addPolynomial(Node* head1, Node* head2) {// 遍历两个链表，根据指数的大小进行相应的相加操作，并将结果存储到一个新的链表中}```5. 多项式的相减```Node* subtractPolynomial(Node* head1, Node* head2) {// 遍历两个链表，根据指数的大小进行相应的相减操作，并将结果存储到一个新的链表中}```四、示例代码1. 主函数```int main() {Node* head1 = nullptr;Node* head2 = nullptr;Node* result = nullptr;// 输入第一个多项式inputPolynomial(head1);// 输入第二个多项式inputPolynomial(head2);// 输出两个多项式cout << "First polynomial: ";outputPolynomial(head1);cout << "Second polynomial: ";outputPolynomial(head2);// 计算两个多项式的和result = addPolynomial(head1, head2);cout << "Sum of two polynomials: ";outputPolynomial(result);// 计算两个多项式的差result = subtractPolynomial(head1, head2); cout << "Difference of two polynomials: "; outputPolynomial(result);return 0;}```五、总结本文介绍了如何使用C++实现一元多项式的相加和相减运算，并利用链表来存储和操作多项式的数据。
数据结构C语言描述——用单链表实现多项式的相加
数据结构C语⾔描述——⽤单链表实现多项式的相加#include <stdio.h>#include <stdlib.h>typedef DataType;typedef struct Node2{DataType xishu;DataType zhisu;struct Node2 *Next;}Node2;typedef struct Node2* PNode2;//多项式按照指数⼤⼩排序void insertNewPoint_link(PNode2 head,PNode2 qNode){PNode2 p=head;while (p->Next!=NULL){if (p->Next->zhisu>qNode->zhisu){qNode->Next=p->Next;p->Next=qNode;break;}p=p->Next;}if (p->Next==NULL){p->Next=qNode;}}//打印多项式void printLinkeLink(PNode2 head){PNode2 temp=head->Next;while (temp!=NULL){printf("%d %d",temp->xishu,temp->zhisu);printf("\n");temp=temp->Next;}}//多项式的加法计算void add_poly(Node2 *pa,Node2 *pb){Node2 *p=pa->Next;Node2 *q=pb->Next;Node2 *pre=pa;Node2 *u;while (p!=NULL&&q!=NULL){if (p->zhisu<q->zhisu){pre=p;p=p->Next;}else if(p->zhisu==q->zhisu){float x=p->xishu+q->xishu;if (x!=0){p->xishu=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){pre->Next=q;}free(pb);}void main( ){int zhishu;float xishu;PNode2 head1=(PNode2)malloc(sizeof(struct Node2));PNode2 head2=(PNode2)malloc(sizeof(struct Node2));PNode2 tem=NULL;head1->Next=NULL;head2->Next=NULL;printf("输⼊链表⼀的系数和指数，如：3,2 以0,0结束输⼊：\n"); scanf("%f,%d",&xishu,&zhishu);while (xishu!=0||zhishu!=0){tem=(PNode2)malloc(sizeof(struct Node2));tem->xishu=xishu;tem->zhisu=zhishu;tem->Next=NULL;insertNewPoint_link(head1,tem);scanf("%f,%d",&xishu,&zhishu);}printf("链表⼀按指数升序排序后的多项式为：\n");printLinkeLink(head1);printf("\n");printf("输⼊链表⼀的系数和指数，如：3,2 以0,0结束输⼊：\n"); scanf("%f,%d",&xishu,&zhishu);while (xishu!=0||zhishu!=0){tem=(PNode2)malloc(sizeof(struct Node2));tem->xishu=xishu;tem->zhisu=zhishu;tem->Next=NULL;insertNewPoint_link(head2,tem);scanf("%f,%d",&xishu,&zhishu);}printf("链表⼆按指数升序排序后的多项式为：\n");printLinkeLink(head2);printf("\n");add_poly(head1,head2);printf("多项式相加后的结果为：\n");printLinkeLink(head1);}。
数据结构课程设计——一元多项式计算
数据结构课程设计——一元多项式计算一、课程设计题目及要求二、设计思路和方法三、程序流程图四、程序代码及注释五、测试结果及分析六、结论七、参考文献本次课程设计的题目为“一元多项式计算”，要求设计一个程序，能够实现一元多项式的加、减、乘、求导和求值等操作。
在设计思路和方法上，我们采用了链表的数据结构来存储多项式，同时设计了相应的函数来实现各种操作。
程序的流程图如下所示：插入流程图）程序的代码及注释如下所示：插入代码及注释）在测试结果及分析方面，我们对程序进行了多组测试，并对其进行了详细的分析和比较。
结果表明，我们的程序能够正确地实现各种操作，并且具有较高的效率和稳定性。
综上所述，本次课程设计的目标已经得到了圆满地实现，我们对于所取得的成果感到非常满意。
同时，我们也希望能够通过这次课程设计，加深对于数据结构及其应用的理解和掌握，为今后的研究和工作打下坚实的基础。
设计目标：本课程设计旨在结合理论与实际应用，提高学生组织数据及编写大型程序的能力。
通过掌握数据组织、算法设计和算法性能分析的方法，培养学生良好的程序设计能力。
具体实现是利用单链表表示一元多项式，实现多项式的输入、建立、输出、相加、相减和相乘。
总体设计：2.1 数据结构描述与定义：一元多项式定义系数和指数结构如下：coef，expn和next。
定义多项式的结构为线性链表的存储结构，每个结点包含三个元素：系数coef，指数expn和指向下一个结点的指针*next。
多个单项式通过指针连接起来，形成一个多项式。
2.2 模块设计：从实现多项式运算过程的角度来分析，至少需要以下子功能模块：多项式创建、销毁、输出、相加、相减和相乘。
定义并调用的函数有：Insert、CreatePolyn、DestroyPolyn、PrintPolyn、AddPolyn、SubtractPolyn、XXX和main函数。
注：该文章中没有明显的格式错误和需要删除的段落，因此没有进行小幅度改写。
数据结构_基于线性表的链式存储进行一元多项式的相加减_课程设计_实验报告
比较两个节点中的指数项，有下列三种情况： （1） 指针 qa 所指节点的指数值＜指针 qb 所指节点的指数值，则应摘取 qa 所指节点的指数值插入到“和多项式”链表中去； （2） 指针 qa 所指节点的指数值＞指针 qb 所指节点的指数值，则应摘取 qb 所指节点的指数值插入到“和多项式”链表中去，则将两个节点中的系数 相加； （3） 指针 qa 所指节点的指数值＝指针 qb 所指节点的指数值，若和数不等 于零，则修改 qa 所指节点的系数值，同时释放 qb 所指节点；反之，从多 项式 A 的链表中删除相应节点，并释放指针 qa 和 qb 所指节点。
种可能情况进行分析，实现一元多项式的相加、相减操作。
指导教师： 年月日
目录
一 需求分析.........................................................................................................................1 二 目的和意义.....................................................................................................................1 三 问题分析.........................................................................................................................1
一 需求分析
利用线性表的链式存储结构，通过尾插法建立两个单链表，分别存储两个一元多 项式，，建立一元多项式并按照指数降序排列输出多项式，将一元多项式输入并存储 在内存中，然后依次找出系数相同的项来合并同类项，最后完成两个多项式的加减运 算并输出结果。实现本程序需要解决以下几个问题：
一元多项式的单链表表示及其运算
一元多项式的单链表表示及其运算
一元多项式的单链表表示是将多项式的每一项以节点的形式存储在链表中，链表的每个节点包含两个数据域，一个表示系数，一个表示指数。
链表中的节点按照指数从大到小的顺序排列，这样可以方便进行多项式的运算。
例如，多项式2x^3 + 3x^2 + 4x + 5可以表示为如下的单链表：
5 -> 4 -> 3 -> 2 -> NULL
其中，每个节点的第一个数据域表示系数，第二个数据域表示指数。
针对这个单链表表示的多项式，可以进行多项式的加法、减法、乘法等运算。
多项式的加法运算可以通过遍历两个链表，按照指数的大小逐个比较，并将相同指数的项系数相加，将不同指数的项加入到结果链表中。
多项式的减法运算可以通过将减数链表中的每个项的系数取相反数，然后调用加法运算。
多项式的乘法运算可以通过遍历两个链表，计算每一项的系数和指数的乘积，将结果项按照指数从大到小的顺序加入到结果链表中。
除了基本的加法、减法和乘法运算外，还可以对多项式进行求导、求积分等运算。
实验11单链表实现一元多项式的加法和减法
要
加的结果：5x(3) +4x(6)+10x(7)
求
减的结果：－1x(3)＋6x(4)－4x(6)
数 据 结 构 设 计
程 序 实 现
程 序 实 现
程 序 实 现
调 试 情 况
教
师
教师签字：
日期 ：
评
阅
实验 1.1 单链表实现一元多项式的加法和减法
实
验
1、定义线性表的链式存储；
目
2、实现对线性表的一些基本操作和具体函数定义。
的
1、定义一个建立一元多项式的函数；
实
2、定义能对单链表按指数排序的函数；
验
3、定义一元多项式加法和减法函数；
要
4、定义显示一元多项式的函数；
求
5、编写主程序调用上面的函数实现一元多项式的加减。输入示ຫໍສະໝຸດ ：33423
57
4
-3 4
46
数
33
据
57
输
（说明：第一个数据 3 表示该第一个一元多项式的项数为 3，后面的 3 4 表
入
示第一项的系数为 3 指数为 4；每个一元多项式的项数不超过 20，指数都是
与
正整数最大不超过 100）
输 输出示例：
出
排序后的一元多项式 1： 2x(3)+3x(4)+5x(7) 排序后的一元多项式 2： 3x(3)-3x(4)+4x(6)+5x(7)
完整版用单链表实现任意两个一元多项式的加减运算
软件综合设计报告书二○一六年六月一．需求分析：1.设计题目：用单链表实现任意两个一元多项式的加减运算2.设计要求：编程实现以下功能：①分别输入一元多项式p(x)和。
Q(x) n n从键盘输入一元对项式中各项的系数和指数，并用单链表加以表示。
②分别对一元多项式p(x)和进行升幂排序。
(x)Q n n将一元多项式中各子项按照指数从小到大的顺序排序。
③分别输出一元多项式p(x)和(x) 。
Q nn将用单链表表示的一元多项式输出，即打印多项式的系数和指数。
④任意输入一个实数x0，分别求出一元多项式p(x0)和(x0)的值。
Q n n已知有两个一元多项式分别为(x)和Q(x)，求出两个多项式的和P⑤n n(x)和差(x)，分别用单链表表示(x)和(x)，并将二者输出，RTRT n n n n（R(x)=P (x)+Q (x)，T(x)=PQ(x)）(x)- n n n n n n保存多项式，即分别将一元多项式p(x)和Q各项的系数和指数保(x)⑥n n存到外部磁盘文件。
⑦由程序从所存文件中读出多项式的系数和指数，重新构建一元多项式P(x) 和Q并可对其再次进行运算操作。
，(x) n n3.系统功能需求分析：①用单链表表示出一元多项式②将多项式进行升幂排序③输出多项式④计算多项式在x0的值⑤建立并输出多项式的和与差⑥将多项式以及他的系数指数进行保存⑦读取多项式二．概要设计：包括系统总体设计框架和系统功能模块；系统功能模块（1）功能选择函数：通过输入对应功能的数字，进行多项式的运算。
该函数在主函数中调用。
（2）输入数据函数：通过建立单链表，输入两个多项式的各项指数和系数。
（3）升幂函数：通过冒泡排序法对两个多项式进行升幂排序。
（4）求和、求差函数：定义空链用来存储结果，将两个多项式相加减。
）输出函数：输出上一步的运行结果。
5（三．详细设计：包括主要功能模块的算法设计思路以及对应的工作流程图；设计思路：（1）定义结构体struct （2）建立单链表（3）建立一元多项式（4）显示一元多项式（5）一元多项式的加法计算（6）一元多项式的减法计算功能选择函数：数据输入函数：求和函数：求差函数：四．主要源程序代码：包括存储结构设计说明，以及完整源程序；存储结构设计说明：一元多项式的表示在计算机内可以用链表来表示，为了节省存储空间，只存储多项式中系数非零的项。
数据结构一元多项式的运算-无删减范文
数据结构一元多项式的运算数据结构一元多项式的运算简介一元多项式是数学中常见的概念，用于表示一个变量的多项式表达式。
在计算机科学中，经常需要对一元多项式进行各种运算，如加法、减法、乘法等。
为了实现这些运算，可以使用数据结构来存储和操作一元多项式。
本文将介绍一元多项式的数据结构和常见的运算方法，并给出相应的代码示例。
数据结构一元多项式可以用链表来表示。
每个节点包含两个部分：系数（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```减法运算减法运算可以看作加法运算的特殊情况，即将第二个多项式的系数取负数，再进行加法运算。
数据结构实验,用链表实现多项式加减乘
#include<stdio.h>#include<malloc.h>#include<stdlib.h>#include<math.h>#define ERROR 0#define POLY sizeof(Polynomial)typedef struct Polynomial /*用单链表存储多项式的结点结构*/{int coef; /*多项式的系数*/int exp; /*指数*/struct Polynomial *next;/*next是struct Polynomial类型中的一个成员，它又指向struct Polynomial类型的数据，以此建立链表*/}Polynomial;Polynomial * CreatPolyn(void)/*指针函数，返回指针类型；用尾插法建立一元多项式的链表的函数*/{Polynomial *head,*tail,*s;int c,e;head=(Polynomial *)malloc(POLY);/*建立多项式的头结点，为头结点分配存储空间*/if(!head)exit(ERROR);tail=head;/*tail指针始终动态指向链表的当前表尾，以便于做尾插入，其初值指向头结点*/ printf("系数:");scanf("%d",&c); /*输入系数*/printf("指数: ");scanf("%d",&e); /*输入指数*/if(c==0){printf("请重新输入");return NULL;}else{while(c!=0) /*输入系数为0时，表示多项式的输入结束*/{s=(Polynomial *) malloc(POLY); /*申请新结点*/s->coef=c; /*申请新结点后赋值*/s->exp=e; /*申请新结点后赋值*/tail->next=s; /*做尾插，插入新结点*/tail=s; /*tail始终指向单链表的表尾*/printf("系数:");scanf("%d",&c);printf("指数: ");scanf("%d",&e);}tail->next=NULL; /*将表的最后一个结点的next置NULL，以示表结束*/ return(head);}}void DestroyPolyn(Polynomial *p)//删除多项式{Polynomial *q;while(p->next!=NULL){q=p->next;free(p);p=q;}}int PolyLength(Polynomial *p){Polynomial *q;int i=0;q=p;while(q->next!=NULL){q=q->next;i++;}return(i);}void Order(Polynomial *p)/*多项式的升幂排序*/{Polynomial *q;int a,b,i=0;q=p;while(q->next!=NULL){if(q->exp>q->next->exp){a=q->coef;b=q->exp;q->coef=q->next->coef;q->exp=q->next->exp;q->next->coef=a;q->next->exp=b;}q=q->next;i++;}}void PaiXu(Polynomial *p)//重复调用升幂排序函数{int j;for(j=1;j<PolyLength(p);j++)Order(p);}void AddPolyn(Polynomial *polya, Polynomial *polyb)/*两个一元多项式相加，将和多项式存放在多项式polya中，并将多项式ployb删除*/ {Polynomial *p,*q,*he,*temp;int sum;p=polya->next;/*令p指向polya多项式链表中的第一个结点*/q=polyb->next;/*令q指向polyb多项式链表中的第一个结点*/he=polya; /*令he指向和多项式polya*/while(p!=NULL&&q!=NULL)/*当两个多项式均未扫描结束时，执行以下操作*/{if(p->exp<q->exp)/*若p指向的多项式指数小于q指的指数*/{he->next=p; /*将p结点加入到和多项式中*/he=he->next;p=p->next; /*将p指针后移一位*/}else if(p->exp==q->exp)/*若指数相等，则相应的系数相加*/{sum=p->coef+q->coef;if(sum!=0) /*系数和不为零，执行下列操作*/{p->coef=sum;he->next=p;he=he->next;p=p->next;temp=q->next;free(q);//q=q->next;q=temp; /*释放原q节点*/}else /*系数和为零，则删除结点p与q，并将指针指向下一个结点*/{temp=p->next;free(p);p=temp;temp=q->next;free(q);q=temp;}}else /*若p指数大于q指数*/{he->next=q; /*p结点不动，将q结点加入到和多项式中*/he=he->next;q=q->next;}}if(p!=NULL)/*多项式A中还有剩余，则将剩余的结点加入到和多项式中*/he->next=p;else /*否则将B的结点加入到和多项式中*/he->next=q;}void PrintPolyn(Polynomial *p) /*输出函数，打印出一元多项式*/{p=p->next;if(p->exp>0)printf("A(x)= %d*x^%d",p->coef,p->exp);else if(p->exp<0)printf("A(x)= %d*x^(%d)",p->coef,p->exp);elseprintf("A(x)= %d",p->coef);while(p->next!=NULL){p=p->next;if(p->coef>0){if(p->exp>0)printf(" + %d*x^%d",p->coef,p->exp);else if(p->exp<0)printf(" + %d*x^(%d)",p->coef,p->exp);elseprintf(" + %d",p->coef);}else{if(p->exp>0)printf(" %d*x^%d",p->coef,p->exp);else if(p->exp<0)printf(" %d*x^(%d)",p->coef,p->exp);elseprintf(" %d",p->coef);}}}void main() /*主函数*/{Polynomial *polya,*polyb;int i;printf(" !!两个多项式的相加!!");//printf("若输入的单项式为0，则表明多项式创建完毕\n");begin: printf("\n\t\t** ** ** ** ** ** * *** *** **");printf("\n\t\t* 1、输入第一个多项式 *");printf("\n\t\t* 2、输入第二个多项式 *");printf("\n\t\t* 3、输出两个多项式的和 *");printf("\n\t\t* 4、退出 *");printf("\n\t\t** ** ** ** ** ** * *** *** **");printf("\n请选择：");scanf("%d",&i);switch(i){case 1:printf("\n请输入多项式中的每一个单项式的系数和指数\n");printf(" 若输入的单项式为0，则表明多项式创建完毕:\n\n");polya=CreatPolyn(); /*调用函数，创建多项式*/if(polya==NULL)goto begin;else{PaiXu(polya);printf("输入的多项式:\n");PrintPolyn(polya);goto begin;}case 2:printf("\n请输入多项式中的每一个单项式的系数和指数:\n"); polyb=CreatPolyn(); /*同理，创建B*/if(polyb==NULL)goto begin;else{PaiXu(polyb);printf("输入的多项式:\n");PrintPolyn(polyb);goto begin;}case 3:printf("\n两个多项式的和为:\n");AddPolyn(polya,polyb); /*调用一元多项式相加函数*/PrintPolyn(polya);DestroyPolyn(polya);goto begin;case 4:printf("08计（3）谢世伟 080201031025\n");break;}}#include <cstdlib>#include <iostream>using namespace std;struct xiang{float xs,zs,x; //分别表示系数、指数、以及Xxiang *next;};class duoxiangshi{private:xiang *first,*p;public:duoxiangshi();~duoxiangshi();void add(float xs,float zs); //n代表多项式的项数个数xiang * operator+(const duoxiangshi & b); //重载多项式的相加xiang * operator-(const duoxiangshi & b);void print(xiang *athead); //输出多项式相加结果void printself(); //看一下};duoxiangshi::duoxiangshi(){first=new xiang;first->next=NULL;p=first;}duoxiangshi::~duoxiangshi(){while(p=first){first=first->next;delete p;}}void duoxiangshi::add(float xs,float zs) //增加多项式的项数，在插入的同时给它由指数的大小进行排序{xiang *q=new xiang;xiang *tmp; //临时指针。
数据结构C++单链表一元多项式的相加
数据结构C++单链表⼀元多项式的相加#include <iostream>using namespace std;struct Node {double coe; //系数int exp; //指数Node *next;};void CreatPoly(Node *&head, int n) // ⽣成带表头结点的单链表，除头结点外另⽣成n个结点{head = (Node *)new Node;head->coe = 0;head->exp = 0;head->next = NULL; // 初始化头结点cout << "分别每⾏输⼊各项系数及指数：" << endl;Node *p = head;for(int i = 0; i < n; i++) {p->next = (Node *)new Node; // ⽣成新结点，尾插⼊⽣成链表p = p->next;cin >> p->coe >> p->exp;p->next = NULL;}}void ShowPoly(Node *&head){if(head->next == NULL) // 结果是0时直接输出0putchar('0');else {for(Node *p = head->next; p != NULL; p = p->next) {if(p != head->next && p->coe >0) // 当p⾮⾸项且指向的系数为正时才输出'+'putchar('+'); // 之前只判定了p->coe >0if(p->coe == 1) { // 系数为1或-1时特殊处理if(p->exp == 0)putchar('1'); // 判断条件不能写在⼀起：} // if(p->coe == 1 && p->exp == 0) putchar('1');else if(p->coe == -1)putchar('-');elsecout << p->coe;// 指数为0或1时特殊处理switch(p->exp) {case 0:break;case 1:putchar('x');break;default:p->exp < 0 ? printf("x^(%d)", p->exp) : printf("x^%d", p->exp); // 指数⼩于0时打括号break;}}}cout << endl;}char comp(int a, int b)if(a > b)return '>';if(a < b)return '<';return '=';}void Free(Node *&head){Node *q = NULL;for(Node *p = head; p != NULL; p = q) {q = p->next;free(p);}}void AddPolynomial(Node *&pA, Node *&pB) // 传进两个链表的头指针{Node *ha = pA;Node *hb = pB;Node *qa = ha->next; // ha, hb分别跟在qa, qb的后⼀位置Node *qb = hb->next; // qa, qb分别指向Pa, Pb中当前⽐较元素while(qa && qb){double sum = 0;int a = qa->exp;int b = qb->exp;switch( comp(a, b) ) {case '<':ha = qa;qa = qa->next; // ⾮ha = ha->next;break;case '=':sum = qa->coe + qb->coe;if(sum != 0.0) {qa->coe = sum;ha = qa;}else {if(ha->next != qa)cout << "Error: ha->next != qa" << endl;ha->next = ha->next->next; // 删除和为0的结点，ha不变，还在qa后⼀位置free(qa);}if(hb->next != qb)cout << "Error: hb->next != qb" << endl;hb->next = hb->next->next;free(qb);qb = hb->next;qa = ha->next;break;case '>':hb->next = hb->next->next; // 删除qb指向的结点qb->next = ha->next; // 将qb插⼊ha后qa前ha->next = qb;qb = hb->next; // not qb = ha->nextha = ha->next;break;default:cout << "Error!" << endl;break;}if(qb)ha->next = qb;free(hb);}void main(void){Node *A = NULL;Node *B = NULL;int countA;int countB;cout << "请输⼊A的项数：" << endl, cin >> countA; CreatPoly(A, countA); // ⽣成A链表cout << "请输⼊B的项数：" << endl; // ⽣成B链表cin >> countB;CreatPoly(B, countB);cout << " A = ";ShowPoly(A);cout << " B = ";ShowPoly(B);AddPolynomial(A, B); // A = A + Bcout << "A+B= ";ShowPoly(A); // 输出相加的和cout << endl;// 释放结点delete A;}。
数据结构——链表实现一元多项式的表示和加法
数据结构——链表实现⼀元多项式的表⽰和加法⼀元多项式的链式结构：Typedef struct Lnode{float coef;///系数int expn;///指数struct Lnode *next;} PLnode, *PLinkList;基本思想：（1）若pa->expn⼩于pb->expn,则pa继续向前扫描；(2）若pa->expn等于pb->expn,将其系数相加，若相加结果不为0，将结果放⼊pa->coef中，并删除pb所指的结点，否则同时删除pa和pb所指的结点，然后pa和pb继续向前扫描；（3）若pa->expn⼤于pb->expn,则将pb所指的结点插⼊pa所指的结点之前，然后pb继续向前扫描；（4）重复上述过程直到pa或pb有⼀个为空为⽌，最后将剩余结点的链表接在结果链表上。
PLinklist Add(PLinklist pa,PLinklist pb){PLinklist p,q,r,s; /*两个多项式相加*/int cmp,x;p=pa->next; /*指向pa的第⼀个元素*/q=pb->next; /*指向pb的第⼀个元素*/s=pa; /*s作为P的跟踪指针*/r=pb;/*r作为q的跟踪指针*/while(p!=NULL&&q!=NULL){if(p->exp<q->exp){cmp=-1;}else if(p->exp>q->exp){cmp=1;}else///指数相等{cmp=0;}switch(cmp){/*根据指数的⽐较情况进⾏不同的处理*/case -1:{s=p;p=p->next;///pa表指针后移，没有插⼊break;}case0:{x=p->coef+q->coef;///指数相等，系数相加if(x!=0) /*系数不为0*/{p->coef=x;s=p;p=p->next;}/*if*/else///系数为0,在pa表中删除该结点{s->next=p->next;free(p);p=s->next;}/*else*/r->next=q->next;///在pb表中删除该结点free(q);q=r->next;break;} /*case0*/case1:{q->next=s->next;s->next=q;///将pb表中的q插⼊到pa表中的s的后⾯r->next=q->next;s=q;q=r->next;break;} /*case1*/}/*switch*/}/*while*/if(q!=NULL)///当pb连表还有剩余时接⼊到pa连表的尾部 {s->next=q;}free(pb);return pa;}/* Add*/。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
polylinklist L1,L2,L3,L4;
Createlist_L(L1,m);
printf("一元多项式1：");
TraversePolyn(L1,visit);
printf("一元多项式的项数：");
scanf("%d",&h);
printf("系数指数同时输入%d个数据\n",n);
for(i=1;i<=n;i++)
{
p=(polylinklist)malloc(sizeof(polynode));
scanf("%d,%d",&p->coef,&p->expn);
pc->coef=pb->coef; pc->expn=pb->expn;
pb=pb->next;
}
pc->next=NULL;
}
void subtract(polylinklist La, polylinklist Lb, polylinklist &Lc)
else
{ pc->coef=pb->coef; pc->expn=pb->expn; pb=pb->next; }
}
}
while(pa)
{ pc->next=(polylinklist)malloc(sizeof(polynode)); pc=pc->next;
pc->coef=pa->coef; pc->expn=pa->expn;
pa=pa->next;
}
while(pb)
{
pc->next=(polylinklist)malloc(sizeof(polynode)); pc=pc->next;
{ if (pa->expn==pb->expn)
{ x=pa->coef+pb->coef;
if (x!=0)
{ pc->next=(polylinklist)malloc(sizeof(polynode));
{ polylinklist pa,pb,pc;
int x;
pa=La->next ; pb=Lb->next ;
pc=(polylinklist)malloc(sizeof(polynode));
Lc=pc;
while (pa&&pb)
void Createlist_L(polylinklist &L,int n)
{
int i;
polylinklist p,q;
L=(polylinkli;
L->next=NULL;
q=L;
{ polylinklist pa,pb,pc;
int y;
pa=La->next ; pb=Lb->next ;
pc=(polylinklist)malloc(sizeof(polynode));
Lc=pc;
while (pa&&pb)
Createlist_L(L2,h);
printf("一元多项式2：");
TraversePolyn(L2,visit);
printf("加的结果：");
polyadd(L1,L2,L3);
TraversePolyn(L3,visit);
printf("减的结果：");
else
{
pc->next=(polylinklist)malloc(sizeof(polynode)); pc=pc->next;
if(pa->expn<pb->expn)
{ pc->coef=pa->coef; pc->expn=pa->expn; pa=pa->next; }
pc->coef=pa->coef; pc->expn=pa->expn;
pa=pa->next;
}
while(pb)
{ pc->next=(polylinklist)malloc(sizeof(polynode)); pc=pc->next;
while(p)
{vi(p->coef, p->expn);
if(p->next)
{
if(p->next->coef>0)
printf(" + ");
}
p=p->next;
subtract(L1,L2,L4);
TraversePolyn(L4,visit);
}
pc=pc->next; pc->coef=x; pc->expn=pa->expn;
}
pa=pa->next; pb=pb->next;
}
}
printf("\n");
}
void visit(int c, int e)
{if(c != 0)
{printf("%dX^%d",c,e);
}
}
void polyadd(polylinklist La, polylinklist Lb, polylinklist &Lc)
pc=pc->next; pc->coef=y; pc->expn=pa->expn;
}
pa=pa->next; pb=pb->next;
}
q->next=p;
q=q->next;
}
p->next=NULL;
}
void TraversePolyn(polylinklist P,void(*vi)(int, int))
{
polylinklist p=P->next;
else
{ pc->coef=-pb->coef; pc->expn=pb->expn; pb=pb->next; }
}
}
while(pa)
{ pc->next=(polylinklist)malloc(sizeof(polynode)); pc=pc->next;
#include<stdio.h>
#include<malloc.h>
typedef struct polynode
{
int coef;
int expn;
struct polynode *next;
} polynode, *polylinklist;
pc->coef=-pb->coef; pc->expn=pb->expn;
pb=pb->next;
}
pc->next=NULL;
}
int main()
{ int m,h;
printf("一元多项式的项数：");
else
{ pc->next=(polylinklist)malloc(sizeof(polynode)); pc=pc->next;
if(pa->expn<pb->expn)
{ pc->coef=pa->coef; pc->expn=pa->expn; pa=pa->next; }
{ if (pa->expn==pb->expn)
{ y=pa->coef-pb->coef;
if (y!=0)
{ pc->next=(polylinklist)malloc(sizeof(polynode));