数据结构多项式的加减(方法01)
多项式运算掌握多项式的加减乘除运算技巧
多项式运算掌握多项式的加减乘除运算技巧多项式是数学中重要的基础概念之一,它在代数运算中起着核心作用。
掌握多项式的加减乘除运算技巧是我们学习代数的基础,本文将介绍多项式的各种运算技巧。
一、多项式的加法运算多项式的加法运算是非常简单的,只需要把对应项的系数相加即可。
例如,给定两个多项式:P(x) = 3x^3 + 2x^2 + 5x - 4Q(x) = 2x^3 + 4x^2 + 2x + 1我们只需要对应地将各项的系数相加,得到它们的和:P(x) + Q(x) = (3+2)x^3 + (2+4)x^2 + (5+2)x + (-4+1)= 5x^3 + 6x^2 + 7x - 3二、多项式的减法运算多项式的减法运算与加法运算类似,只需要将对应项的系数相减即可。
例如,给定两个多项式:R(x) = 4x^3 + 2x^2 + 3x + 5S(x) = 2x^3 - x^2 + x - 2我们只需要用R(x)的系数减去S(x)的系数,得到它们的差:R(x) - S(x) = (4-2)x^3 + (2-(-1))x^2 + (3-1)x + (5-(-2))= 2x^3 + 3x^2 + 4x + 7三、多项式的乘法运算多项式的乘法运算相对复杂一些,需要将多项式的每一项与另一个多项式的每一项相乘,并将结果相加合并同类项。
例如,给定两个多项式:A(x) = x^2 + 2x + 3B(x) = x + 1我们可以按照如下步骤进行乘法运算:A(x) * B(x) = (x^2 * x) + (x^2 * 1) + (2x * x) + (2x * 1) + (3 * x) + (3 * 1)= x^3 + x^2 + 2x^2 + 2x + 3x + 3= x^3 + 3x^2 + 5x + 3四、多项式的除法运算多项式的除法运算需要利用长除法的方法,将被除式逐步除以除式,得到商和余数。
例如,给定两个多项式:C(x) = 2x^3 - x^2 + 3x + 4D(x) = x - 1我们可以进行如下的除法运算:2x^2 + x + 4___________________x - 1 | 2x^3 - x^2 + 3x + 4- (2x^3 - 2x^2)-----------------x^2 + 3x- (x^2 - x)---------------4x + 4- (4x - 4)------------8因此,C(x) 除以 D(x) 的商为 2x^2 + x + 4,余数为 8。
数据结构实验╲t多项式加法
实验一:完成多项式的相加运算(验证性、4学时)一、实验目的和要求完成多项式的相加、相乘运算。
(1)掌握线性表的插入、删除、查找等基本操作设计与实现(2)学习利用线性表提供的接口去求解实际问题(3)熟悉线性表的的存储方法二、实验内容和原理1.实验内容设计一个一元多项式的简单计算程序,其基本功能有:(1)输入并建立多项式;(2)输出多项式;(3)多项式的相加运算。
利用单链表实现。
(4) 多项式的相乘运算。
2.实验原理使用单链表实现一元多项式的存储,并实现两个一元多项式的加法运算。
三、实验环境硬件:(1)学生用微机(2)多媒体教室或远程教学(3)局域网环境软件:(1)Windows XP中文操作系统(2)Turbo C 3.0或者VC6.0四、算法描述及实验步骤1、描述对于两个多项式,将它们分别存入两个循环链表中,从两个多项式的链表的第一个元素结点开始检测,对每一个结点做如下操作:(1)若两个多项式中对应结点的指数值相等,则将它们的系数相加。
如果相加结果不为零,则形成一个新结点后链入新链表的末尾。
然后再检测两个链表中的下一个结点。
(2)若两个多项式中对应结点的指数值不相等,则复抄指数值大的那个结点中的指数值与系数值,形成一个新结点后链入(1)中所述的链表尾。
然后再检测指数值小的链表中的当前结点与指数值大的链表中的下一个结点。
上述过程一直做到两个链表中的链表中的所有结点均检测完为止。
2、算法流程图beginscanfNODE *Creat(int n)-1 0 1Y N3、代码(注释)#include <stdio.h>#include <malloc.h>#include <stdlib.h>#define NULL 0 head = (NODE *)malloc(sizeof(NODE)); NODE *AddPolyn(NODE *head1, NODE *head2)qa && qb a = qa->expn; b = qb->expn; ompare(a, b)ha = qa;qa = qa->next; sum = qa->coef + qb->coef; qb = hb->next;ha = ha->next; sum != 0.0 qa->coef = sum; ha = qa; free(Delfirst(ha,qa)) free(Delfirst(hb, qb)) qa = ha->next; qb = hb->next; NODE *Delfirst(NODE *p1, NODE *q) end printftypedef struct NODE{ float coef; //系数int expn; //指数struct NODE *next;}NODE;NODE *Creat(int n);void print(NODE *head);NODE *AddPolyn(NODE *head1, NODE *head2); NODE *Delfirst(NODE *head, NODE *q);void InsertBefore(NODE *p1, NODE *p2);int compare(int a, int b);main(){NODE *head1, *head2, *head3;int n1, n2;printf("请输入你需要的多项数的数目n1 : ");scanf("%d", &n1);head1 = Creat(n1);printf("第一个多项式的显示: \n");print(head1);printf("\n请输入你需要的多项数的数目n2 : ");scanf("%d", &n2);head2 = Creat(n2);printf("\n第二个多项式的显示: \n");print(head2);head3 = AddPolyn(head1, head2);printf("\n合并后的多项式的显示: \n");print(head3);printf("\n");}NODE *Creat(int n) /*创建链表*/{NODE *current, *previous, *head;int i;head = (NODE *)malloc(sizeof(NODE)); /*创建头结点*/ previous = head;for(i = 0; i < n; i++){current = (NODE *)malloc(sizeof(NODE));printf("请输入系数和指数: ");scanf("%f%d", ¤t->coef, ¤t->expn); previous->next = current;previous = current;}previous->next = NULL;return head;}/*一元多项式的想加,总体考虑,可分qa的指数比qb小,或等于pb(如果系数相加等于0和不等于0),或大于pb里面由InsertBefore和Delfirst两个小模块组成一部分*/NODE *AddPolyn(NODE *head1, NODE *head2){NODE *ha, *hb, *qa, *qb;int a, b;float sum;ha = head1; /*ha和hb指向头结点*/hb = head2;qa = ha->next; /*qa和qb指向头结点的下一个结点*/qb = hb->next;while(qa && qb) /*qa和qb均非空*/{a = qa->expn;b = qb->expn;switch(compare(a, b)) {case -1 : /*qa->expn < qb->expn*/ha = qa;qa = qa->next;break;case 0 :sum = qa->coef + qb->coef; /*系数的和*/if(sum != 0.0) /*如果不是0.0*/{qa->coef = sum; /*改变系数*/ha = qa;}else{ free(Delfirst(ha, qa));}free(Delfirst(hb, qb));qa = ha->next;qb = hb->next; /*qb释放后要重新赋值*/break;case 1 : /*如果qa-> expn > qb -> expn*/Delfirst(hb, qb);InsertBefore(ha, qb); /*把qb插入到ha下一个结点之前*/qb = hb->next;ha = ha->next;break;}}if(qb)ha->next = qb; /*插入剩余的pb*/free(head2);return head1;}int compare(int a, int b) /*比较*/{if(a < b)return -1;else if(a > b)return 1;elsereturn 0;}NODE *Delfirst(NODE *p1, NODE *q) /*删除结点q*/{p1 -> next = q -> next;return (q);}/*插入结点,引入结点p,可以让p插入到p2和p1之间*/void InsertBefore(NODE *p1, NODE *p2){NODE *p;p = p1->next;p1->next = p2;p2->next = p;}void print(NODE *head){NODE *current;current = head->next;while(current->next != NULL){printf("%0.f * x^%d + ", current->coef, current->expn);current = current -> next;}printf("%0.f * x^%d", current->coef, current->expn);}五、调试过程#include "alloc.h"语句出错,少了一个m,改为#include "malloc.h",则编译通过了。
多项式的加减乘除运算
多项式的加减乘除运算多项式是数学中常见的代数表达式形式,由多个项组成。
每个项由系数和指数两部分组成,例如3x^2和5y表示两个多项式的项。
多项式的加减乘除运算是数学中重要的概念,本文将详细介绍多项式的加减乘除运算规则及相应的例子。
一、多项式的加法运算多项式的加法运算是将两个多项式按照相同指数的项进行合并。
在进行加法运算时,只需将对应指数的项的系数相加即可,而不同指数的项则需要保留原样。
例如,考虑以下两个多项式:P(x) = 3x^2 + 2x + 5Q(x) = 4x^2 - x + 3将两个多项式进行加法运算时,我们将对应指数的项的系数相加,不同指数的项保留原样。
按照这个规则,我们可以将上述两个多项式相加得到:P(x) + Q(x) = (3x^2 + 4x^2) + (2x - x) + (5 + 3)= 7x^2 + x + 8因此,P(x) + Q(x) = 7x^2 + x + 8。
二、多项式的减法运算多项式的减法运算是将两个多项式按照相同指数的项进行合并,并将减数的项的系数取负。
也就是说,我们将第二个多项式的各项的系数取相反数,然后按照相同指数的项进行合并。
考虑以下两个多项式:P(x) = 3x^2 + 2x + 5Q(x) = 4x^2 - x + 3我们将P(x) - Q(x)展开运算:P(x) - Q(x) = (3x^2 - 4x^2) + (2x + x) + (5 - 3)= -x^2 + 3x + 2所以, P(x) - Q(x) = -x^2 + 3x + 2。
三、多项式的乘法运算多项式的乘法运算是将两个多项式的各项进行配对相乘,并将同指数的各项相加。
例如,考虑以下两个多项式:P(x) = 3x^2 + 2x + 5Q(x) = 4x - 1我们将P(x) * Q(x)展开运算:P(x) * Q(x) = (3x^2 * 4x) + (3x^2 * -1) + (2x * 4x) + (2x * -1) + (5 * 4x) + (5 * -1)= 12x^3 - 3x^2 + 8x^2 - 2x + 20x - 5= 12x^3 + 5x^2 + 18x - 5所以,P(x) * Q(x) = 12x^3 + 5x^2 + 18x - 5。
多项式相加数据结构
多项式相加数据结构多项式相加是一种常见的数学操作,它在数据结构中也有广泛的应用。
本文将介绍多项式相加的概念、实现方法以及应用场景。
## 一、多项式相加的概念多项式是由常数项和一系列幂次项组成的代数表达式,形如:P(x) = a0 + a1x + a2x^2 + ... + anx^n其中,ai为系数,x为变量,n为最高次数。
多项式相加即将两个或多个多项式相加得到一个新的多项式。
## 二、多项式相加的实现方法多项式相加的实现方法有多种,常见的有数组表示法、链表表示法和稀疏矩阵表示法。
1. 数组表示法:将多项式的系数存储在一个数组中,数组下标表示幂次,数组元素表示系数。
2. 链表表示法:将多项式的每一项用链表的形式连接起来,每个节点包含系数和幂次信息。
3. 稀疏矩阵表示法:对于稀疏的多项式,只存储非零项的信息,可以用矩阵的形式表示。
不同的表示方法适用于不同的场景,选择合适的实现方法可以提高多项式相加的效率和灵活性。
## 三、多项式相加的应用场景多项式相加在实际应用中有很多场景,以下列举几个常见的应用场景:1. 数据压缩:在某些情况下,数据具有稀疏性,多项式相加可以将稀疏数据压缩为较小的存储空间,减少数据传输和存储成本。
2. 图像处理:图像的滤波操作可以看作是将图像的像素值与一个多项式进行相加的过程,通过调整多项式的系数可以实现不同的滤波效果。
3. 信号处理:信号可以表示为一个多项式的形式,多项式相加可以实现信号的叠加和混合,用于音频合成、语音识别等应用。
4. 机器学习:在机器学习算法中,多项式相加可以用于特征工程,通过将不同特征的多项式进行相加,得到新的特征表示,提高模型的拟合能力。
## 四、总结多项式相加是一种常见的数学操作,在数据结构中有广泛的应用。
本文介绍了多项式相加的概念、实现方法和应用场景,并提到了多项式相加在数据压缩、图像处理、信号处理和机器学习等领域的重要性。
选择合适的实现方法和应用场景可以提高多项式相加的效率和灵活性,进而推动相关领域的发展和应用。
多项式加减法
主要目的是实现多项式的加法和减法,那么可以先把目光集中在具体的算法上,而输入输出可以简化先,等把多项式的加法减法实现
,第再一进 项一是步否完有善符输号链入(表输加2出号表可示以多省项略式,2 减号不可2以省略3)
35
-3 8 ^
void read();
在加链号表 还1是的减基号从础?上通链对过表其判进断1行和系结数链点与的表0插的2入大的和小删,头除决部,定得是开到否始结要果加进多上行项“式+指”。数比较。指数相等则系数相加,把结 用一个队列表果示一结个点多项链式接到链表3的尾部,删除多余结点;该结点指数唯一,则直接将
c用la队ss列P表oly示n的o该m上ia述节l:p多r点iv项at式链e E接xten到de链d_q表ueu3e的尾部
链表3表示结果多项式
60
链表1为空,链表2为空
结果多项式为 62x32x5
23
-2 5 ^
多项式的表示2:链表
方式三:新开辟结点空间,结果用一个新链表存放
65x53x8
链表1表示多项式1
class Polynomial:private Extended_queue { public:
void read(); void print()const; void equals_sum(Polynomial p,Polynomial q); void equals_difference(Polynomial p,Polynomial q); };
方式二:利用原结点空间,结果用一个新链表存放 队列表示:相应多项式加法算法(减法类似)
void equals_sum(Polynomial p,Polynomial q);
队列中的每个成员是多项式的一项
数据结构课程设计—一元多项式加法、减法、乘法运算的实现
1.一元多项式加法、减法、乘法运算的实现1.1设计内容及要求1)设计内容(1)使用顺序存储结构实现多项式加、减、乘运算。
例如:10321058)(2456+-+-+=x x x x x x f ,x x x x x x g +--+=23451020107)(求和结果:102220128)()(2356++-+=+x x x x x g x f(2)使用链式存储结构实现多项式加、减、乘运算,10305100)(1050100+-+=x x x x f ,x x x x x x g 320405150)(10205090+++-=求和结果:1031040150100)()(102090100++-++=+x x x x x x g x f2)设计要求(1)用C 语言编程实现上述实验内容中的结构定义和算法。
(2)要有main()函数,并且在main()函数中使用检测数据调用上述算法。
(3)用switch 语句设计如下选择式菜单。
***************数据结构综合性实验***********************一、多项式的加法、减法、乘法运算***************** 1.多项式创建 ***************** 2.多项式相加 ***************** 3.多项式相减 ***************** 4.多项式相乘 ***************** 5.清空多项式 ***************** 0.退出系统 ***************** 请选择(0—5) ************************************************************请选择(0-5):1.2数据结构设计根据下面给出的存储结构定义:#define MAXSIZE 20 //定义线性表最大容量//定义多项式项数据类型typedef struct{float coef; //系数int expn; //指数}term,elemType;typedef struct{term terms[MAXSIZE]; //线性表中数组元素int last; //指向线性表中最后一个元素位置}SeqList;typedef SeqList polynomial;1.3基本操作函数说明polynomial*Init_Polynomial();//初始化空的多项式int PloynStatus(polynomial*p)//判断多项式的状态int Location_Element(polynomial*p,term x)在多项式p中查找与x项指数相同的项是否存在int Insert_ElementByOrder(polynomial*p,term x)//在多项式p中插入一个指数项xint CreatePolyn(polynomial*P,int m)//输入m项系数和指数,建立表示一元多项式的有序表pchar compare(term term1,term term2)//比较指数项term1和指数项term2polynomial*addPloyn(polynomial*p1,polynomial*p2)//将多项式p1和多项式p2相加,生成一个新的多项式polynomial*subStractPloyn(polynomial*p1,polynomial*p2) //多项式p1和多项式p2相减,生成一个新的多项式polynomial*mulitPloyn(polynomial*p1,polynomial*p2)//多项式p1和多项式p2相乘,生成一个新的多项式void printPloyn(polynomial*p)//输出在顺序存储结构的多项式p1.4程序源代码#include<stdlib.h>#include<stdio.h>#include<iostream.h>#define NULL 0#define MAXSIZE 20typedef struct{float coef;int expn;}term,elemType;typedef struct{term terms[MAXSIZE];int last;}SeqList;typedef SeqList polynomial;void printPloyn(polynomial*p);int PloynStatus(polynomial*p){if(p==NULL){return -1;}else if(p->last==-1){return 0;}else{return 1;}}polynomial*Init_Polynomial(){polynomial*P;P=new polynomial;if(P!=NULL){P->last=-1;return P;}else{return NULL;}}void Reset_Polynomial(polynomial*p){if(PloynStatus(p)==1){p->last=-1;}}int Location_Element(polynomial*p,term x){int i=0;if(PloynStatus(p)==-1)return 0;while(i<=p->last && p->terms[i].expn!=x.expn) {i++;}if(i>p->last){return 0;}else{return 1;}}int Insert_ElementByOrder(polynomial*p,term x){int j;if(PloynStatus(p)==-1)return 0;if(p->last==MAXSIZE-1){cout<<"The polym is full!"<<endl;return 0;}j=p->last;while(p->terms[j].expn<x.expn && j>=0){p->terms[j+1]=p->terms[j];j--;}p->terms[j+1]=x;p->last++;return 1;}int CreatePolyn(polynomial*P,int m){float coef;int expn;term x;if(PloynStatus(P)==-1)return 0;if(m>MAXSIZE){printf("顺序表溢出\n");return 0;}else{printf("请依次输入%d对系数和指数...\n",m);for(int i=0;i<m;i++){scanf("%f%d",&coef,&expn);x.coef=coef;x.expn=expn;if(!Location_Element(P,x)){Insert_ElementByOrder(P,x);}}}return 1;}char compare(term term1,term term2){if(term1.expn>term2.expn){return'>';}else if(term1.expn<term2.expn){return'<';}else{return'=';}}polynomial*addPloyn(polynomial*p1,polynomial*p2){int i,j,k;i=0;j=0;k=0;if((PloynStatus(p1)==-1)||(PloynStatus(p2)==-1)){return NULL;}polynomial*p3=Init_Polynomial();while(i<=p1->last && j<=p2->last){switch(compare(p1->terms[i],p2->terms[j])){case'>':p3->terms[k++]=p1->terms[i++];p3->last++;break;case'<':p3->terms[k++]=p2->terms[j++];p3->last++;break;case'=':if(p1->terms[i].coef+p2->terms[j].coef!=0){p3->terms[k].coef=p1->terms[i].coef+p2->terms[j].coef;p3->terms[k].expn=p1->terms[i].expn;k++;p3->last++;}i++;j++;}}while(i<=p1->last){p3->terms[k++]=p1->terms[i++];p3->last++;}return p3;}polynomial*subStractPloyn(polynomial*p1,polynomial*p2){int i;i=0;if((PloynStatus(p1)!=1)||(PloynStatus(p2)!=1)){return NULL;}polynomial*p3=Init_Polynomial();p3->last=p2->last;for(i=0;i<=p2->last;i++){p3->terms[i].coef=-p2->terms[i].coef;p3->terms[i].expn=p2->terms[i].expn;}p3=addPloyn(p1,p3);return p3;}polynomial*mulitPloyn(polynomial*p1,polynomial*p2){int i;int j;int k;i=0;if((PloynStatus(p1)!=1)||(PloynStatus(p2)!=1)){return NULL;}polynomial*p3=Init_Polynomial();polynomial**p=new polynomial*[p2->last+1];for(i=0;i<=p2->last;i++){for(k=0;k<=p2->last;k++){p[k]=Init_Polynomial();p[k]->last=p1->last;for(j=0;j<=p1->last;j++){p[k]->terms[j].coef=p1->terms[j].coef*p2->terms[k].coef;p[k]->terms[j].expn=p1->terms[j].expn+p2->terms[k].expn;}p3=addPloyn(p3,p[k]);}}return p3;}void printPloyn(polynomial*p){int i;for(i=0;i<=p->last;i++){if(p->terms[i].coef>0 && i>0)cout<<"+"<<p->terms[i].coef;elsecout<<p->terms[i].coef;cout<<"x^"<<p->terms[i].expn;}cout<<endl;}void menu(){cout<<"\t\t*******数据结构综合性实验*********"<<endl;cout<<"\t\t***一、多项式的加、减、乘法运算***"<<endl;cout<<"\t\t******* 1.多项式创建 *********"<<endl;cout<<"\t\t******* 2.多项式相加 *********"<<endl;cout<<"\t\t******* 3.多项式相减 *********"<<endl;cout<<"\t\t******* 4.多项式相乘 *********"<<endl;cout<<"\t\t******* 5.清空多项式 *********"<<endl;cout<<"\t\t******* 0.退出系统 *********"<<endl;cout<<"\t\t****** 请选择(0-5) ********"<<endl;cout<<"\t\t***********************************"<<endl; }void main(){int sel;polynomial*p1=NULL;polynomial*p2=NULL;polynomial*p3=NULL;while(1){menu();cout<<"\t\t*请选择(0-5):";cin>>sel;switch(sel){case 1:p1=Init_Polynomial();p2=Init_Polynomial();int m;printf("请输入第一个多项式的项数:\n");scanf("%d",&m);CreatePolyn(p1,m);printf("第一个多项式的表达式为p1=");printPloyn(p1);printf("请输入第二个多项式的项数:\n");scanf("%d",&m);CreatePolyn(p2,m);printf("第二个多项式的表达式为p2=");printPloyn(p2);break;case 2:printf("p1+p2=");if((p3=subStractPloyn(p1,p2))!=NULL)printPloyn(p3);break;case 3:printf("\np1-p2=");if((p3=subStractPloyn(p1,p2))!=NULL)printPloyn(p3);break;case 4:printf("\np1*p2=");if((p3=mulitPloyn(p1,p2))!=NULL)printPloyn(p3);case 5:Reset_Polynomial(p1);Reset_Polynomial(p2);Reset_Polynomial(p3);break;case 0:return;}}return;}1.5程序执行结果2.迷宫问题实现2.1设计内容及要求1)设计内容以一个m*n的长方阵表示迷宫,0和1分别表示迷宫中的通路和障碍。
数据结构一元多项式的运算
数据结构一元多项式的运算正文:1. 引言本文档旨在介绍数据结构中一元多项式的运算方法。
一元多项式是指在一个变量上的多项式,其中每一项由一个系数和一个指数组成。
我们将会讨论一元多项式的表示、存储和基本运算,包括多项式的加法、减法、乘法和求导等操作。
2. 一元多项式的表示和存储2.1 一元多项式的定义一元多项式是指在一个变量x上的多项式,每一项由一个系数和一个指数组成,例如:2x^3 - 5x^2 + 3x + 1.其中,2、-5、3和1分别是系数,3、2、1和0分别是指数。
2.2 一元多项式的表示方法一元多项式可以使用数组、链表或其他数据结构来表示。
在本文中,我们选择使用数组来表示一元多项式。
数组的索引代表指数,数组的元素代表系数。
例如,多项式 2x^3 - 5x^2 + 3x + 1 可以表示为 [1, 3, -5, 2]。
2.3 一元多项式的存储结构为了表示一元多项式,我们可以使用一个数组来存储多项式的系数。
数组的长度应该比多项式的最高指数大1.数组的索引代表指数,数组的元素代表系数。
例如,数组 [1, 3, -5, 2] 表示的多项式 2x^3 - 5x^2 + 3x + 1 中,索引0对应指数为3的项,索引1对应指数为2的项,以此类推。
3. 一元多项式的基本运算3.1 一元多项式的加法一元多项式的加法是指将两个多项式相加,并合并同类项。
具体操作如下:- 将两个多项式的系数相加,并将结果存储在一个新的多项式中。
- 遍历新的多项式,将相邻的相同指数的项合并。
3.2 一元多项式的减法一元多项式的减法是指将一个多项式减去另一个多项式,并合并同类项。
具体操作如下:- 将两个多项式的系数相减,并将结果存储在一个新的多项式中。
- 遍历新的多项式,将相邻的相同指数的项合并。
3.3 一元多项式的乘法一元多项式的乘法是指将两个多项式相乘,并合并同类项。
具体操作如下:- 遍历一个多项式的每一项,与另一个多项式的每一项相乘。
数据结构——链表实现一元多项式的表示和加法
数据结构——链表实现⼀元多项式的表⽰和加法⼀元多项式的链式结构: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*/。
多项式相加数据结构
多项式相加数据结构多项式相加数据结构是一种用于处理多项式加法的算法和数据结构。
在数学中,多项式是由常数和变量的乘积相加而成的表达式。
例如,2x² + 3x + 4就是一个多项式。
在计算机科学中,我们需要对多项式进行操作,如求导、求积分、求根、求值等。
对于两个多项式P(x)和Q(x),它们的加法可以表示为:R(x) = P(x) + Q(x),即将它们的同类项相加得到结果R(x)。
例如,(2x² + 3x + 4) + (4x² - 2x + 1) = 6x² + x + 5。
实现多项式相加有很多方法,其中一种常见的方法是使用链表来存储每个非零系数的项。
链表中每个节点包含两个字段:系数和指数。
系数表示该项的系数,指数表示该项中变量的指数。
例如,在上面的例子中,第一个多项式可以表示为:2 -> 2 -> null其中第一个节点表示系数为2、指数为2(即2x²)的一项,第二个节点表示系数为3、指数为1(即3x)的一项。
使用链表存储多项式有以下优点:1. 可以灵活地插入和删除节点,方便进行各种操作。
2. 可以节省空间,因为只存储非零系数的项,而且指数是有序的。
3. 可以方便地进行排序和合并,因为链表中的节点是有序的。
下面是一个简单的多项式相加算法:1. 创建一个空链表R,用于存储结果。
2. 从P和Q的头节点开始遍历它们的链表。
3. 如果P和Q都还有节点,则比较它们的指数大小:a. 如果P的指数小于Q的指数,则将P节点插入到R中,并移动P 指针到下一个节点。
b. 如果Q的指数小于P的指数,则将Q节点插入到R中,并移动Q指针到下一个节点。
c. 如果P和Q的指数相等,则将它们对应系数相加得到新系数,并创建一个新节点插入到R中。
然后移动P和Q指针到下一个节点。
4. 如果其中一个链表已经遍历完了,则将另一个链表剩余部分直接插入到R中。
5. 返回结果链表R。
数据结构实验多项式加法
数据结构实验报告实验名称:多项式加减法学号:19姓名:林强实验日期:一、实验目的通过实现多项式的加减法,对链表有更深入的了解二、实验具体内容1、实验题目1:(1)题目设计一个一元稀疏多项式简单的加减法计算器实现要求:一元稀疏多项式简单计算器的基本功能是:(1)输入并建立多项式:8517A+x+x=;+73x9)(x798xB-+x=822x)(x(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->expn<qb->expn){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<<"请输入数据:"<<endl;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){cout<<"("<<L1->next->coef<<","<<L1->next->expn<<")"<<" ";L1=L1->next;}//输出计算结果}三、实验小结通过编写多项加法这个程序,我将自己所学到的创建链表,初始化链表和多项式加法算法都应用了一次,这使我们不仅仅只是理论化的学习书本上的知识,而是将学习到的理论知识应用到实际的操作中来增强我们的实际操作能力,这使我增加了实际操作经验,也使我通过实际操作来认识到自己在程序编写上的不足从而增强了我的实际编写程序的能力。
数据结构多项式加减
{
return;
}
else
{
for(;q!=NULL;q=q->next)
{
s=new node;
s->next=NULL;
s->coef=-q->coef;
delete head2;
}
print=head1->next;
while(print!=NULL)
{
cout<<print->coef<<" "<<print->exp<<endl;
head1->next=NULL;
node*head2=new node;
head2->next=NULL;
node*head3=new node;
head3->next=NULL;
node*head4=new node;
}
else
{
pre=p;
p=p->next;
}
qre->next=q->next;
{
cout<<-p->coef<<" "<<p->exp<<endl;
p=p->next;
}
}
else if(n!=0&&m==0||head1->next!=NULL&&head2->next==NULL)
{
}
}
}
数据结构实验-多项式的相加减
集美大学数据结构课程实验报告课程名称:数据结构班级:网络0911实验成绩:指导教师:姓名:实验项目名称:多项式的相加减学号上机实践日期:实验项目编号:组号:上机实践时间:学时一、目的(本次实验所涉及并要求掌握的知识点)学习和掌握如何运用链表来实现一元稀疏多项式的相加减。
多项式的输入和输出的应注意的要点,规定输出的多项式的顺序。
二、实验内容与设计思想(设计思路、主要数据结构、主要代码结构、)实验内容:一元稀疏多项式的相加减设计思路:建立数据结构存放常数和系数以及指向下一个节点的指数,用链表存放各个节点,通过对常数和系数的的运算,实现多项式的相加减主要数据结构:结构体,链表主要代码结构:struct Polyn;void addPolyn(Polyn * a,Polyn * b,int add);void display( );void tip()’Polyn * CreatPolyn(int m);三、实验使用环境(本次实验所使用的平台和相关软件)Dev-C++、windows XP四、实验步骤和调试过程(实验步骤、测试数据设计、测试结果分析)需说明出,加入必要的截图说明。
#include<iostream>#include<vector>using namespace std;struct Polyn{float coef;int expn;Polyn *next;};//构建结构体vector <Polyn *> ve;void addPolyn(Polyn * a,Polyn * b,int add);void display(Polyn *n);//打印void tip();//屏幕显示Polyn * CreatPolyn(int m); //建立多项式int main(){tip();system("pause");}void tip(){Polyn *first, *second,*s;int m;for( int i=1;i;){cout<<" 多项式运算.\n";cout<<"======================="<<"\n"; cout<<" 1------ 构造多项式.\n";cout<<" 2------ 多项式相加.\n";cout<<" 3------ 多项式相减.\n";cout<<" 0------ 结束.\n";cout<<"======================="<<"\n"; cout<<" 请输入您的选择.\n";cin>>i;switch(i){case 1:cout<<"请输入多项式的项数.\n";cin>>m;s=CreatPolyn(m);display(s);ve.push_back(s);break;case 2:first=ve.back();ve.pop_back();second=ve.back();addPolyn(first,second,0);break;case 3:first=ve.back();ve.pop_back();second=ve.back();addPolyn( first,second,1);break;case 0:cout<<" 再见"<<"\n";break;};}}Polyn* CreatPolyn(int m){Polyn* px=new Polyn[m];cout<<" 输入系数.\n";for(int i=0;i<m;i++)cin>>px[i].coef;cout<<"输入与系数相对应的指数.\n";for(int i=0;i<m;i++){cin>>px[i].expn;if(i!=m-1)px[i].next=&px[i+1];elsepx[i].next=NULL;}return px;}void display(Polyn *n){int q=0;Polyn * r;r=n;for(;r;r=r->next){if(r->coef)q++;if(r==n){if(r->coef!=0)cout<<r->coef<<"X"<<"^"<<r->expn;}else{if( r->coef>0)cout<<"+"<<r->coef<<"X"<<"^"<<r->expn;if(r->coef<0)cout<<r->coef<<"X"<<"^"<<r->expn;}}cout<<"\n";if(q==0)cout<<"0"<<"\n";}void addPolyn(Polyn * a,Polyn * b,int add)//两个多项式的加减{float c;int a1=1,b1=1,s,e;Polyn *ha,*hb,*p,*r;ha=a;hb=b;p=ha;r=hb;for(int i=0;ha[i].next;++i)a1++;for(int i=0;hb[i].next;++i)b1++;ha[a1-1].next=hb;for(int j=0;j<b1;j++){for(int i=0;i<a1;i++){if(a[i].expn-b[j].expn==0){if(add)ha[i].coef=ha[i].coef-hb[j].coef;elseha[i].coef=ha[i].coef+hb[j].coef;if(hb!=&hb[j])hb[j-1].next=hb[j].next;else{hb=hb[j].next;ha[a1-1].next=hb;}i=a1;}}}for(;p;p=p->next){for( Polyn * t=p->next;t;t=t->next)if( p->expn>t->expn){e=p->expn;p->expn=t->expn;t->expn=e;c=p->coef;p->coef=t->coef;t->coef=c;}}display(ha);}五、实验小结(实验中遇到的问题及解决过程、实验体会和收获)至少两点1.刚开始实现多项式的相加减运算时,申请一个新的空间来存放结果,结果指针乱了,后来改成了现在的程序。
数据结构实验-一元多项式的加法运算
一元多项式加法一、实验目的通过实现多项式加法,对链表有更深入的了解二、实验内容问题描述:设计一个一元稀疏多项式简单的加法计算器实现要求:一元稀疏多项式简单计算器的基本功能是:(1)输入并建立多项式:1785937)(x x x x A +++=;879228)(x x x x B -+=(2)输出多项式(3)多项式A 和B 相加,建立多项式C =A +B ,并输出相加的结果多项式C(4)选作:多项式A 和B 相减,建立多项式C =A -B ,并输出相减的结果多项式D 方法说明:(1)多项式的输入与存储用带表头结点的单链表存储多项式,链表中的每个节点分别存储多项式各项的系数和指数,即每从键盘输入多项式的一对数(系数,指数),可对应建立链表的一个结点。
每个节点的结构为:建立两个链表,其中pa 和pb 分别为它们的头指针:pb结果链表Pa(或者是Pc)Pc(2)多项式数据类型的定义struct tagNode{float coef;int exp;struct tagNode *next;typedef struct tagNode Node;typedef struct tagNode* pNode;(3)主要算法①创建两个链表,分别存放多项式1和多项式2,这两个链表中的节点是按指数降序或者升序排列的②多项式相加,下面给出多项式相加的部分实现/*下面的函数实现两个多项式的相加,要相加的链表分别由pa和pb指向(其中,pa,pb都是分配了空间的头结点)。
相加的结果直接由pa指向的链表保存,即是在pa链表中添加或删除(当系数因为相加为0的情况下)一些结点,构成结果。
相加的链表中指数按从小到大的顺序排列好的,是升序链表。
*/void add_poly(Node *pa,Node *pb){Node *p=pa->pNext;//链表1,将来的结果也放在此Node *q=pb->pNext;//链表2Node *pre=pa;Node *u;//临时用float x;while (p!=NULL && q!=NULL)//当两个链表都不为空{if (p->exp<q->exp)//比较链表1跟链表2当前节点的指数大小,链表1也是存放结果的地方{pre=p;p=p->pNext;//p指向要比较的下一个结点。
数据结构多项式运算的程序(加减法和乘法)C语言版
数据结构多项式运算的程序(加减法和乘法)C语言版#include#includetypedef struct node{//定义节点类型float coef;int expn;struct node * next;}PLOY;void start()//用户选择界面{printf("************************************\n");printf(" 两个一元多项式的相加/相减,相乘:\n");printf("************************************\n");printf("请选择操作:\n");printf("0.退出\n");printf("1.两个一元多项式相加\n");printf("2.两个一元多项式相乘\n");printf("3.两个一元多项式相减\n");}void insert(PLOY *head,PLOY *inpt)//查找位置插入新链节程序{PLOY *pre,*now;int signal=0;pre=head;//pre定义为现在的前一个链节if(pre->next==NULL) {pre->next=inpt;}else {now=pre->next;while(signal==0){if(inpt->expnexpn)//当新链节小于现在的连接时向后移一个链节{if(now->next==NULL){now->next=inpt;signal=1;}else{pre=now;now=pre->next;}}elseif(inpt->expn>now->expn)//如果发现比现在的链节大了就插入到这个连接的前面{inpt->next=now;pre->next=inpt;signal=1;}else{now->coef=now->coef+inpt->coef;signal=1;free(inpt);//与当前链节相等指数if(now->coef==0){pre->next=now->next;free(now);}}}}}PLOY *creat(char ch)//输入多项式{PLOY *head,*inpt;float x;int y;head=(PLOY *)malloc(sizeof(PLOY));//创建链表头head->next=NULL;printf("请输入一元多项式%c:(格式是:系数指数;以0 0 结束!)\n",ch);scanf("%f %d",&x,&y);while(x!=0){inpt=(PLOY *)malloc(sizeof(PLOY));//创建新链节inpt->coef=x;inpt->expn=y;inpt->next=NULL;insert(head,inpt);//不然就查找位置并且插入新链节printf("请输入一元多项式%c的下一项:(以0 0 结束!)\n",ch);scanf("%f %d",&x,&y);}return head;}PLOY *addPLOY(PLOY *head,PLOY *pre)//多项式相加{PLOY *inpt;int flag=0;while(flag==0){if(pre->next==NULL)flag=1;//当现在指向空时跳出循环else{pre=pre->next;inpt=(PLOY *)malloc(sizeof(PLOY));//创建新链节inpt->coef=pre->coef;inpt->expn=pre->expn;inpt->next=NULL;insert(head,inpt);}//否则把当前"g(x)"的链节插入到"y(x)"中}return head;}PLOY *minusPLOY(PLOY *head,PLOY *pre)//多项式相加{PLOY *inpt;int flag=0;while(flag==0){if(pre->next==NULL)flag=1;//当现在指向空时跳出循环else{pre=pre->next;inpt=(PLOY *)malloc(sizeof(PLOY));//创建新链节inpt->coef=0-pre->coef;inpt->expn=pre->expn;inpt->next=NULL;insert(head,inpt);}//否则把当前"g(x)"的链节插入到"y(x)"中}return head;}PLOY *byPLOY(PLOY *head1,PLOY *head2)//多项式相乘{PLOY *inpt,*res,*pre;int flag=0;res=(PLOY *)malloc(sizeof(PLOY));//创建链表头res->next=NULL;head1=head1->next;pre=head2;while(flag==0){if(pre->next==NULL){pre=head2;//当现在指向空时跳出循环head1=head1->next;continue;}if(head1==NULL){flag=1;//当现在指向空时跳出循环continue;}pre=pre->next;inpt=(PLOY *)malloc(sizeof(PLOY));//创建新链节inpt->coef=pre->coef*head1->coef;inpt->expn=pre->expn+head1->expn;inpt->next=NULL;insert(res,inpt);//把当前"g(x)"的链节插入到"y(x)"中}return res;}void print(PLOY *fun)//输出多项式{PLOY *printing;int flag=0;printing=fun->next;//正在被打印的链节if(fun->next==NULL)//如果函数为空打印0{printf("0\n");return;}while(flag==0){if(printing->coef>0&&fun->next!=printing) printf("+");//为正数时打印"+"号if(printing->coef==1);//如果为"1"就不用打印系数了else if(printing->coef==-1)printf("-");//如果为"-1"就打印"-"号就行了elseprintf("%f",printing->coef);//其余情况都得打印if(printing->expn!=0) printf("x^%d",printing->expn);//如果指数为"0"不打印指数项else if((printing->coef==1)||(printing->coef==-1))printf("1");if(printing->next==NULL)flag=1;//如果现在的链节没有下一个就结束elseprinting=printing->next;}printf("\n");}void main(){PLOY *f,*g;int sign=-1;//设置标志start();while(sign!=0){scanf("%d",&sign);switch(sign){case 0:break;//退出case 1:printf("你选择的操作是多项式相加:\n"); f=creat('f');//输入多项式f(x)printf("f(x)=");print(f);g=creat('g');//输入多项式g(x)printf("g(x)=");print(g);printf("F(x)=f(x)+g(x)=");f=addPLOY(f,g);//两个多项式相加print(f);sign=-1;//复位标志start();//回复用户选择界面break;}case 2:{printf("你选择的操作是多项式相乘:\n"); f=creat('f');//输入多项式f(x)printf("f(x)=");print(f);g=creat('g');//输入多项式g(x)printf("g(x)=");print(g);printf("F(x)=f(x)*g(x)=");f=byPLOY(f,g);//两个多项式相加print(f);sign=-1;//复位标志start();//回复用户选择界面break;case 3:{printf("你选择的操作是多项式相减:\n");f=creat('f');//输入多项式f(x)printf("f(x)=");print(f);g=creat('g');//输入多项式g(x)printf("g(x)=");print(g);printf("F(x)=f(x)-g(x)=");f=byPLOY(f,g);//两个多项式相加print(f);sign=-1;//复位标志start();//回复用户选择界面break;}default:{printf("输入有误!请重新选择操作!\n");//选择错误,返回选择界面start();break;}}}}。
多项式加减法
具体实现方法二:用自己实现的队列类
#ifndef POLYNOMIAL_H_ #define POLYNOMIAL_H_ #include <iostream> using namespace std; #include "Extended_queue.h" //class Polynomial------------------------------------// class Polynomial:private Extended_queue { public: void read(); void print()const; void equals_sum(Polynomial p,Polynomial q); void equals_difference(Polynomial p,Polynomial q); }; #endif
#ifndef POLYNOMIAL_H_ #define POLYNOMIAL_H_ #include <iostream> #include <queue> using namespace std; struct Node { float coef;//系数 int exp;//指数 };
Polynomial.h
//class Polynomial------------------------------------// class Polynomial:private queue<Node> { public: void read(); void print()const; //多项式p+q void equals_sum(Polynomial p,Polynomial q); //多项式p-q void equals_difference(Polynomial p,Polynomial q); }; #endif
多项式相加数据结构
多项式相加数据结构1. 引言在数学中,多项式是一种重要的代数表达式,由若干项的和组成。
每一项包含一个系数和一个指数,并且可以是变量的多项式。
在计算机科学中,我们需要设计一种有效的数据结构来表示和计算多项式的相加运算。
本文将介绍一种用于多项式相加的数据结构,通过分析其设计原理和实现方法,展示了该数据结构的优势。
2. 问题描述多项式相加是指将两个或多个多项式相加得到一个新的多项式。
每个多项式由一系列项组成,每项包含一个系数和一个指数。
例如,多项式 P = 2x^2 + 3x + 1 和多项式 Q = 4x^3 + 2x^2 + 5 可以相加得到多项式 R = 4x^3 + 4x^2 + 3x + 6。
我们需要一个数据结构来高效地表示和计算多项式相加的运算结果。
3. 设计思路为了实现多项式相加的功能,我们可以设计一个多项式类,其中每个多项式都由一组项组成,每个项包含一个系数和一个指数。
以下是该数据结构的设计思路:3.1 多项式类多项式类由一组项组成,我们可以使用数组或链表来存储这些项。
每个项包含一个系数和一个指数,我们可以使用一个结构体或类来表示每个项。
多项式类可以包含以下方法:•addTerm(coefficient, exponent): 向多项式中添加一个新的项,参数为系数和指数。
•removeTerm(exponent): 从多项式中移除指定指数的项。
•getTerm(exponent): 获取多项式中指定指数的项。
•getDegree(): 获取多项式的最高次数。
•add(other): 将另一个多项式加到当前多项式中。
•multiply(other): 将另一个多项式乘以当前多项式。
3.2 项类项类由一个系数和一个指数组成。
我们可以使用一个结构体或类来表示每个项,具体实现可以根据需要进行选择。
4. 数据结构实现基于上述设计思路,我们可以实现多项式相加的数据结构。
以下是该数据结构的详细实现步骤:4.1 多项式类的实现1.使用一个数组或链表来存储多项式的项。
一元多项式的加减求导运算算法数据结构算法
polylink order_list(polylink h); O(n²)
polylink simply_list(polylink h); O(n²)
polylink add(polylink a,polylink b); O(n²)
polylink opposite(polylink b);// O(n)
如下为运行结果。1)菜单
2)加法
3)减法
4)导数
六、源程序
#include<iostream>
using namespace std;
typedef struct pnode
{
double coef;/*系数域*/
int exp;/*指数域*/
struct pnode *next;/*指针域,指向下一个系数不为0的子项*/
cout<<"-X^"<<expo1;
else
cout<<coef1<<"X^"<<expo1;
}
}
else
{
if(expo1==1)
{
if(coef1==1)
cout<<"+X";
else if(coef1==-1)
cout<<"-X";
else if(coef1>0)
cout<<"+"<<coef1<<"X";
p=h->next ;
if(!p)
{
cout<<"多项式"<<o<<" : 0 "<<endl;
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
case 3:
{
printf("---------------------------帮助------------------------------\n");
printf("
\n");
printf(" 1.输入时只输入多项式的系数与指数
\n");
printf(" 2.输入多项式形式:系数 1 指数 1 系数 2 指数 2 …… ,以 0 0 结束\n");
数据结构多项式的加减(方法 {float coef; int expn; struct node * next; }PLOY;
01).txt
void insert(PLOY *head,PLOY *inpt) //查找位置插入新链节程序 { PLOY *pre,*now; int signal=0; pre=head; if(pre->next==NULL) {pre->next=inpt;} else {now=pre->next; while(signal==0) { if(inpt->expn<now->expn) { if(now->next==NULL) { now->next=inpt; signal=1; } else { pre=now; now=pre->next; } } else if(inpt->expn>now->expn) { inpt->next=now; pre->next=inpt; signal=1; } else { now->coef=now->coef+inpt->coef; signal=1; free(inpt); if(now->coef==0) { pre->next=now->next; free(now);
}}}}}
PLOY *creat(char ch) //输入多项式 { PLOY *head,*inpt; float x; int y; head=(PLOY *)malloc(sizeof(PLOY)); //创建链表头 head->next=NULL; scanf("%f %d",&x,&y); while(x!=0) { inpt=(PLOY *)malloc(sizeof(PLOY)); //创建新链节 inpt->coef=x; inpt->expn=y; inpt->next=NULL; insert(head,inpt); //查找位置并且插入新链节 scanf("%f %d",&x,&y); } return head; }
else printing=printing->next; } printf("\n"); }
void start() //用户选择界面
{
printf(" ************************************\n");
printf("
两个一元多项式的加减运算
\n");
printf(" ************************************\n");
void print(PLOY *fun) //输出多项式 { PLOY *printing; int flag=0; printing=fun->next; if(fun->next==NULL) { printf("0\n"); return; } while(flag==0) { if(printing->coef>0&&fun->next!=printing) printf("+"); if(printing->coef==1); else if(printing->coef==-1) printf("-"); else printf("%f",printing->coef); if(printing->expn!=0) printf("x^%d",printing->expn); else if((printing->coef==1)||(printing->coef==-1)) printf("1"); if(printing->next==NULL) flag=1;
printf(" 请输入第二个多项式 g(x):");
g=creat('g'); printf(" 第二个多项式为:g(x)="); print(g); printf(" 结果为:F(x)=f(x)+g(x)="); f=add(f,g); print(f); printf("\n\n"); printf(" 继续请选择相应操作,退出请按 0. "); break; }
case 2: { printf(" 你选择的操作是多项式相减:\n"); printf(" 请输入第一个多项式 f(x):"); f=creat('f'); printf(" 第一个多项式为:f(x)="); print(f); printf(" 请输入第二个多项式 g(x):"); g=creat('g'); printf(" 第二个多项式为:g(x)="); print(g); printf(" 结果为:F(x)=f(x)-g(x)="); f=sub(f,g); print(f); printf("\n\n"); printf(" 继续请选择相应操作,退出请按 0. "); break; }
printf("
\n");
printf(" 注:输入多项式格式为:系数 1 指数 1 系数 2 指数 2 …… ,并以 0 0 结束:\n");
printf("
\n");
printf(" 请选择操作: ");
}
void main()
{
PLOY *f,*g;
int sign=-1;
start();
while(sign!=0)
}
default: {
printf("看完帮助信息后,请重新选择操作:\n"); break; } } } }
不去庆父,鲁难未已。雄关漫道真如铁,而今迈步从头越。
PLOY *add(PLOY *head,PLOY *pre) //多项式相加 { PLOY *inpt; int flag=0; while(flag==0) { if(pre->next==NULL) flag=1; //跳出循环 else { pre=pre->next; inpt=(PLOY *)malloc(sizeof(PLOY)); inpt->coef=pre->coef; inpt->expn=pre->expn; inpt->next=NULL; insert(head,inpt); // 把当前“g(x)”的链节插入到“y(x)”中 } } return head; }
printf(" 3.例如输入 \"1 1 2 2 0 0\" 表示 \"1*X^1+2*X^2\"
\n");
printf("
\n");
printf("---------------------------帮助------------------------------\n");
printf("\n\n");
{
scanf("%d",&sign);
switch(sign)
{
case 0:
break;
case 1:Βιβλιοθήκη {printf(" 你选择的操作是多项式相加:\n");
printf(" 请输入第一个多项式 f(x):");
f=creat('f');
printf(" 第一个多项式为:f(x)=");
print(f);
PLOY *sub(PLOY *head,PLOY *pre) //多项式相减
{ PLOY *inpt; int flag=0; while(flag==0) { if(pre->next==NULL) flag=1; else { pre=pre->next; inpt=(PLOY *)malloc(sizeof(PLOY)); inpt->coef=0-pre->coef; inpt->expn=pre->expn; inpt->next=NULL; insert(head,inpt); } } return head; }
printf(" *
*\n");
printf(" *
1.两个一元多项式相加
*\n");
printf(" *
2.两个一元多项式相减
*\n");
printf(" *
3.帮助
*\n");
printf(" *
0.退出系统
*\n");
printf(" *
*\n");