下载文档原格式
链表及其多项式相加一、实验目的1.了解线性表的链式存储结构，熟练掌握链表。
2.了解作为链表的多项式存贮方式。
3.熟悉掌握多项式加法的算法。
#include<stdio.h>#include <malloc.h>typedef struct linkline{int coef;int exp;struct linkline *next;}line;line *creat(){ /*建立多项式列表*/int n;line *head;line *p1,*p2;n=0;printf("(输入的数必须是整数，指数须从小到大依次输入,系数为零表示多项式结束)\n");p1=p2=(line *)malloc(sizeof(line)); /*开辟一个新单元*/scanf("%d%d",&p1->coef,&p1->exp); /*录入多项式*/if (p1->coef==0) head=0;else{while(p1->coef!=0){n++;if (n==1) head=p1;else p2->next=p1;p2=p1;p1=(line *)malloc(sizeof(line));scanf("%d%d",&p1->coef,&p1->exp);}p2->next=0;}return(head);}/* 以下是输出多项式的函数*/void print(line *p){line *p0;p0=p;printf(" ");do{printf("%dx的%d次幂",p0->coef,p0->exp);p0=p0->next;if(p0!=0) printf("+");}while(p0!=0);else printf(" 空多项式!!");printf("\n");}int compare(int m,int n) /*比较两个整数的大小的函数*/ {int j;if (m<n) j=-1;if (m==n) j=0;if (m>n) j=1;return(j);}void freeNode(line *w1) /* 释放一个表中的所有结点*/ {line *w2;w2=w1->next;while(w1){free(w1);w1=w2;w2=w2->next;}}line *AddLine(line *ha,line *hb) /*两个非空多项式相加*/ {line *la,*lb,*lc;int a,b,sum;lc=ha;la=ha;lb=hb;if ((ha==0)&&(hb!=0)) return(hb);while ((la!=0)&&(lb!=0)){a=la->exp; b=lb->exp;switch( compare(a,b) ) /*比较当前结点指数的大小*/ {{ ha=la; /*只修改la的指针*/la=la->next;break;}case 0:{ sum=la->coef+lb->coef;if(sum!=0){ /* 将其不为零的系数和保存*/la->coef=sum;ha=la; la=la->next;} /* end if*/else{ /* 分别删除系数和为零的对应的两个结点*/if (lc==la) {lc=lc->next;ha=lc;la=ha;} /* 刚开始时特殊处理头结点*/ else{ha->next=la->next;la=ha->next;}} /*end else*/hb=lb;lb=lb->next;break;}case 1:{ /* 将指数小的项插入到la的前部*/hb=lb->next;if(ha==la) {lc=lb;lb->next=ha;la=la->next; }else{ha->next=lb;lb->next=la;ha=la;la=la->next;}lb=hb->next;break;}} /*end swtich*/} /*end while*/if (lb!=0) ha->next=lb;return(lc);} /*end AddLine *//*************以下为主程序**************/main(){line *la,*lb,*lc;printf("请输入多项式La: ");la=creat();printf("请输入多项式Lb: ");lb=creat();printf("多项式La:\n");print(la);printf("多项式Lb:\n");print(lb);printf("多项式La与Lb的和是: \n");lc=AddLine(la,lb);print(lc);freeNode(lb);}二、实验原理顺序存储的线性表有一些弱点，其一，插入与删除元素需要大量移动元素；其二，预先分配存储空间时必须按最大的空间来分配。
实验一：两个多项式相加相乘链表实现学生姓名：#班级：@12学号：完成时间：2015.06.25本人郑重声明：本实验的程序代码编写与调试、实验报告的撰写均由本人独立完成，如被发现抄袭或与其他同学作业雷同，同意取消该实验成绩！声明人：#2015.06.25【实验内容】I.设计构造两个链式线性表，用来表示两个一元多项式II.程序允许用户手工输入这两个线性表，每个线性表中的每个数据元素包含两个值，系数Pi和幂qi；输入方式自定；III.程序对两个多项式进行相加，然后输出一个相加后的一元多项式。
IV.两个多项式相乘（选做）。
【编程思路】1.创建链表：先分别输入两个多项式的项数以及调用Createlist（）函数按降幂顺序输入各项的系数和次数，构建出两个多项式的链表。
两个多项式的系数和次数同样按降幂顺序存入两个线性表a、b中，头结点分别为head_a,head_b。
2.多项式相加：创建一个新链表，作为相加后所得结果的多项式的链表寄存处。
定义两个临时链表节点指针pa和pb，分别指向两个链表头结点的下一位（注：链表的头结点不存项）。
通过比较两个多项式的首项确定最高次幂，用max_qi记录。
然后用一个for循环从两个链表中寻找，判断pa和pb当前位置有无次数为i（i为循环变量）的项，有则合并同类项。
如果pa、pb次数等于i，两对应系数相加，和其系数一起存入新节点中，再将新节点插入新链表中，pa、pb随后后移一个单位；如果pa的次数小于i，pb次数等于i，则只加pb项，也存入新节点并插入新链表中，随后pb向后移动一个单位；如果pb的次数小于i，pa次数等于i，处理方法与上一种情况类似。
如果pa和pb次数均小于i，则i减小1，进入下一次循环，再作比较。
若pa或pb为空，则将不为空的多项式链表的剩余项逐一赋给新链表即可。
3.多项式相乘：创建一个新链表，作为相乘后所得结果的多项式的链表寄存处。
定义两个临时链表节点指针pa和pb，分别指向两个链表头结点的下一位。
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++实现一元多项式的相加和相减运算，并利用链表来存储和操作多项式的数据。
哈尔滨工业大学计算机科学与技术学院实验报告课程名称：数据结构与算法课程类型：必修实验项目：线性结构及其应用实验题目：多项式的加减乘除和特定值带入实验日期：2017/11/5班级：1603001学号：**********姓名：***一、实验目的设计线性表的链式存储结构，并实现一元多项式的代数运算。
二、实验要求及实验环境（1）实验要求：以链表存储一元多项式，在此基础上完成对多项式的代数操作。
1.能够输入多项式（可以按各项的任意输入顺序，建立按指数降幂排列的多项式）和输出多项式（按指数降幂排列）,以文件形式输入和输出，并显示。
2.能够计算多项式在某一点 x=x0 的值，其中 x0 是一个浮点型常量，返回结果为浮点数。
3.能够给出计算两个多项式加法、减法、乘法和除法运算的结果多项式，除法运算的结果包括商多项式和余数多项式。
4.要求尽量减少乘法和除法运算中间结果的空间占用和结点频繁的分配与回收操作。
（提示：利用循环链表结构和可用空间表的思想，把循环链表表示的多项式返还给可用空间表，从而解决上述问题）。
（2）实验环境：windows下的CB;三、设计思想（本程序中的用到的所有数据类型的定义，主程序的流程图及各程序模块之间的调用关系）1．逻辑设计:struct polynode{int coef;int exp;struct polynode * link;};//建立链表typedef struct polynode poly;poly* Attch(int c,int e,poly *d);//多项式插入poly *newPoly();//新链表poly *padd(poly *p1,poly *p2);//多项式加法poly *pmul(poly *p1,poly *p2);//乘法poly *inputPoly();//输入多项式poly *psub(poly *p1,poly *p2);//减poly *pdiv(poly *p1,poly *p2);//除poly *inputPoly1();double caculate(double x,poly *p);//计算多项式void sortPoly(poly *p);//多项式排序void outputPoly(poly*p);//输出多项式void delPoly(poly*p);//清空多项式2．物理设计：四、测试结果五、经验体会与不足不能连续输入多个多项式函数设计不够简洁算法过于直接简单加注释后修改代码方便六、附录：源代码（带注释）#include <stdio.h>#include <stdlib.h>struct polynode{int coef;int exp;struct polynode * link;};//建立新链表typedef struct polynode poly;poly* Attch(int c,int e,poly *d);//插入链表poly *newPoly();//建立新链表poly *padd(poly *p1,poly *p2);//加法poly *pmul(poly *p1,poly *p2);//乘法poly *inputPoly();//输入多项式poly *psub(poly *p1,poly *p2);//减法poly *pdiv(poly *p1,poly *p2);//除法poly *inputPoly1();//输入double caculate(double x,poly *p);//计算void sortPoly(poly *p);//排序void outputPoly(poly*p);//输出多项式void delPoly(poly*p);//除法void Insert(poly *p,poly *h){if(p->coef==0)free(p);else{poly *q1,*q2;q1=h;q2=h->link;while(q2&&p->exp<q2->exp){q1=q2;q2=q2->link;}/*判断两个指数是否相等*/if(q2&&p->exp==q2->exp){q2->coef+=p->coef;free(p);if(!q2->coef){q1->link=q2->link;free(q2);}}/*相等就加系数*/else{p->link=q2;q1->link=p;}}/*不等就插在后面*/}int main(){poly *p1,*p2,*padd1,*psub1,*pmul1; p1=newPoly();printf("第一个多项式\n");p1->link=inputPoly();outputPoly(p1);p2=newPoly();printf("第二个多项式\n");p2->link=inputPoly1();outputPoly(p2);padd1=newPoly();pmul1=newPoly();psub1=newPoly();padd1->link=padd(p1,p2);printf("padd\n");outputPoly(padd1);psub1->link=psub(p1,p2);printf("psub\n");outputPoly(psub1);pmul1->link=pmul(p1,p2);printf("pmul\n");outputPoly(pmul1);printf("输入x的值！");int x;scanf("%d",&x);x=caculate(x,p1);printf("%d\n",x);pdiv(p1,p2);return 0;}poly *newPoly(){poly *x;x=(poly*)malloc(sizeof(poly)); x->link=NULL;x->coef=0;x->exp=0;return x;}poly* Attch(int c,int e,poly *d) {poly *x;x=newPoly();x->coef=c;x->exp=e;d->link=x;return x;}poly *padd(poly *p1,poly *p2){poly *a, *b,*c,*d,*p;c=newPoly();d=c;p=c;a=p1->link;b=p2->link;while(a!=NULL&&b!=NULL){if(a->exp>b->exp)//如果a的系数大于b把a先输入 {c=Attch(a->coef,a->exp,c);a=a->link;}else if(a->exp<b->exp)//小于相反{c=Attch(b->coef,b->exp,c);b=b->link;}else//相等{c=Attch(b->coef+a->coef,a->exp,c);a=a->link;b=b->link;}}/*a b比较完成开始遍历剩下的未插入的*/while(a!=NULL){c=Attch(a->coef,a->exp,c);a=a->link;}while(b!=NULL){c=Attch(b->coef,b->exp,c);b=b->link;}c->link=NULL;d=d->link;p->link=NULL;delPoly(p);return d;}poly *psub(poly*p1,poly*p2)//加和减思路相同，b的系数得输入相反值{poly *a, *b,*c,*d,*p;c=newPoly();d=c;p=c;a=p1->link;b=p2->link;while(a!=NULL&&b!=NULL){if(a->exp>b->exp){c=Attch(a->coef,a->exp,c);a=a->link;}else if(a->exp<b->exp){c=Attch(b->coef*(-1),b->exp,c);b=b->link;}else{if((a->coef-b->coef)>0){c=Attch(a->coef-b->coef,a->exp,c); a=a->link;b=b->link;}else{a=a->link;b=b->link;}}}while(a!=NULL){c=Attch(a->coef,a->exp,c);a=a->link;}while(b!=NULL){c=Attch(b->coef*(-1),b->exp,c);b=b->link;}c->link=NULL;d=d->link;p->link=NULL;delPoly(p);return d;}/*乘法，先用第一个链表的第一个数据乘以第二个链表里的所有值，储存在新的链表中，之后遍历一中所有的值，最后把这些多项式加在一起。
一元多项式头结点单链表,求一阶导一元多项式可以表示为一个单链表，每个节点表示一个项，包含两个成员变量，一个是系数，一个是指数。
我们需要求一阶导数，即每个项的系数乘以指数，并将指数减一作为新节点的系数。
具体算法如下：1. 定义一个新的链表，用于存放一阶导数的结果。
2. 遍历给定的一元多项式链表。
3. 对于每个节点，计算其一阶导数的系数，即节点的系数与指数的乘积，并将指数减一作为新节点的系数。
4. 将计算得到的结果插入到新链表中，要保持新链表按指数递减的顺序排列。
5. 返回新链表作为一阶导数的结果。
以下是使用Python实现的代码示例：```pythonclass Node:def __init__(self, coef, exp):self.coef = coefself.exp = expself.next = Nonedef derivative(polynomial):# 定义新链表的头结点derivative_head = Node(None, None)current = derivative_head# 遍历一元多项式链表while polynomial.next:polynomial = polynomial.next# 计算一阶导数的系数derivative_coef = polynomial.coef * polynomial.exp# 如果一阶导数的系数不为0，则插入到新链表中if derivative_coef != 0:# 创建新节点derivative_node = Node(derivative_coef, polynomial.exp - 1)current.next = derivative_nodecurrent = current.nextreturn derivative_head.next```使用示例：```python# 创建一元多项式链表polynomial = Node(None, None)node1 = Node(2, 3)node2 = Node(3, 1)node3 = Node(4, 0)polynomial.next = node1node1.next = node2node2.next = node3# 求一阶导数derivative_polynomial = derivative(polynomial)# 打印结果current = derivative_polynomialwhile current:print("系数:", current.coef, "指数:", current.exp) current = current.next```输出结果：```系数: 6 指数: 2系数: 3 指数: 0```。
数据结构PTA-⼀元多项式的乘法与加法运算数组链表⼀元多项式的乘法与加法运算输⼊格式:输⼊分2⾏，每⾏分别先给出多项式⾮零项的个数，再以指数递降⽅式输⼊⼀个多项式⾮零项系数和指数（绝对值均为不超过1000的整数）。
数字间以空格分隔。
输出格式:输出分2⾏，分别以指数递降⽅式输出乘积多项式以及和多项式⾮零项的系数和指数。
数字间以空格分隔，但结尾不能有多余空格。
零多项式应输出0 0。
输⼊样例:4 3 4 -5 26 1 -2 03 5 20 -74 3 1输出样例:15 24 -25 22 30 21 -10 20 -21 8 35 6 -33 5 14 4 -15 3 18 2 -6 15 20 -4 4 -5 2 9 1 -2 0思路⽤了太多次链表实在是⽤吐了，虽然运⾏起来很爽，但是编写太⿇烦了，换数组解决。
这⾥参考了⼀下其他⼤佬的思路问题的关键在于变量其实是两个（指数和系数），放在⼀起紧挨着或分成两个数组都不好处理，尤其是多项式相乘是⼀种交叉相乘的计算。
⽐较巧妙的处理⽅式是将取数组的位置为指数，该位置对应的值为系数。
应注意反之不可，因为可以存在n倍的x0（即常数），⽽不存在0倍的x n。
区别于其他⼲扰数可以通过初始化数组为0来实现。
参考:https:///yuxiaoba/p/8326018.htmlhttps:///Jie-Fei/p/10138885.html代码：#include<bits/stdc++.h>using namespace std;#define P 10000int main(){int a[10000]= {0},b[10000]= {0};//输⼊数组int c[10000]= {0},d[10000]= {0};//结果数组int n,m;int i,j;int flag; //⽤于判断输出空格int x,y; //系数&指数scanf("%d",&n);for(i=0; i<n; i++){scanf("%d %d",&x,&y);a[y]=x; //指数为位置，系数为数组}scanf("%d",&m); //同上输⼊for(i=0; i<m; i++){scanf("%d %d",&x,&y);b[y]=x;}for(i=P-1; i>=0; i--) //////////两数相乘{if(a[i]!=0){for(j=0; j<P; j++){if(b[j]!=0){c[i+j]+=a[i]*b[j];}}}}flag=0; //输出乘式 for(i=P-1; i>=0; i--){if(c[i]!=0){if(flag!=0)printf(" ");printf("%d %d",c[i],i);flag++;}}if(flag==0 ) //扣分点{printf("0 0");}printf("\n"); //换⾏for(i=P-1; i>=0; i--) //两式相加 {if(a[i]!=0)d[i]+=a[i];if(b[i]!=0)d[i]+=b[i];}flag=0; //输出加式 for(i=P-1; i>=0; i--){if(d[i]!=0){if(flag!=0)printf(" ");printf("%d %d",d[i],i);flag++;}}if(flag==0 ) //扣分点{printf("0 0");}}。
通信韩若冰222010315220106实验项目：线性表及其应用实验内容：用单链表存储多项式；实现多项式的输出显示、相加、相乘、求导、求值运算。
算法设计与程序实现：由于存储多项式需要存储系数和指数，且其指数变化范围可能很大如果用顺序表就会浪费很大的空间，用单链表存取指针域，和数据域（系数和指数）就会节省很大空间。
要想实现多项式的显示，相加，相乘，求导，求值运算，首先得创建函数以实现上述功能，然后再在主函数中调用上述函数以得到运行结果。
算法描述：（实验内容的核心算法）创建链表：首先创建空表，然后将每个结点用尾插法依次插入。
每一项多项式的组成部分（系数和指数）输出程序：此程序需要遍历整个链表，通过判断p->next的系数的正负来确定输出“+”还是“-”很容易出现错误。
多项式相加：这个程序需要按照幂的排列顺序依次遍历寻找一个多项式与另一个多项式指数相同的，将其系数相加比较简单。
该程序写成升幂比较，其中可能出现如A多项式的前几项都比B中的指数小，那么以一个pre为头结点的链表先将其穿起来，找到相等的进行运算再串起来，最后可能会有链表剩余的指数更大的项不能和另一个相加再将剩余的串起来。
（第一项要先串起来，因为第一项之前没有多项式不用判断+ —号）多项式相乘：此程序需要循环语句，即将一个多项式的每一项分别和另一个多项式相乘，依次调用多项式相加的程序叠加起来。
多项式求导：需要依次将多项式的每一项的系数和指数相乘，指数减1，形成一个链表多项式求值：需要有x的幂次的表示，C语言不能识别“^”，所以需要用一个循环实现x^exp相乘的结果，容易出错核心程序：运行结果：实验总结：本次试验做了很长时间，也出现了很多错误。
总起来说有以下几种错误：1.输入错误：中英文状态下输入错误，其中还有运行时在中文状态下输入数据回车后就不能输了，应在英文状态下输入data , data↙2.多项式表示需要判断下一个多项式系数是正还是负然后分别写+, —（fabs），但是第一项必须先输出,因为第一项不需要写+ —号3.多项式相加，要注意写的程序是怎么比较的，升幂的话则p->exp < q->exp 则把p结点指数小的先穿起来。
一元多项式的单链表表示及其运算
一元多项式的单链表表示是将多项式的每一项以节点的形式存储在链表中，链表的每个节点包含两个数据域，一个表示系数，一个表示指数。
链表中的节点按照指数从大到小的顺序排列，这样可以方便进行多项式的运算。
例如，多项式2x^3 + 3x^2 + 4x + 5可以表示为如下的单链表：
5 -> 4 -> 3 -> 2 -> NULL
其中，每个节点的第一个数据域表示系数，第二个数据域表示指数。
针对这个单链表表示的多项式，可以进行多项式的加法、减法、乘法等运算。
多项式的加法运算可以通过遍历两个链表，按照指数的大小逐个比较，并将相同指数的项系数相加，将不同指数的项加入到结果链表中。
多项式的减法运算可以通过将减数链表中的每个项的系数取相反数，然后调用加法运算。
多项式的乘法运算可以通过遍历两个链表，计算每一项的系数和指数的乘积，将结果项按照指数从大到小的顺序加入到结果链表中。
除了基本的加法、减法和乘法运算外，还可以对多项式进行求导、求积分等运算。
链表两个多项式相加与相乘的解释链表是一种数据结构，其中每个元素（称为节点）包含数据部分和一个指向下一个元素的指针。
在链表中表示多项式，每个节点包含一个系数和一个指示下一个节点在链表中的位置的指针。
多项式的每一项都存储在链表中。
对于两个多项式的相加和相乘，我们可以使用链表来表示这些操作。
1. 多项式相加：假设我们有两个多项式 P(x) 和 Q(x)，它们可以表示为链表：```cssP(x) = a_nx^n + a_n-1x^(n-1) + ... + a_1x + a_0Q(x) = b_mx^m + b_m-1x^(m-1) + ... + b_1x + b_0```多项式 P(x) 和 Q(x) 的相加可以通过简单的对应项相加来完成。
即对于每个i，我们找到 P(x) 的第 i 项和 Q(x) 的第 i 项，然后将它们相加并将结果存储在一个新的链表中。
注意，这可能会导致新的链表中的节点数少于原始链表中的节点数，因为如果某个指数在两个原始链表中都不存在，那么它就不会出现在结果链表中。
2. 多项式相乘：多项式相乘稍微复杂一些。
假设我们有两个多项式 P(x) 和 Q(x)，它们的链表表示如下：```cssP(x) = a_nx^n + a_{n-1}x^{n-1} + ... + a_1x + a_0Q(x) = b_mx^m + b_{m-1}x^{m-1} + ... + b_1x + b_0```P(x) 和 Q(x) 的相乘可以通过创建一个新的链表来完成，该链表包含所有可能的对应项乘积。
具体来说，结果链表的每个节点包含一个系数，该系数是原始链表中两个节点的系数的乘积。
对于每个 i 和 j（i 从 0 到 n，j 从 0 到m），我们将 P(x) 的第 i 项与 Q(x) 的第 j 项相乘并将结果添加到结果链表中。
注意，这可能会导致结果链表中的节点数多于原始链表中的节点数，因为每个节点可能与其它的多个节点相乘。
#include<stdio.h>#include<malloc.h>#include<stdlib.h>//首先要构造多项式的数据结构struct duoxiangshi{char ch;//变量名float coef;//系数coefficientint expo; //指数exponentstruct duoxiangshi *next;};//初始化一个链表duoxiangshi * initlink(){duoxiangshi *p;p=(duoxiangshi*)malloc(sizeof(duoxiangshi));//如果申请内存空间失败if(p==NULL){printf("申请空间失败");exit(0);}p->next=NULL;return p;}//销毁整个链表void destroy_link(duoxiangshi *p){duoxiangshi *q;while(p!=NULL){q=p;p=p->next;free(q);}}//将多项式存入链表中duoxiangshi * creat_ploy(duoxiangshi *p){char c[1];int i=0,n=0;duoxiangshi *p1;p=initlink();printf("输入变量名:\n");scanf("%s",c);printf("输入多项式项数\n");scanf("%d",&n);for(i=0;i<n;i++){p1=(duoxiangshi *)malloc(sizeof(duoxiangshi));if(p1==NULL)//如果分配失败时{printf("申请空间失败");exit(0);}printf("输入第%d项的系数：\n",i+1);scanf("%f",&p1->coef);printf("输入变量的指数：\n");scanf("%d",&p1->expo);p1->ch=c[0];p1->next=p->next;p->next=p1;}return p;}//删除节点返回剩下的链表首地址duoxiangshi * deletenode(duoxiangshi *h,duoxiangshi *maxp) {duoxiangshi *t;t=h;//找到要删除的节点的前节点while(t->next!=maxp){t=t->next;}//删除节点t->next=maxp->next;maxp->next=NULL;return h;}//求表长a用来记录长度void link_length(duoxiangshi *p,int &a){while(p->next!=NULL){p=p->next;a++;}}//将链表中的多项式的指数的大小排序duoxiangshi *sort(duoxiangshi *h){int min;//用于保存指数最小的值duoxiangshi *t=NULL,*minp=NULL,*head=NULL;if(h->next==NULL){printf("链表中不存在数据\n");exit(0);}//链表排序的思想和冒泡排序差不多，需要临时变量来存在当前最小值while(h->next!=NULL){t=h->next;//临时指针min=t->expo;//临时最小的指数值minp=t;//把当前t中的值作为最小while(t->next!=NULL)//如果t后面有节点就需要比较{t=t->next;//向后移动一位当前最小比较if(t->expo<min){min=t->expo;//每次记录最小的minp=t;}}h=deletenode(h,minp);//删除保存最小的指数的节点返回剩余的minp->next=head;//将每次的最小节点接在头结点之前head=minp;//head重新回到该链开头}h->next=head;//把head接在头结点之后return h;}//显示多项式void display_poly(duoxiangshi *p){int a;p=sort(p);//排序while(p->next!=NULL){a=1;p=p->next;if(p->coef<0) a=0;a?printf("+"):printf(" ");printf("%.6f%c^%d", p->coef, p->ch, p->expo);}printf("\n");}//查找指数为index的节点duoxiangshi *locate_link(duoxiangshi *p, int index) {p = p->next;while(p != NULL && p->expo != index)p = p->next;if(p == NULL)return NULL;elsereturn p;}//多一元多项式求导duoxiangshi *poly_qiudao(duoxiangshi *p){duoxiangshi *n,*q;q=p;if(p->next==NULL){printf("链表中没有数据\n");exit(0);}while(p->next!=NULL){p=p->next;if(p->expo==0||p->coef==0){q=deletenode(q,p);}n=q;//保存删除无用节点的链表之后的头结点，用于返回//有可能删除后就没有数据了if(q->next==NULL){printf("链表中没有数据\n");exit(0);}while(q->next!=NULL){q=q->next;//求导特点q->coef=q->coef*q->expo;q->expo=q->expo-1;}return n;}//创建多项式void creat(duoxiangshi *&p1,duoxiangshi *&p2){printf("创建第一个多项式\n");p1=creat_ploy(p1); //创建多项式printf("创建第二个多项式\n");p2=creat_ploy(p2);//创建多项式printf("第一个多项式:\n");display_poly(p1);printf("第二个多项式:\n");display_poly(p2);}//多项式相加duoxiangshi * poly_add(duoxiangshi *head1,duoxiangshi *head2,char a) {char ch[1];duoxiangshi *p1,*p2,*p,*r;p1=head1;p2=head2;if(a=='+') //只能是多项式的加法可以使用{system("cls");creat(p1,p2);//创建p1,p2}while(r->next!=NULL){p1=r->next;r=deletenode(r,p1); //删除p1p=locate_link(p2,p1->expo);//查找p2中是否有系数等于p1->expn的节点，有就返回该点，否则返回NULLif(p!=NULL){p->coef=p->coef+p1->coef;}else{p1->next=p2->next;p2->next=p1;}}if(a=='+'){printf("多项式相加后的结果是:\n");display_poly(p2);printf("需要知道多项式求导后的结果吗？:Y/N\n");scanf("%s", ch);//继续创建if(ch[0] == 'Y' || ch[0] == 'y'){p2=poly_qiudao(p2);display_poly(p2);//显示p2destroy_link(p2); //销毁链表}//不继续进行else{destroy_link(p2); //销毁链表}getchar();//吃掉输入的字符，让屏幕显示停在运算结果上return NULL;}return p2;}//多项式相减可以重用多项式相加只是变了符号void poly_sub(duoxiangshi *p1,duoxiangshi *p2){char ch[1];duoxiangshi *n,*p;system("cls"); //清屏creat(p1,p2);p=p2;//将后面的多项式全部相当于乘以-1while(p->next!=NULL){p=p->next;p->coef=-1*p->coef;}printf("多项式的相减结果是:\n");n=poly_add(p1,p2,'-');display_poly(n);printf("需要知道多项式求导后的结果吗？:Y/N\n");scanf("%s", ch);if( ch[0] == 'Y' || ch[0] == 'y'){n = poly_qiudao(n); //求导display_poly(n);destroy_link(n); //销毁}elsedestroy_link(n);getchar();}//多项式相乘的其中一个重用方法duoxiangshi * poly_multiply(duoxiangshi *p,float coef,int index){// 传入系数和指数，分别与p的每个节点运算最后返回该链duoxiangshi *q,*n;n = (duoxiangshi *)malloc(sizeof(duoxiangshi));//作为头节点n->next = NULL;while(p->next!=NULL){p = p->next;q = (duoxiangshi *)malloc(sizeof(duoxiangshi));q->ch = p->ch;q->coef=coef*p->coef;q->expo=index+p->expo;q->next=n->next;n->next=q;}return n;}//多项式相乘重用所用方法void run_mul(duoxiangshi *p1,duoxiangshi *p2,int num) {int i=0;char ch[1];duoxiangshi **p,*q;//二维指针存每次poly_multiply()函数返回的链表p=(duoxiangshi**)malloc(num*sizeof(duoxiangshi));//从p1的第一项开始依次乘以p2的每一项while(p1->next!=NULL){p1=p1->next;p[i++]=poly_multiply(p2,p1->coef,p1->expo);}q=poly_add(p[0],p[1],'*');for(i=2;i<num;i++){q=poly_add(q,p[i],'*');}printf("多项式相乘后的结果是:\n");display_poly(q);printf("需要知道多项式求导后的结果吗？:Y/N\n");scanf("%s", ch);if( ch[0] == 'Y' || ch[0] == 'y'){q = poly_qiudao(q); //求导display_poly(q);destroy_link(q); //销毁}else destroy_link(q);getchar();}//多项式相乘时真正方法void poly_mul(duoxiangshi *p1,duoxiangshi *p2){int num1=0,num2=0;system("cls");creat(p1, p2);//求两个链表长度保存在mum1和mum2中link_length(p1, num1);link_length(p2, num2);if(num2 >= num1) /*根据链表*/{run_mul(p1, p2, num1);}else{run_mul(p2, p1, num2);}}//选择函数int select(){printf("输入任何字符进入主菜单\n");getchar();//读入字符但不显示system("cls"); /*清屏*/printf("选择多项式的操作\n\n");printf("##################################\n");printf("1.多项式相加\n");printf("2.多项式相减\n");printf("3.多项式相乘\n");printf("4. 退出\n");printf("##################################\n");int n=0;do{printf("输入你的选择\n");scanf("%d",&n);}while(n<1||n>4);//如果操作不对则一直循环return n;}int main(){duoxiangshi *head1=NULL;duoxiangshi *head2=NULL;duoxiangshi *head3=NULL;//无限次死循环for(;;){switch(select()){case 1:head3=poly_add(head1, head2, '+'); break;case 2:poly_sub(head1, head2); break;case 3:poly_mul(head1, head2); break;case 4:exit(0); //退出}}return 0;}。
