实验报告2-多项式加法的链表设计与实现

合集下载

链表及其多项式相加

链表及其多项式相加

链表及其多项式相加一、实验目的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);}二、实验原理顺序存储的线性表有一些弱点,其一,插入与删除元素需要大量移动元素;其二,预先分配存储空间时必须按最大的空间来分配。

多项式加法实验报告

多项式加法实验报告

题目:多项式加法多项式加法一、课题概述线性表是一种最简单、最基本,也是最常用的数据结构,其用途十分广泛,例如,用带表头结点的单链表求解一元整系数多项式加法和乘法运算。

现给两个一元整系数多项式,请求解两者之和。

输入两组数据,每一组代表一个一元整系数多项式,有多行组成,其中每一行给出多项式每一项的系数和指数,这些行按指数递减次序排序,每一组结束行为0 -1。

输出三组数据,前两组为一元整系数多项式,最后一组为两个多项式的和。

一元整系数多项式输出形式如下:(1)多项式项4x输出为4X(2)多项式项4x2输出为4X^2(3)第一项系数为正数时,加号不要输出(4)除常系数项外,项系数为1不显式输出,-1输出为-例如,4x3- x2+x-1正确输出形式为4X^3-X^2+X-1,错误输出形式为+4X^3-1X^2+1X-1二、设计与实现1、类的层次关系及核心算法分析:项节点类Trem中定义了三个私有变量,系数coef、指数exp和指向下一个项节点的指针域link。

多项式类Polynominal被声明成项节点类Trem类的友元类。

公有函数InsertAfter构造一个新的项节点,其系数为c指数为e,并将新节点插入在调用该函数的项节点及后继节点之间。

多项式类Polynominal中包含了3个公有成员函数:AddTerms,Output和PolyAdd。

AddTerms函数通过输入流in,输入多项式的各项构造一个多项式的单循环链表;Output函数将多项式按降幂方式送输出流;PolyAdd函数实现将多项式r加到指针this指示的多项式上。

AddTerms函数从输入流in按降幂输入各项(c,e)来构造多项式的单循环链表,当输入(0,-1)是构造过程结束。

Output函数遍历单循环链表将多项式按降幂方式送输出流,它调用项类Trem 上重载的“<<”操作符实现按项输出。

多项式加法,设有多项式p(x)和q(x),分别用单循环链表表示。

两个多项式相加实验报告

两个多项式相加实验报告

两个多项式相加实验报告主要实验内容:根据所学的数据结构中线性结构(线性表)的逻辑特性和物理特性及相关算法,应用于求解一个具体的实际问题----------两个多项式相加一、运行环境:visual C++二、需求分析(1)掌握线性结构的逻辑特性和物理特性(2)掌握线性结构的各种相关算法(3)掌握将算法转换成程序的方法和步骤(4)掌握采用线性结构解决实际问题。

三、概要设计1、抽象数据类型一元多项式的定义如下:ADT Polynomial { 数据对象:D={ a i | a i∈TermSet, i=1,2,...,m, m≥0TermSet 中的每个元素包含一个表示系数的实数和表示指数的整数 }数据关系:R1={ <a i-1 ,a i >|a i-1 ,a i∈D, i=2,...,n,且a i-1中的指数值<a i中的指数值}基本操作:CreatPolyn ( &P, m )操作结果:输入 m 项的系数和指数,建立一元多项式 P。

DestroyPolyn ( &P )初始条件:一元多项式 P 已存在。

操作结果:销毁一元多项式 P。

PrintPolyn ( &P )初始条件:一元多项式 P 已存在。

操作结果:打印输出一元多项式 P。

PolynLength( P )初始条件:一元多项式 P 已存在。

操作结果:返回一元多项式 P 中的项数。

AddPolyn ( &Pa, &Pb )初始条件:一元多项式 Pa 和 Pb 已存在。

操作结果:完成多项式相加运算,即:Pa = Pa+Pb,并销毁一元多项式 Pb。

SubtractPolyn ( &Pa, &Pb )… …} ADT Polynomial2、一元多项式的实现:typedef OrderedLinkList polynomial;// 用带表头结点的有序链表表示多项式结点的数据元素类型定义为:typedef struct { // 项的表示float coef; // 系数int expn; // 指数 term, ElemType;四、详细设计线性表的应用--多项式相加问题多项式的相加操作是线性表处理的典型例子。

多项式相加相乘链表实现模板

多项式相加相乘链表实现模板

实验一:两个多项式相加相乘链表实现学生姓名:#班级:@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,分别指向两个链表头结点的下一位。

多项式加法的链表设计与实现

多项式加法的链表设计与实现
r=h; /*r指针始终动态指向链表的当前表尾,以便于做尾插入,其初值指向头结点*/
printf("coef:");
scanf("%d",&c); /*输入系数*/
printf("exp: ");
scanf("%d",&e); /*输入指针*/
while(c!=0) /*输入系数为0时,表示多项式的输入结束*/
//////补充代码......
pre->next=p;
}
else if(p->exp==q->exp) /*若指数相等,则相应的系数相加*/
{
sum=p->coef+q->coef;
if(sum!=0)
{/*将p结点加入到和多项式中,删除结点q*/
p->coef=sum;
pre->next=p;pre=pre->next;p=p->next;
polyb=create(); /*调用建立链表函数,创建多项式B*/
print(polyb);
printf("Sum of the poly is:\n");
polyadd(polya,polyb); /*调用一元多项式相加函数*/
print(polya); /*调用输出函数,打印结果*/
printf("\n");
存放在多项式polya中,并将多项式ployb删除*/
{
node *p,*q,*pre,*temp;
int sum;
p=polya->next;/*令p和q分别指向polya和polyb多项式链表中的第一个结点*/

实验二 链表操作实现

实验二 链表操作实现

实验二链表操作实现实验日期:2017 年 3 月16 日实验目的及要求1. 熟练掌握线性表的基本操作在链式存储上的实现;2. 以线性表的各种操作(建立、插入、删除、遍历等)的实现为重点;3. 掌握线性表的链式存储结构的定义和基本操作的实现;4. 通过本实验加深对C语言的使用(特别是函数的参数调用、指针类型的应用)。

实验内容已知程序文件linklist.cpp已给出学生身高信息链表的类型定义和基本运算函数定义。

(1)链表类型定义typedef struct {int xh; /*学号*/float sg; /*身高*/int sex; /*性别,0为男生,1为女生*/} datatype;typedef struct node{datatype data; /*数据域*/struct node *next; /*指针域*/} LinkNode, *LinkList;(2)带头结点的单链表的基本运算函数原型LinkList initList();/*置一个空表(带头结点)*/void createList_1(LinkList head);/*创建单链表*/void createList_2(LinkList head);/* 创建单链表*/void sort_xh(LinkList head);/*单链表排序*/void reverse(LinkList head);/*对单链表进行结点倒置*/void Error(char *s);/*自定义错误处理函数*/void pntList(LinkList head);/*打印单链表*/void save(LinkList head,char strname[]);/*保存单链表到文件*/任务一创建程序文件linklist.cpp,其代码如下所示,理解LinkList类型和基本运算函数后回答下列问题。

#include <stdio.h>#include <stdlib.h>/*单链表结点类型*/typedef struct {int xh; /*学号*/float sg; /*身高*/int sex; /*性别,0为男生,1为女生*/} datatype;typedef struct node{datatype data; /*数据域*/struct node *next; /*指针域*/} LinkNode, *LinkList;/*带表头的单链表的基本运算函数*/LinkList initList();/*置一个空表(带头结点)*/void createList_1(LinkList head);/*创建单链表*/void createList_2(LinkList head);/*创建单链表*/void sort_xh(LinkList head);/*单链表排序*/void reverse(LinkList head);/*单链表倒置*/void Error(char *s);/*自定义错误处理函数*/void pntList(LinkList head);/*打印单链表*/void save(LinkList head,char strname[]);/*保存单链表到文件*//*置一个空表*/LinkList initList(){ LinkList p;p=(LinkList)malloc(sizeof(LinkNode));p->next=NULL;return p;}/*创建单链表*/void createList_1(LinkList head){ FILE *fp;int xh;float sg;int sex;LinkList p;if((fp=fopen("records.txt","r"))==NULL){ Error("can not open file !");return ;}while(!feof(fp)){ fscanf(fp,"%d%f%d",&xh,&sg,&sex);p=(LinkList)malloc(sizeof(LinkNode));p->data.xh=xh;p->data.sg=sg;p->data.sex=sex;p->next=head->next;head->next=p;}fclose(fp);}/*创建单链表*/void createList_2(LinkList head){ FILE *fp;int xh;float sg;int sex;LinkList p,rear;if((fp=fopen("records.txt","r"))==NULL){ Error("can not open file !");return ;}rear=head;while(!feof(fp)){ fscanf(fp,"%d%f%d",&xh,&sg,&sex);p=(LinkList)malloc(sizeof(LinkNode));p->data.xh=xh;p->data.sg=sg;p->data.sex=sex;p->next=NULL;rear->next=p;rear=p;}fclose(fp);}/*单链表排序*/void sort_xh(LinkList head){LinkList q,p,u;p=head->next;head->next=NULL;/*利用原表头结点建新的空表*/while(p){ q=p; /*q为被插入的结点*/p=p->next;/*用p记录后继结点*//*遍历新链表查找插入位置*/u=head;while(u->next!=NULL)/*查找插入位置*/{ if(u->next->data.xh>q->data.xh)break;u=u->next;}/*插入在u结点的后面*/q->next=u->next;u->next=q;}}/*单链表倒置*/void reverse(LinkList head){ LinkList p, r;p=head->next;head->next=NULL;while(p){ r=p;p=p->next;/*r指向结点头插到链表*/r->next=head->next;head->next=r;}}/*输出单链表*/void pntList(LinkList head){ LinkList p;p=head->next;while(p!=NULL){printf("%2d: %.2f %d\n",p->data.xh,p->data.sg,p->data .sex);p=p->next;}}/*自定义错误处理函数*/void Error(char *s){ printf("\n %s", s);exit(1); /*返回OS,该函数定义在stdlib.h中*/}/*保存单链表到文件*/void save(LinkList head,char strname[]){ FILE *fp;LinkList p;if((fp=fopen(strname,"w"))==NULL){ printf("can not open file !");return ;}p=head->next;while(p!=NULL){ fprintf(fp,"%2d %5.2f %2d\n",p->data.xh,p->data.sg,p->data.sex);p=p->next;}fclose(fp);}请回答下列问题:(1)由单链表结点类型定义可知,该链表结点类型名为 LinkNode ,结点的指针类型为 LinkList ,向系统申请一个学生结点空间并把起始地址存于上述结点指针变量new 中的语句是: p=(LinkList)malloc(sizeof(LinkNode)); 。

数据结构多项式相加实验报告doc

数据结构多项式相加实验报告doc

数据结构多项式相加实验报告篇一:数据结构实验多项式加法数据结构实验报告实验名称:多项式加减法学号:1XX10419姓名:林强实验日期:XX.5.05一、实验目的通过实现多项式的加减法,对链表有更深入的了解二、实验具体内容1、实验题目1:(1)题目设计一个一元稀疏多项式简单的加减法计算器实现要求:一元稀疏多项式简单计算器的基本功能是:(1)输入并建立多项式:A(x)?7?3x?9x8?5x17;B(x)?8x?22x7?9x8(2)输出多项式(3)多项式A和B相加,建立多项式C=A+B,并输出相加的结果多项式C(4)选作:多项式A和B相减,建立多项式C=A-B,并输出相加的结果多项式D(2)分析1:本程序的任务是实现两个多项式的加法其中多项式的系数为浮点型,指数为整数,输出的结果也为系数和指数。

(1)输入的形式和输入值的范围:输入多项式的系数a和未知数X的指数b,当a和b都为零时,输入结束。

输入值的范围:a为实数,b为整数。

(2)输出形式:输出多项式的系数和多项式未知数X 的指数即(a,b)形式。

(3)程序所能达到的功能,实现两个多项式的加法,并输出最后的结果2:整个程序运行期间实行动态创建节点,一边输入数据,一边创建节点当将全部数据输入到单链表中后再调用多项式加法这个函数,并一边实现多项式的相加,一边释放节点,有效防止了在程序反复运行过程中可能出现系统空间不够分配的现象(3)实验代码typedef int Status;#define OVERFLOW -1#define null 0typedef struct Lnode{float coef; //存储项系数int expn;//存储项指数struct Lnode *next;}Lnode,*LinkList;typedef LinkList polynomial;Status InitList_L(LinkList &L) {//初始化头节点L=(LinkList)malloc(sizeof(Lnode));if(!L)return(-1);L->next=null;return 1;}void AddPolyn(polynomial pa, polynomial pb){ //实现两个多项式相加的算法float x;polynomial qa;polynomial qb;polynomial s;polynomial u;qa=pa->next; qb=pb->next; s=pa;while(qa&&qb){if(qa->expnexpn){s=qa;qa=qa->next;}else if(qa->expn==qb->expn){x=qa->coef+qb->coef;if(x!=0){qa->coef=x;s=qa;qa=qa->next;u=qb;qb=qb->next;free(u);}else{s->next=qa->next;free(qa);qa=s->next;u=qb;qb=qb->next;free(u);}}else if(qa->expn>qb->expn){ u=qb->next;s->next=qb;s=qb;qb->next=qa;qb=u;}}if(qb)qa->next=qb;free(pb);}void main(){float a;int b;polynomial L1;polynomial L2; LinkList q;LinkList p;LinkList m;LinkList n;InitList_L(L1);q=L1;InitList_L(L2);p=L2;cout 请输入数据:" for(;;){ cin>>a;cin>>b;if(a==0&&b==0) break;m=new Lnode;m->coef=a;m->expn=b;q->next=m;q=m;q->next=null;}//循环输入第一个多项式的系数与指数for(;;){cin>>a;cin>>b;if(a==0&&b==0)break;n=new Lnode;n->coef=a;n->expn=b;p->next=n;p=n;p->next=null;}//循环输入第二个多项式的系数与指数AddPolyn(L1,L2);//调用多项式相加的算法while((L1->next)!=null){coutnext->coefnext->expn L1=L1->next;}//输出计算结果}三、实验小结通过编写多项加法这个程序,我将自己所学到的创建链表,初始化链表和多项式加法算法都应用了一次,这使我们不仅仅只是理论化的学习书本上的知识,而是将学习到的理论知识应用到实际的操作中来增强我们的实际操作能力,这使我增加了实际操作经验,也使我通过实际操作来认识到自己在程序编写上的不足从而增强了我的实际编写程序的能力。

数据结构实验报告完成多项式的运算

数据结构实验报告完成多项式的运算

简单介绍:本次作业力在学会链表表示线性表的插入、删除、查找等基本操作设计与实现,学习利用链表提供的接口去求解实际问题,同时熟悉链表的的存储方法。

再基于线性链表的基础设计完成多项式的相加运算程序。

一、实验目的和要求完成多项式的相加、相乘运算。

(1)掌握线性表的插入、删除、查找等基本操作设计与实现(2)学习利用线性表提供的接口去求解实际问题(3)熟悉线性表的的存储方法二、实验内容和原理1.实验内容设计一个一元多项式的简单计算程序,其基本功能有:(1)输入并建立多项式;(2)输出多项式;(3)多项式的相加运算。

利用单链表实现。

2.实验原理使用单链表实现一元多项式的存储,并实现两个一元多项式的加法运算。

三、实验环境硬件:(1)学生用微机(2)多媒体教室或远程教学(3)局域网环境软件:(1)Windows XP中文操作系统(2)VC6.0四、算法描述及实验步骤1、描述:加法:输入建立一元多项式,进行简单加法运算,输出结果;通过建立单链表A和B分别存放多项式的a和b的各项系数及指数;并且利用A使得不产生新的节点而在A中存放数据运算结果;该过程通过定义指针变量p和q使它们分别指向两个多项式的第一个节点,之后依次比较它们所指向的项的指数,即一种情况指数相等时系数相加且和不为零,修改当前p所指项的系数(和),同时删除q所指项,若和为零则同时删除p和q各自所指;情况二,p当前项指数大于q当前项,将q所指插入p所指之前作为结果项之一;情况三,p当前项指数小于q当前项,p所指作为多项式和的一项,移动p指向下一项,进行比较,在移动p,q至其中以个链空,把另一个链余下节点插在p所指之后;乘法:定义指针p,q指向所操作节点,通过A链表的每一项与B链表各项相乘,指数相加,系数相乘,将值赋给新节点各自域,构成一新的链表,最后返回头结点。

可这样有一个问题,即新生成的链表,即最终结果混乱,没有对数据进行过滤,相同指数项应在执行加法运算,所以可以这样实现,通过A链表的每一项与B链表各项相乘的新生成节点单独构成一链表,并将第一个链表加入另一新链表,循环此操作将后生成的链表加之先前的链表,即可实现排序问题。

实验链表实验报告

实验链表实验报告

实验链表实验报告一、实验目的本次实验的主要目的是深入理解链表这种数据结构的概念、特点和操作方法,并通过实际编程实现来提高对链表的应用能力。

二、实验环境本次实验使用的编程语言为C++,开发工具为Visual Studio 2019。

三、实验原理链表是一种常见的数据结构,它由一系列节点组成,每个节点包含数据和指向下一个节点的指针。

与数组不同,链表的内存分配是动态的,并且可以方便地进行插入和删除操作,而不需要移动大量的元素。

链表分为单向链表、双向链表和循环链表等多种类型。

在本次实验中,我们主要实现单向链表。

单向链表的节点结构通常包含数据域和指针域。

数据域用于存储节点的数据,指针域用于指向下一个节点。

通过遍历链表的指针,可以访问链表中的每个节点。

四、实验内容1、链表节点的定义```cppstruct ListNode {int data;ListNode next;ListNode(int x) : data(x), next(NULL) {}};```2、链表的创建```cppListNode createList(){ListNode head = NULL;ListNode tail = NULL;int num;cout <<"请输入链表中的数字(输入-1 结束):";cin >> num;while (num!=-1) {ListNode newNode = new ListNode(num);if (head == NULL) {head = newNode;tail = newNode;} else {tail>next = newNode;tail = newNode;}cin >> num;}return head;}```3、链表的遍历```cppvoid traverseList(ListNode head) {ListNode curr = head;while (curr!= NULL) {cout << curr>data <<"";curr = curr>next;}cout << endl;}```4、链表的插入```cppvoid insertNode(ListNode& head, int position, int value) {ListNode newNode = new ListNode(value);if (position == 0) {newNode>next = head;head = newNode;return;}ListNode curr = head;int count = 0;while (curr!= NULL && count < position 1) {curr = curr>next;count++;}if (curr == NULL) {cout <<"插入位置超出链表长度" << endl; return;}newNode>next = curr>next;curr>next = newNode;}```5、链表的删除```cppvoid deleteNode(ListNode& head, int position) {if (head == NULL) {cout <<"链表为空,无法删除" << endl; return;}if (position == 0) {ListNode temp = head;head = head>next;delete temp;return;}ListNode curr = head;ListNode prev = NULL;int count = 0;while (curr!= NULL && count < position) {prev = curr;curr = curr>next;count++;}if (curr == NULL) {cout <<"删除位置超出链表长度" << endl; return;}prev>next = curr>next;delete curr;}```五、实验结果通过对上述链表操作函数的调用,我们成功地创建、遍历、插入和删除了链表中的节点。

用链表实现多项式及其操作

用链表实现多项式及其操作

通信韩若冰222010315220106实验项目:线性表及其应用实验内容:用单链表存储多项式;实现多项式的输出显示、相加、相乘、求导、求值运算。

算法设计与程序实现:由于存储多项式需要存储系数和指数,且其指数变化范围可能很大如果用顺序表就会浪费很大的空间,用单链表存取指针域,和数据域(系数和指数)就会节省很大空间。

要想实现多项式的显示,相加,相乘,求导,求值运算,首先得创建函数以实现上述功能,然后再在主函数中调用上述函数以得到运行结果。

算法描述:(实验内容的核心算法)创建链表:首先创建空表,然后将每个结点用尾插法依次插入。

每一项多项式的组成部分(系数和指数)输出程序:此程序需要遍历整个链表,通过判断p->next的系数的正负来确定输出“+”还是“-”很容易出现错误。

多项式相加:这个程序需要按照幂的排列顺序依次遍历寻找一个多项式与另一个多项式指数相同的,将其系数相加比较简单。

该程序写成升幂比较,其中可能出现如A多项式的前几项都比B中的指数小,那么以一个pre为头结点的链表先将其穿起来,找到相等的进行运算再串起来,最后可能会有链表剩余的指数更大的项不能和另一个相加再将剩余的串起来。

(第一项要先串起来,因为第一项之前没有多项式不用判断+ —号)多项式相乘:此程序需要循环语句,即将一个多项式的每一项分别和另一个多项式相乘,依次调用多项式相加的程序叠加起来。

多项式求导:需要依次将多项式的每一项的系数和指数相乘,指数减1,形成一个链表多项式求值:需要有x的幂次的表示,C语言不能识别“^”,所以需要用一个循环实现x^exp相乘的结果,容易出错核心程序:运行结果:实验总结:本次试验做了很长时间,也出现了很多错误。

总起来说有以下几种错误:1.输入错误:中英文状态下输入错误,其中还有运行时在中文状态下输入数据回车后就不能输了,应在英文状态下输入data , data↙2.多项式表示需要判断下一个多项式系数是正还是负然后分别写+, —(fabs),但是第一项必须先输出,因为第一项不需要写+ —号3.多项式相加,要注意写的程序是怎么比较的,升幂的话则p->exp < q->exp 则把p结点指数小的先穿起来。

数据结构实验-多项式的相加减

数据结构实验-多项式的相加减

集美大学数据结构课程实验报告课程名称:数据结构班级:网络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.刚开始实现多项式的相加减运算时,申请一个新的空间来存放结果,结果指针乱了,后来改成了现在的程序。

(完整word版)链表线性结构(多项式的加减乘除)

(完整word版)链表线性结构(多项式的加减乘除)

哈尔滨工业大学计算机科学与技术学院实验报告课程名称:数据结构与算法课程类型:必修实验项目:线性结构及其应用实验题目:多项式的加减乘除和特定值带入实验日期: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;}/*乘法,先用第一个链表的第一个数据乘以第二个链表里的所有值,储存在新的链表中,之后遍历一中所有的值,最后把这些多项式加在一起。

链表实现多项式的加和乘

链表实现多项式的加和乘
if (lnode_tmp->exp!=0)
printf("x");
if (lnode_tmp->exp!=1 && lnode_tmp->exp!=0)
printf("^%d",lnode_tmp->exp);
if(lnode_tmp->next->coef>0)
printf("+");
}
else
scanf("%d",&l2_length) ;
CreatPolyn(l2,l2_length);
//创建相加链表的头节点,把链表l1,l2加入l_plus
Linklist l_plus=Create_lnode();
AddPolyn(l_plus,l1);
AddPolyn(l_plus,l2);
//创建相乘链表的头节点,l1,l2相乘生成链表l_mul
void MulPolyn(Linklist l_mul,Linklist l1,Linklist l2)
{
Linklist tmp_p = Create_lnode();
Linklist tmp_q = Create_lnode();
int zhishu,xishu;
tmp_p=l1->next;
InsertLnode(l_mul,p);
tmp_q = tmp_q->next;
}
tmp_p = tmp_p->next;
}
}
//PrintPolyn:打印链表l
Status PrintPolyn(Linklist l)
{

数据结构多项式相加实验报告

数据结构多项式相加实验报告

试验一多项式相加一. 实验内容:多项式相加二.实验目的和要求:利用双向链表实现通讯录的建立、删除、检索和列表,并可保存至文件,可重新装入。

用链式存储结构实现一元多项式的相加运算。

三.算法思想描述:1. 以单链表为存储结构插入多项式: 多项式输入:多项式按幂从高到低,以“系数,幂”的格式输入,并以“0,0”结束。

printf("Please input coef:");scanf("%d",&i);printf("Please input exp: ");scanf("%d",&j);while(i!=0){q=(pnode)malloc(sizeof(struct node));q->coef=i;q->exp=j;p->link=q;p=q;printf("Please input coef:");scanf("%d",&i);printf("Please input exp: ");scanf("%d",&j);}p->link=NULL;2. 多项式相加单链表合并:由两个多项式对应的单链表头节点开始,依次扫描各节点。

(1)若两表的节点均非空:比较二者的幂,按幂大者先入表。

如果幂相等,则系数相加再入表。

具体由以下代码实现:while(p!=NULL && q!=NULL){if(p->exp==q->exp){x=p->coef+q->coef;if(x!=0){s=(pnode)malloc(sizeof(struct node));s->coef=x;s->exp=p->exp;r->link=s;r=s;}p=p->link;q=q->link;}else if(p->exp<q->exp){s=(pnode)malloc(sizeof(struct node));s->coef=q->coef;s->exp=q->exp;r->link=s;r=s;q=q->link;}else{s=(pnode)malloc(sizeof(struct node));s->coef=p->coef;s->exp=p->exp;r->link=s;r=s;p=p->link;}(2). 若有一链表已空,则将非空链表插入新表:while(p!=NULL){s=(pnode)malloc(sizeof(struct node));s->coef=p->coef;s->exp=p->exp;r->link=s;r=s;p=p->link;}while(q!=NULL){s=(pnode)malloc(sizeof(struct node));s->coef=q->coef;s->exp=q->exp;r->link=s;r=s;q=q->link;}3. 输出合并后的链表:while(head->link!=NULL){head=head->link;printf(" %d*x^%d",head->coef,head->exp);}4. 主函数调用,完成多项式相加。

链表-实验报告

链表-实验报告

实验2 链表实验概述:一、实验目的本次实习的主要目的是为了使学生熟练掌握链表的基本操作以及在链式存储结构上的实现,包括创建、插入、删除、查找、以及合并等操作。

二、实验要求掌握链表存储方式,熟悉链式存储结构。

三、实验步骤用链表结构实现对多项式初始化、创建、插入、删除等运算。

步骤:输入第一个多项式:7x+2x3输入第二个多项式:8x+9x5输出第一个多项式输出第二个多项式输出两个多项式相加的结果:15x+2x3+9x5实验结果如图:四、实验环境(使用的软件和设备)(1)实习器材:多媒体计算机。

(2)实习地点:校内多媒体机房。

(3)实习软件: Win-TC实验内容:【实验过程】(实验步骤、记录、数据、分析)实验过程(提示)输入第一个多项式:7x+2x3输入第二个多项式:8x+9x5输出第一个多项式输出第二个多项式输出两个多项式相加的结果:15x+2x3+9x5【结果实验记录】(图形或图像)1.说明掌握情况#include<stdio.h>#include<stdlib.h>typedef struct{int sat1,sat2,sat3,sat4;}ElemType;typedef struct LNode{ElemType data;struct LNode *next;}LNode,*LinkList;LinkList InitList(){ LinkList L;L=(LinkList)malloc(sizeof(LNode)); L->next=NULL;return(L);}void InsLNode(LinkList L,ElemType x){ LinkList s,p;s=(LinkList)malloc(sizeof(LNode));s->data=x;p=L;while(p->next)p=p->next;s->next=NULL;p->next=s;}void AddPolyn(LinkList La,LinkList Lb){int sum;int a,b;LinkList pa,pb;pa=La->next;pb=Lb->next;a=pa->data.sat1;b=pb->data.sat1;sum=a+b;printf(" %dx%d exp",sum,pa->data.sat2);printf("+");printf(" %dx%d exp+",pa->data.sat3,pa->data.sat4); printf(" %dx%d exp\n",pb->data.sat3,pb->data.sat4);}void Print(LinkList L){ LinkList p;p=L->next;printf(" %dx%d exp",p->data.sat1,p->data.sat2); printf("+");printf(" %dx%d exp",p->data.sat3,p->data.sat4);}main() {LinkList La,Lb;ElemType c,b;int a,i;La=InitList();Lb= InitList();printf("Please input polynomial La:\n");scanf("%d %d",&c.sat1,&c.sat2);scanf("%d %d",&c.sat3,&c.sat4);InsLNode(La,c);printf("Please input polynomial Lb:\n");scanf("%d %d",&b.sat1,&b.sat2);scanf("%d %d",&b.sat3,&b.sat4);InsLNode(Lb,b);printf("polynomial La:");printf("\n");Print(La);printf("\n");printf("polynomial Lb:");printf("\n");Print(Lb);printf("\n");printf("La+Lb:");printf("\n");AddPolyn(La,Lb);printf("\n");getch();}2.裁图说明实验结果【心得体会、问题和建议】成绩:指导教师签名批阅日期:。

数据结构实验,用链表实现多项式加减乘

数据结构实验,用链表实现多项式加减乘

#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; //临时指针。

数据结构(Datastructure):用链表实现多项式的表示和运算(C语言)

数据结构(Datastructure):用链表实现多项式的表示和运算(C语言)

数据结构(Datastructure):⽤链表实现多项式的表⽰和运算(C语⾔)0.简介(在以下环境下运⾏通过):运⾏环境:Linux(ubuntu12.10); 编译器:gcc; 语⾔:C语⾔; 作者:Catcher24。

1.问题描述: 使⽤链表实现多项式的表⽰和运算(加法、减法、乘法)。

2.数据结构描述与设计: 2.1 使⽤链表的原因: 有两个多项式: P1 = 6x^4+4x^2-x; P2 = -7x^5+x^2; 如果要对两个多项式进⾏操作(多项式相加、除法等等......),可以采⽤数组的存储⽅式。

设多项式P(n) = a1x n+a2x n-1+...a n;如果采⽤数组A[n]来存储P(n)的系数,当P(n)中有的a i为0时,数组储存在空间上会带来很⼤的浪费。

⽽采⽤链表存储,每个节点存储系数和指数信息。

⽤链表来表⽰多项式,节点信息如下图:图:链表节点信息 2.2 多项式的链表实现: 下⾯给出polynomial.h⽂件,⾥⾯包含了节点的定义和函数定义;1 #include <stdlib.h>2 #include <stdio.h>34 #ifndef _List_H5 typedef int bool;6 typedef int exp_type;7 typedef float coe_type;8#define true 19#define false 010 typedef struct node {11 coe_type coefficient;12 exp_type exponent;13struct node* next;14 }node;15 typedef struct node* polynomial;1617 node* init(node* l);18 node* make_empty(node* l);19bool is_empty(node* l);20bool is_last(node* p,node* l);21 node* find(coe_type x,node* l);22 node* find_previous(coe_type x,node *l);23void delete_node(coe_type x, node* l);24void insert(coe_type x,exp_type y,node* l);25void delete_list(node* l);26 node* header(node* l);27 node* first(node* l);28void print_list(node* l);2930 polynomial create(polynomial poly,coe_type coe[],exp_type exp[],int n);32 polynomial sub_poly(const polynomial poly1,const polynomial poly2,polynomial polyprod);33 polynomial mult_poly(const polynomial poly1,const polynomial poly2,polynomial polyprod);34void print_poly(const polynomial poly);3536#endif 其中通过create()函数创建⼀个新的多项式,⽤⼀个float类型的数组来表⽰多项式的系数,⽤int型的数组来表⽰多项式的指数。

多项式的链表表示及运算实验报告

多项式的链表表示及运算实验报告

多项式的链表表示及运算实验报告
一、实验目的
本次实验旨在了解多项式的链表表示及运算,学习应用链表实现多项式的加减乘除运算。

二、实验原理
多项式是数学中一种常见的运算方式,它由若干个单项式(即常数、未知数以及未知数不同次幂的积)求和组成。

多项式通常可以用数组或链表来表示。

本实验采用链表表示多项式。

链表表示多项式可以用一个链表来存储多项式中的每一项,链表节点存储着每一项的系数和指数。

链表的头节点指向第一项。

在链表表示多项式时,我们可以定义一个结构体来表示节点,包含两个成员变量:系数和指数。

当我们对多项式进行加减乘除运算时,首先需要将多项式转换成链表形式,然后按照运算规则进行运算,最后将运算结果转换为多项式形式。

三、实验步骤
1、定义多项式节点结构体,包含系数和指数两个成员变量;
2、编写函数从命令行读取用户输入的多项式,按照指数降序的方式将多项式转换成链表形式;
3、编写函数完成多项式相加、相减、相乘、相除等运算,每种运算均需要将两个多项式转换成链表形式后进行;
4、编写函数将链表形式的多项式转换成多项式字符串;
5、在主函数中调用上述函数,进行多项式的读取、运算、转换并输出结果。

四、实验总结
本次实验学习了多项式的链表表示及运算,掌握了链表的基本操作,了解了多项式的四则运算的实现。

在实验中,我们成功地用链表实现了多项式的加减乘除运算,实现了从命令行读取多项式,并将其转换为链表,最后将链表转换为多项式字符串输出。

通过本次实验,我更加深刻地理解了链表及其应用,学会了运用链表实现算法,提高了编码能力。

实验二 多项式加减法

实验二 多项式加减法

数据结构实验报告实验二多项式加减法姓名:xxx学号:xxxx专业:信息安全实验时间:第八周周日实验二多项式加减法一、实验目的通过实现多项式的加减法,对链表有更深入的了解二、实验内容问题描述:设计一个一元稀疏多项式简单的加减法计算器实现要求:一元稀疏多项式简单计算器的基本功能是:(1)输入并建立多项式:8517xx=;++A+9x37(x)798xB-x+=)x822(x(2)输出多项式(3)多项式A和B相加,建立多项式C=A+B,并输出相加的结果多项式C(4)选作:多项式A和B相减,建立多项式C=A-B,并输出相加的结果多项式D实验完整代码:头文件部分:#ifndef DOUXIANGSHI_H#define DOUXIANGSHI_Htypedef struct pino NODE;typedef NODE * LIST;struct pino{ double xishu;int zhishu;NODE *next;};LIST creatlist1();void creatlist(LIST head);void print(LIST head);void add_poly(LIST pa,LIST pb);#endifC文件部分,算法的实现:#include"douxiangs.h"#include<stdlib.h>#include<stdio.h>#include<string.h>LIST creatlist1()//创建空链表{ LIST head=(NODE*)malloc(sizeof(NODE)); if(head==NULL)exit(0);memset(head,0,sizeof(head));}void creatlist(LIST head)//输入多项式{ NODE*read=head;NODE*p=NULL;double a=0;int b=0;int c;scanf("%d",&a);printf("^");scanf("%d",&b);while(a!=-1&b!=-1){ p=(NODE*)malloc(sizeof(NODE));p->xishu=a;p->zhishu=b;p->next=NULL;read->next=p;read=p;printf("+");scanf("%d",&a);printf("^");scanf("%d",&b);}printf("多项式输入结束啦!");}void print(LIST head)//打印多项式{ NODE*p=head->next;while(p!=NULL){ printf("%d",p->xishu);printf("^");printf("%d",p->zhishu);printf("+");p=p->next;}}void add_poly(LIST pa,LIST pb)//多项式相加{NODE *p=pa->next;//链表,将来的结果也放在此NODE *q=pb->next;//链表NODE *pre=pa;NODE *u;//临时用double x;while (p!=NULL && q!=NULL)//当两个链表都不为空{if (p->zhishu<q->zhishu)//比较链表跟链表当前节点的指数大小,链表也是存放结果的地方{pre=p;p=p->next;//p指向要比较的下一个结点。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

实验名称多项式加法的链表设计与实现实验方案实验成绩实验日期实验室信息系统设计与仿真室I 实验操作
实验台号班级姓名实验结果
一、实验目的
1、掌握多项式链表结构的设计;
2、掌握多项式结点的创建、插入、释放等操作;
3、编程实现多项式链表的文件读入、加法求和以及输出显示功能。

二、实验任务
设计一元多项式的加法程序,其基本功能有
①从文件中读取一元多项式;格式: 5X3+4X2+3X+2
②实现两个多项式相加;
③输出结果多项式;
运用单链表存储多项式,结果链表使用原链表空间。

三、实验设计方案
1.多项式结构体设计
思路:应包含系数项、指数项和后继指针项。

struct ploy{
int ceof; //系数
int exp; //指数
struct ploy *next;
};
typedef struct ploy Ploy;
2.自定义函数设计
(1)从文件读取多项式
思路:按照文件in.txt格式读取多项式,注意判断各种符号情况:符号位、系数、x、指数。

Ploy *input()
{
int ceof=1,exp=0,sign=1; //赋初始值: 系数为1, 指数为0, 符号为1 (正)
int c2e=0; //标记变量: 表示准备读入系数还是指数(0表示系数, 1表示指数)
char str[20],*p=str; //str用于存放读入的多项式
Ploy *pa=newnode(0,0); //创建链表头结点.
Ploy *t=pa; //队尾指针初始值为头指针
scanf("%s",str); //读入多项式到str
while(*p!='\0'){ //将多项式系数和指数写入到链表结点中
if(*p=='+' || *p=='-') //如果是符号+或-
{
if (c2e) //如果c2e为1,表示已经读入指数,可以将系数和指数插入链表结点t=insert(t,ceof,exp); //尾插法
sign= (*p=='+' ? 1 : -1); //取符号位
exp=0; //符号位读完后,接下来要读入系数和指数,赋指数系数默认值
ceof=1;
c2e=0; //表示接下来要读入系数
}
else if(*p>='0' && *p<='9' && c2e==0) //表示读入的系数
ceof=(*p-'0')*sign;
else if (*p=='X' || *p=='x'){ //表示读入的是x
c2e=1; //表示接下来要读入指数
exp=1; //指数默认值赋为1
}
else if(*p>='0' && *p<='9' && c2e==1) //表示读入的是指数
exp=*p-'0';
p++; //转移到下一个字符
}
t=insert(t,ceof,exp); //插入最后一项(系数和指数)
return pa;
}
(2)多项式加法
思路:分三种情况把多项式1和多项式2中的各项链接到和多项式中。

Ploy *add(Ploy *ha, Ploy *hb)
{
Ploy *pa,*pb,*q; //pa和pb指向多项式1和2的当前项, q表示和多项式的当前项.
pa=ha->next; //初始化pa, pb和q
pb=hb->next;
q=ha;
free(hb); //用多项式1的头结点作为和多项式的头结点,故释放多项式2的头结点hb.
while(pa!=NULL && pb!=NULL){ // 比较多项式1和多项式2两个当前项的指数if(pa->exp > pb->exp){ //多项式1的指数大
q->next=pa; // 链接到和多项式指针q的后面
q=pa; // 修改q
pa=pa->next; // 多项式1当前项后移
}
else if (pa->exp < pb->exp){ //多项式2的指数大
q->next=pb;
q=pb;
pb=pb->next;
}
else{ //多项式1和2的指数相等
int x=pa->ceof+pb->ceof; // 计算两项的系数之和
Ploy *r; //用于指示准备释放的结点
if(x) { //如果系数之和不为0
pa->ceof=x; // 修改多项式1当前项的系数项
q->next=pa; //将多项式1的当前项接到和多项式q后面
q=pa; // 修改q
pa=pa->next; //pa指针后移
r=pb; //r存放pb当前项, 准备释放该结点空间
pb=pb->next; //pb后移
free(r); //释放r
}
else{ //如果系数为0
r=pb; //准备释放pb当前项
pb=pb->next;
free(r);
r=pa; //准备释放pb当前项
pa=pa->next;
free(r);
}
}
}
if(pa==NULL && pb==NULL) //多项式1和2均为空, q的指针域赋结束标记NULL q->next=NULL;
else if(pa!=NULL) //多项式1不空, 剩余项接到q后面
q->next=pa;
else //多项式2不空, 剩余项接到q后面
q->next=pb;
return ha;
}
(3)输出和多项式
思路:注意第1项没有正符号位, 以后各项最好按符号,系数,X和指数分开显示.
void output(Ploy *p)
{
p=p->next;
if(p!=NULL) //显示第1项
printf("%dX%d",p->ceof,p->exp);
p=p->next;
while(p!=NULL){
if(p->ceof>0) //符号位
printf("+");
printf("%d",p->ceof); //系数
if(p->exp>0) //X
printf("X");
if(p->exp>1) //指数
printf("%d",p->exp);
p=p->next;
}
printf("\n");
}
(4)给出创建结点函数newnode()和插入结点函数insert()的函数原型, 请编程完成. Ploy *newnode(int c, int e);
Ploy *insert(Ploy *p, int c, int e);
3.主函数设计
思路:主函数实现实验任务的基本流程。

void main()
{
Ploy *pa, *pb;
freopen("in.txt","r",stdin);
pa=input(); //读入多项式1
pb=input(); //读入多项式2
pa=add(pa,pb); //两个多项式相加
output(pa); //输出和多项式
}
四、测试
1、测试数据
下面测试数据存放在in.txt文件中:
5X3+4X2+3X+2
2X2+X+1
2、测试结果
测试结果显示如下:
5X3+6X2+4X+3
五、总结与讨论
1、问题与错误
2、经验与收获
3、改进与设想
六、源代码。

相关文档
最新文档