当前位置：文档库 › 一元多项式的相加(数据结构)

一元多项式的相加(数据结构)

实验报告

课程名称：数据结构实验名称：一元多项式的相加

班级： 1333 学生姓名：蔡景旺学号： 37

一、需求分析

1.用户可以根据自己的需求分别输入两个一元多项式（输入必须按指数递增顺序），并且

能够实现输入的一元多项式的显示。

2.能够完成两个一元多项式的相加功能并显示结果。

3.程序执行的命令包括：

（1）构造链表A （2）构造链表B （3）两个链表的相加（4）求链表的长度（5）打印（显示）已有的链表

二、概要设计

⒈为实现上述算法，需要线性表的抽象数据类型：

ADT Polynomial {

数据对象：D={a i:|a i∈TermSet,i=1…n,n≥0

TermSet 中的每个元素包含一个表示系数的实数和表示指数的整数} 数据关系：R1={|a i-1,a i∈D,且a i-1中的指数值< a i中的指数值

i=2,…n≥0}

基本操作:

CreatPolyn(&p,m)

操作结果：输入m项的系数和指数，建立一个一元多项式P。

操作结果：完成一元多项式相加运算，即：Pa=Pa+Pb,销毁一元多项式Pb.

}ADT Polynomail

typedef struct{ // 项的表示，多项式为linklist的数据元素

float coef; //系数

int evpn; //指数

}term,ElemType; //两个类型名：term用于本ADT,ElemType为Linklist的数据对象名Typedef Linklist polynomial; //用带表头结点的有序链表表示多项式；

Int cmp(term a,term b)；

void CreatPolyn (polynomial &P,int m){

//输入m项的系数和指数，建立表示一元多项式的有序链表P

InitList (P); h = GetHead (P);

e.coef = 0.0;e.expn = -1;SetCurElem (h,e); //设置头结点的数据元素

for （i = 1;i<=m;++i）{//依次输入m项非零项

scanf(e.coef,e.expn);

if (! LocateElem(P,e,q,(*cmp)){ //当链表不存在指数项

if(MakeNode (s,e)) InsFirst(q,s);//生成结点并插入链表

}

}//CreatPolyn

void AddPolyn(polynomial &Pa, polynomial &Pb){

//多项式加法：Pa=Pa+Pb，利用两个多项式的结点构成“和多项式”

ha=Gethead(Pa); hb=Gethead(Pb);//ha和hb分别指向Pa和Pb的头结点

qa=NextPos(Pa,ha); qb=NextPos(Pb,hb);// /ha和hb分别指向Pa和Pb的当前结点

while(qa&&qb){//qa和qb均非空

a=GetCurElem(qa); b=GetCurElem(qb);

switch(*cmp(a,b)){

case -1: //多项式PA中当前结点的指数值小

ha=qa;qa= NextPos(Pa,ha);break;

case 0://l两者的指数相等

sum=a.cofe+b.cofe;

if(sum!=0.0){//修改多项式PA中当前结点的系数值

SetCurELem(qa,sum);ha=qa;}

else {//删除当前结点

Delfirst(ha,qa);FreeNode(qa);}

Delfirst(ha,qa);FreeNode(qa); qb=NextPos(Pb,hb); qa=NextPos(Pa,ha);break;

Case1://多项式PB中当前结点的指数值小

DelFirst(hb,qb); InsFirst(ha,qb);

qb=NextPos(Pb,hb); qa=NextPos(Pa,ha);break;

}//swtich

}//while

If(!ListEmpty(Pb)) Append(Pa,qb);

FreeNode(hb)://释放Pb头结点

}//AddPolyn

2. 数据结构分析：

逻辑结构为线性表，采用链式存储结构。因为我们要让一元多项式相加，需要使得数据变更，采用顺序存储结构的话，工作量就运用起来不便捷。因此链式存储结构显得更加简单方便。

------------------------------------------------

↓↓↓

CreatPolyn(&p,m) AddPolyn(&Pa,&Pb) PrintPolyn(P) 4．Addpolyn流程

三、详细设计

#include

#define Len sizeof (struct link)

struct link *head1,*rear1,*p,*head2,*rear2,*head3,*rear3; head1=rear1=(struct link *)malloc(Len);

printf("请输入第一个一元多项式的项数\n");

scanf("%d",&m);

printf("请输入第一个一元多项式的系数和指数\n");

for(i=0;i

{p=(struct link *)malloc(Len);

scanf("%d,%d",&p->coef,&p->expn);

head2=rear2=(struct link *)malloc(Len);

printf("请输入第二个一元多项式的项数\n");

scanf("%d",&n);

printf("请输入第二个一元多项式的系数和指数\n");

for(i=0;i

{p=(struct link *)malloc(Len);

scanf("%d,%d",&p->coef,&p->expn);

head3=rear3=(struct link *)malloc(Len);

while(rear1!=NULL&&rear2!=NULL)

{p=(struct link *)malloc(Len);

if(rear1->expn=rear2->expn)

{p->coef=rear1->coef+rear2->coef;

p->expn=rear2->expn;

rear1=rear1->next;

rear2=rear2->next;

i++;j++;rear3->next=p;

rear3=p;}

else if(rear1->expn>rear2->expn)

{p->coef=rear2->coef;

p->expn=rear2->expn;rear3->next=p;

rear3=p;j++;rear2=rear2->next;}

else if(rear1->expnexpn)

{p->coef=rear1->coef;

p->expn=rear1->expn;rear3->next=p;

rear3=p;i++;rear1=rear1->next;}

}

while(rear1!=NULL)

{p=(struct link *)malloc(Len);

p->coef=rear1->coef;

p->expn=rear1->expn;

rear3->next=p;rear3=p;

rear1=rear1->next;}

while(rear2!=NULL)

{p=(struct link *)malloc(Len);

p->coef=rear2->coef;

p->expn=rear2->expn;

rear3->next=p;rear3=p;

{printf("%d,%d,",rear3->coef,rear3->expn); rear3=rear3->next;}

}

四、调试分析及存在问题分析

五、用户手册

本程序的运行环境为windows 8.1操作系统，并且在Visual C++ 6.0中运行

数据结构实验多项式加法

数据结构实验报告实验名称：多项式加减法学号：1200310419 姓名：林强实验日期：2015.5.05 一、实验目的通过实现多项式的加减法，对链表有更深入的了解二、实验具体内容 1、实验题目1：（1）题目设计一个一元稀疏多项式简单的加减法计算器实现要求：一元稀疏多项式简单计算器的基本功能是：（1）输入并建立多项式： 85 17 A+ x + x =； + 3 9 x 7 ) (x 79 8 x B- + = x 22 8 x ) (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 0 typedef struct Lnode{

一元多项式的相加减复习过程

实验一一元多项式的表示和相减、相乘一、实验目的 1.掌握链表的存储方式 2.掌握一元多项式的存储及运算。二、实验内容已知一元多项式P(x)和Q(x)已存在，求P(x)-Q(x)和P(x)* Q(x)并输出。要求： 1.通过键盘随机输入两多项式P(x)和Q(x)的内容。 2.输出结果要有P(x)和Q(x)的以及它们的差P(x)-Q(x)和乘积P(x)* Q(x)。三、实验步骤： 1.创建一元多项P(x)和Q(x)。 2.求P(x)-Q(x)，P(x)* Q(x)。 3.输出P(x)、Q(x)、P(x)-Q(x)，P(x)* Q(x)。四、算法说明首先，定义一元多项式的存储方式，然后从键盘输入P(x)和Q(x)对应多项式的各对系数和指数，建立相应的一元多项式五、测试结果参考下图多项式相减多项式相乘

六、源代码 1.多项式的相减 # include # include typedef struct{ float coef; //系数 int expn; //指数 }ElemType; typedef struct LNode{ //结点类型 ElemType data; struct LNode *next; }*LinkList; void MakeNode(LinkList &s,ElemType e){ //生成结点 s=(LinkList)malloc(sizeof(LNode)); s->data=e; }

void InsAfter(LinkList p,LinkList s){ //插入结点 s->next=p->next; p->next=s; } int compare(ElemType e1,ElemType e2){ //比较 if(e1.expn>e2.expn) return 1; else if(e1.expnnext,s; while(q){ int n=compare(e,q->data); if(n<0){ MakeNode(s,e); InsAfter(p,s);break; } else if(n==0) { q->data.coef=q->data.coef+e.coef; if(q->data.coef==0){p->next=q->next;free(q);} break; }

数据结构课程设计报告一元多项式的计算

数据结构课程设计报告题目：一元多项式计算院（系）：计算机与信息科学学院专业：软件工程班级：软件1202班学号：02 05 40 姓名：陈潇潇刘敏易庆鹏指导教师：彭代文 2013年12月

一、课程设计介绍 1.1课程设计目的 ⑴熟悉使用c语言编码程序，解决实际问题； ⑵了解数据结构与算法的设计方法，具备初步的独立分析和设计能力。 ⑶初步掌握软件开发过程的分析能力，系统设计，程序编码，测试等基本能力。 ⑷提高综合运用的能力，运用所学理论知识与独立分析能力。 1.2课程设计内容一元多项式计算任务：⑴能够按照指数降序排列建立并输出多项式 ⑵能够完成两个多项式的相加，并将结果输入 ⑶在上交资料中请写明：存储结构、多项式相加的基本过程的算法（可以使用程序流程图）、源程序、测试数据和结果、算法的时间复杂度、另外可以提出算法的改进方法 1.3课程设计要求 ⑴学生必须仔细阅读《数据结构》课程设计方案，认真主动完成课设的要求。有问题及时主动通过各种方式与教师联系沟通。 ⑵学生要发挥自主学习的能力，充分利用时间，安排好课设的时间计划，并在课设过程中不断检测自己的计划完成情况，及时的向教师汇报。 ⑶课程设计按照教学要求需要一周时间完成，一周中每天（按每周5天）至少要上3-4小时的机来调试C语言设计的程序，总共至少要上机调试程序30小时。 ⑷课程设计在期末考试之前交。最好一起上交。 ⑸同班同学之间最好不要相同。源代码可以打印，但是下面模块要求的内容必须手写。二、需求设计 2.1 课设题目粗略分析建立一元多项式并按照指数降序排列输出多项式，将一元多项式输入并存储在内存中，能够完成两个多项式的加减运算并输出结果

数据结构-多项式相加

数据结构课程设计 2012年12月班级：XXX 学号：XXX 姓名： XXX 指导教师：XXX

一元稀疏多项式计算器【问题描述】设计一个一元稀疏多项式简单计算器【基本要求】一元多项式简单计算器的基本功能是： 1，输入并建立多项式; 2，输出多项式，输出形式为整数序列:n,c1,e1,c2,c2,...,cn,en,其中n是多项式的项数，ci和ei分别是第i项的系数和指数，序列按指数降序排列; 3,多项式a和b相加，建立多项式a+b; 4,多项式a和b相减，建立多项式a-b. 【算法设计思想】 ①一般情况下的一元n次多项式可写成pn(x)=p1xe1+p2xe2+……+pmxem 其中，p1是指数为ei的项的非零系数，且满足0≦e1

【实现提示】用带表头结点的单链表存储多项式。【程序代码】 #include #include typedef struct node { float coef; int expn; struct node *next; }Lnode, *polynmial; void create(polynmial &L); //输入并建立多项式L void display(polynmial L); //显示，输出多项式L void sort(polynmial &L); //多项式L按指数排序 void reverse(polynmial &L); //逆置 void select(); //用户选择加减操作 void add(polynmial La, polynmial Lb, polynmial &Lc); //多项式La,Lb相加void subtract(polynmial La, polynmial Lb, polynmial &Ld); //多项式La减去Lb，结果给Ld void create(polynmial &L) //输入并建立多项式L { int i, n; static struct node *p; scanf("%d", &n); L = (struct node *)malloc (sizeof(struct node)); L->next = NULL; for(i = 0; i < n; i++) { p = (struct node *)malloc(sizeof(struct node)); scanf("%f %d", &p->coef, &p->expn); p->next = L->next; L->next = p; } } void display(polynmial L)//显示，输出多项式L { struct node *p, *q; int flag = 0; int k = 0; q = L->next; while(q)

数据结构中实现一元多项式简单计算

数据结构中实现一元多项式简单计算：设计一个一元多项式简单的计算器。基本要求：一元多项式简单计算器的基本功能为：（1）输入并建立多项式；（2）输出多项式；（3）两个多项式相加，建立并输出和多项式；（4）两个多项式相减，建立并输出差多项式； #include #include #define MAX 20 //多项式最多项数 typedef struct//定义存放多项式的数组类型 { float coef; //系数 int exp; //指数 } PolyArray[MAX]; typedef struct pnode//定义单链表结点类型 { float coef; //系数 int exp; //指数 struct pnode *next; } PolyNode; void DispPoly(PolyNode *L) //输出多项式 { PolyNode *p=L->next; while (p!=NULL) { printf("%gX^%d ",p->coef,p->exp); p=p->next; } printf("\n"); } void CreateListR(PolyNode *&L,PolyArray a,int n) //尾插法建表 { PolyNode *s,*r;int i; L=(PolyNode *)malloc(sizeof(PolyNode)); //创建头结点 L->next=NULL; r=L; //r始终指向终端结点,开始时指向头结点for (i=0;i

数据结构实验一一元多项式相加

数据结构实验报告实验一：一元多项式相加姓名：周成学号：专业：软件工程任课教师：马慧珠 2013年12 月01 日

1.实验名称：一元多项式相加 2.实验目的: 如何使用C语言实现链表的说明、创建以及结点的插入和删除等操作。 3.实验要求：对一元多项式能实现输入、输出，以及两个一元多项式相加及结果显示。 4.实验内容：一元多项式的表示在计算机内用链表来实现，同时为了节省存储空间，只存储其中非零的项，链表中的每个节点存放多项式的系数非零项。它包含三个域，分别存放多项式的系数，指数，以及指向下一个项的指针。根据一元多项式相加的运算规则：对于两个一元多项式中所有指数相同的项，对应系数相加，若其和不为零，则构成“和多项式”中的一项，对于两个一元多项式中所有指数不相同的项，则分别复抄到“和多项式”中去。核心算法PolyAdd是把分别由pa和pb所指的两个多项式相加，结果为pa所指的多项式。运算规则如下：相加时，首先设两个指针变量qa和qb分别从多项式的首项开始扫描，比较qa和qb所指结点指数域的值，可能出现下列三种情况之一：

（1）qa->exp大于qb->exp,则qa继续向后扫描。（2）qa->exp等于qb->exp,则将其系数相加。若相加结果不为零，将结果放入qa->coef中，并删除qb所指结点，否则同时删除qa和qb所指结点。然后qa、qb继续向后扫描。（3）qa->exp小于qb->exp,则将qb所指结点插入qa所指结点之前，然后qa、qb继续向后扫描。扫描过程一直进行到qa或qb有一个为空为止，然后将有剩余结点的链表接在结果表上。所得pa指向的链表即为两个多项式之和。 5.实验程序代码及运行结果： #include"" #include<> #include<> #include<> #include<> #define NULL 0 typedef struct NODE {

一元多项式求和

一元多项式求和——链表编程一．实验名称：一元多项式求和——链表编程。二．实验环境：Windows Xp ,Vc++6.0。三．实验目的： 1.掌握一元多项式的链表式存储算法； 2.掌握链表的结构定义； 3.采用尾插法生成单链表。四．实验内容： 1.一元多项式的表示：一元多项式可按升幂的形式表示为 12012()n e e e n n P x p p x p x p x =++++…… 其中：i e 为第i 项的指数，i p 是指数i e 的项的系数，且 121i n e e e e <=<=<=<=<=<=……。则多项式()n P x 可以用一个线性表P 来表示：01(,)m P p p p =, ；同理，多项式 ()n Q x 可表示为01(,,)n Q q q q =…（mcodf=c;

多项式加法(C语言实现)

多项式加法 #include #include #define Max_Size 100 typedef struct node { float coef; int expn; struct node *next; }PolyNode; int CreCoeStr(float C[]) { char flag; int i=0; do { scanf("%f",&C[i++]); scanf("%c",&flag); } while (flag!='#'); return(i); } void CreExpStr(int E[]) { int i=0; char flag; do { scanf("%d",&E[i++]); scanf("%c",&flag); } while (flag!='#'); } void InitPolyList(PolyNode **sq) { if((*sq=(PolyNode *)malloc(sizeof(PolyNode)))==NULL) exit(1); (*sq)->next=NULL; }

void CreatPolyList(PolyNode **sq,float C[],int E[],int num) { int i; PolyNode *s,*r=*sq; for(i=0;icoef=C[i]; s->expn=E[i]; r->next=s; r=s; } r->next=NULL; } void InsertSortPoly(PolyNode **sq) { PolyNode *p,*q,*r,*u; p=(*sq)->next; (*sq)->next=NULL; while (p) { r=*sq; q=(*sq)->next; while (q&&q->expn<=p->expn) { r=q; q=q->next; } u=p->next; p->next=r->next; r->next=p; p=u; } } void DispList(PolyNode *sq) { PolyNode *p=sq->next; while(p) { printf("(%7.2f,%d)",p->coef,p->expn); p=p->next; }

数据结构一元多项式的加减乘

#ifndef _POL YNOMIAL_H #define _POL YNOMIAL_H #include using namespace std; #include //#define ElemType char typedef struct // 项的表示,多项式的项作为LinkList的数据元素 { float coef; // 系数 int expn; // 指数 }term, ElemType; typedef struct LNode // 结点类型 { ElemType data; struct LNode *next; }LNode,*Link,*Position; typedef struct LinkList // 链表类型 { Link head,tail; // 分别指向线性链表中的头结点和最后一个结点 int len; // 指示当前线性链表中数据元素的个数 }LinkList; typedef LinkList polynomial; void InitList(LinkList &P); void CreatPolyn(polynomial &P,int m); void DestroyPolyn(polynomial &P); void CreatePolyn(polynomial &P,int m);//建立表示一元多项式的有序链表P void DestroyPolyn(polynomial &P);//销毁一元多项式P void PrintPolyn(polynomial P);//打印 int PolyLength(polynomial P);//项数 void AddPolyn(polynomial &Pa,polynomial &Pb);//相加运算 void SubtractPolyn(polynomial &Pa,polynomial &Pb);//相减运算 void MultiplyPolyn(polynomial &P,polynomial &Pa,polynomial &Pb);//相乘运算 int cmp(term a,term b);//依a的指数值<(或=)(或>)b的指数值，分别返回-1,0,+1 int LocateElemP(LinkList L,ElemType e,Position *q, int(*compare)(ElemType,ElemType)); int MakeNode(Link *p,ElemType e); int InsFirst(LinkList *L,Link h,Link s);

链表实现多项式相加实验报告

实验报告课程名称：数据结构题目：链表实现多项式相加班级：学号：姓名：完成时间：2012年10月17日

1、实验目的和要求 1）掌握链表的运用方法； 2）学习链表的初始化并建立一个新的链表； 3）知道如何实现链表的插入结点与删除结点操作； 4）了解链表的基本操作并灵活运用 2、实验内容 1）建立两个链表存储一元多项式； 2）实现两个一元多项式的相加； 3）输出两个多项式相加后得到的一元多项式。 3、算法基本思想数降序存入两个链表中，将大小较大的链表作为相加后的链表寄存处。定义两个临时链表节点指针p,q,分别指向两个链表头结点。然后将另一个链表中从头结点开始依次与第一个链表比较，如果其指数比第一个小，则p向后移动一个单位，如相等，则将两节点的系数相加作为第一个链表当前节点的系数，如果为0，则将此节点栓掉。若果较大，则在p前插入q,q向后移动一个，直到两个链表做完为止。 4、算法描述用链表实现多项式相加的程序如下： #include #include #include struct node{ int exp; float coef; struct node*next; };

void add_node(struct node*h1,struct node*h2); void print_node(struct node*h); struct node*init_node() { struct node*h=(struct node*)malloc(sizeof(struct node)),*p,*q; int exp; float coef=1.0; h->next=NULL; printf("请依次输入多项式的系数和指数(如:\"2 3\"；输入\"0 0\"时结束):\n"); p=(struct node*)malloc(sizeof(struct node)); q=(struct node*)malloc(sizeof(struct node)); for(;fabs(coef-0.0)>1.0e-6;) { scanf("%f %d",&coef,&exp); if(fabs(coef-0.0)>1.0e-6) { q->next=p; p->coef=coef; p->exp=exp; p->next=NULL; add_node(h,q); } } free(p); free(q); return(h); } void add_node(struct node*h1,struct node*h2) { struct node*y1=h1,*y2=h2; struct node*p,*q; y1=y1->next; y2=y2->next; for(;y1||y2;) if(y1) { if(y2) { if(y1->expexp) y1=y1->next; else if(y1->exp==y2->exp) { y1->coef+=y2->coef; if(y1->coef==0)

数据结构一元多项式的计算

一元多项式的计算数据结构课程设计

一元多项式的计算—加，减摘要(题目)一元多项式计算任务：能够按照指数降序排列建立并输出多项式；能够完成两个多项式的相加、相减，并将结果输入；目录 1.引言 2.需求分析 3.概要设计 4.详细设计 5.测试结果 6.调试分析 7.设计体会 8.结束语一:引言: 通过C语言使用链式存储结构实现一元多项式加法、减法和乘法的运算。按指数

降序排列。二：需求分析建立一元多项式并按照指数降序排列输出多项式，将一元多项式输入并存储在内存中，能够完成两个多项式的加减运算并输出结果三：概要设计存储结构：一元多项式的表示在计算机内可以用链表来表示，为了节省存储空间，只存储多项式中系数非零的项。链表中的每一个结点存放多项式的一个系数非零项，它包含三个域，分别存放该项的系数、指数以及指向下一个多项式项结点的指针。创建一元多项式链表，对一元多项式的运算中会出现的各种可能情况进行分析，实现一元多项式的相加、相减操作。 1．单连表的抽象数据类型定义： ADT List{ 数据对象：D={ai|ai∈ElemSet,i=1,2,…,n,n≥0} 数据关系：R1={| ai-1, ai∈D,i=2,…,n} 基本操作： InitList（＆L） //操作结果：构造一个空的线性表 CreatPolyn(&L) //操作结果：构造一个以单连表存储的多项试 DispPolyn(L) //操作结果：显示多项试 Polyn(&pa,&pb) //操作结果：显示两个多项试相加，相减的结果 } ADT List 2．本程序包含模块： typedef struct LNode //定义单链表 { }LNode,*LinkList; void InitList(LinkList &L) //定义一个空表 { } void CreatPolyn(LinkList &L) //用单链表定义一个多项式 { } void DispPolyn(LinkList L) //显示输入的多项式

多项式求和

数据结构课程设计题目：多项式运算学生姓名：熊奉标学号：10115011046 专业：计算机科学与技术班级：10级（1）班指导教师姓名及职称：陈正铭讲师起止时间：2012 年2 月——2012 年4 月 1 需求分析

1.1 课题背景及意义本课程设计主要解决一元多项式的运算问题，通过链表的使用，实现对一元多项式的构建、录入、存储、打印、以及之间的运算。在本课程设计中，程序设计语言为C++语言，程序运行平台为Windows/98/2000/XP，程序采用了链表存储方法以及结构化和模块化的设计方法，通过调试运行，可以进行多项式的加、减、乘运算，勉强实现了设计目标，并且经过适当完善后，将可应用到实际中解决某些问题。一元多项式的运算，虽然无法直接在除数学外的其他领域作出贡献，但是在数学上，它可以为人们解决一些自己动笔动手很难解决的问题，比如说那些很长很长的多项式，用笔算可能要算半天，但是用该程序，只需短短的几秒钟，所以它给人们带来了不少方便，同时相信它也能间接地为其他领域做出贡献。 1.2 课题要求（1）掌握线性表的创建、插入、删除等基本运算。（2）掌握线性表的顺序存储结构和链式存储结构（3）掌握线性表的典型应用—多项式运算(加、减、乘)。该程序的主要任务是将用户输入的多项式用线性表存储，然后通过对线性表的基本操作，而实现多项式之间的三则运算，把正确结果输出给用户。 1.3 软件格式规定输入格式：有两类编辑框可供输入，系数编辑框、指数编辑框，在系数编辑框中允许输入浮点型数据，在指数编辑框中只允许输入整型数据。正确的输入： f(x)=8X^6+4X^5-2X^4-12X^3-1X^1+10X^0 g(x)=2X^3-5X^2+1X^1 正确的输出结果： f(x)+g(x)：结果= 8.00X^6 +4.00X^5 -2.00X^4 -121.00X^3 -5.00X^2 +10.00 f(x)-g(x)：结果= 8.00X^6 +4.00X^5 -2.00X^4 -125.00X^3 +5.00X^2 -2.00X

一元多项式相加完整实验报告

一元多项式相加实验报告一元多项式的相加

一实验内容根据所学的数据结构中线性结构（线性表）的逻辑特性和物理特性及相关算法，应用于求解一个具体的实际问题----------两个多项式相加二需求分析 1掌握线性结构的逻辑特性和物理特性。 2建立一元多项式。 3将一元多项式输入，并存储在内存中，并按照指数降序排列输出多项式。 4能够完成两个多项式的加减运算，并输出结果。三概要设计 1 本程序所用到的抽象数据类型： typedef OrderedLinkList polynomial; // 用带表头结点的有序链表表示多项式结点的数据元素类型定义为: typedef struct { // 项的表示 float coef; // 系数 int expn; // 指数 term, ElemType; V oid AddPolyn(polynomail&Pa,polynomail&Pb) Position GetHead() Position NextPos(LinkList L,Link p) Elem GetCurElem(Link p) int cmp(term a term b) Status SetCurElem(Link&p, ElemType e) Status DelFirst(Link h, Link &q) Status ListEmpty(LinkList L) Status Append(LinkList&L, Link S) FreeNode() 2 存储结构

一元多项式的表示在计算机内用链表来实现，同时为了节省存储空间，只存储其中非零的项，链表中的每个节点存放多项式的系数非零项。它包含三个域，分别存放多项式的系数，指数，以及指向下一个项的指针。创建一元多项式链表，对运算中可能出现的各种情况进行分析，实现一元多项式的相加相减操作。 3 模块划分 a) 主程序；2）初始化单链表；3）建立单链表； 4）相加多项式 4 主程序流程图四详细设计根据一元多项式相加的运算规则：对于两个一元多项式中所有指数相同的项，对应系数相加，若其和不为零，则构成“和多项式”中的一项，对

数据结构一元多项式报告

一元多项式计算：程序要求： 1）、能够按照指数降序排列建立并输出多项式； 2）、能够完成两个多项式的相加、相减，并将结果输入。概要设计： 1.功能：将要进行运算的多项式输入输出。 2.数据流入：要输入的多项式的系数与指数。 3.数据流出：合并同类项后的多项式。 4.程序流程图：多项式输入流程图如图3.2.1所示。 5.测试要点：输入的多项式是否正确，若输入错误则重新输入 2、多项式的加法（1）功能：将两多项式相加。（2）数据流入：输入函数。（3）数据流出：多项式相加后的结果。（4）程序流程图：多项式的加法流程图如图3.2.2所示。（5）测试要点：两多项式是否为空，为空则提示重新输入，否则，进行运算。

3、多项式的减法（1）功能：将两多项式相减。（2）数据流入：调用输入函数。（3）数据流出：多项式相减后的结果。（4）程序流程图：多项式的减法流程图如图3.2.3所示。（5）测试要点：两多项式是否为空，为空则提示重新输入，否则，进行运算。

详细代码： #include #include #include using namespace std; struct Node { float coef;//结点类型 int exp; }; typedef Node polynomial;

struct LNode { polynomial data;//链表类型 LNode *next; }; typedef LNode* Link; void CreateLink(Link &L,int n); void PrintList(Link L); void PolyAdd(Link &pc,Link pa,Link pb); void PolySubstract(Link &pc,Link pa,Link pb); void CopyLink(Link &pc,Link pa); void PolyMultiply(Link &pc,Link pa,Link pb); int JudgeIfExpSame(Link pa,Link e); void DestroyLink(Link &L); int CompareIfNum(int i); void DestroyLink(Link &L) { Link p; p=L->next; while(p) { L->next=p->next; delete p; p=L->next; } delete L; L=NULL; } //创建含有n个链表类型结点的项，即创建一个n项多项式void CreateLink(Link &L,int n) { if(L!=NULL) { DestroyLink(L); } Link p,newp; L=new LNode; L->next=NULL; (L->data).exp=-1;//创建头结点 p=L; for(int i=1;i<=n;i++) { newp=new LNode; cout<<"请输入第"<

一元多项式计算(数据结构课程设计)

一、系统设计 1、算法思想根据一元多项式相加的运算规则：对于两个一元多项式中所有指数相同的项，对应指数相加（减），若其和（差）不为零，则构成“和（差）多项式”中的一项；对于两个一元多项式中所有指数不相同的项，则分别写到“和（差）多项式”中去。因为多项式指数最高项以及项数是不确定的，因此采用线性链表的存储结构便于实现一元多项式的运算。为了节省空间，我采用两个链表分别存放多项式a 和多项式b，对于最后计算所得的多项式则利用多项式a进行存储。主要用到了单链表的插入和删除操作。

(1)一元多项式加法运算它从两个多项式的头部开始，两个多项式的某一项都不为空时，如果指数相等的话，系数就应该相加；相加的和不为零的话，用头插法建立一个新的节点。P 的指数小于q的指数的话就应该复制q的节点到多项式中。P的指数大于q的指数的话，就应该复制p节点到多项式中。当第二个多项式空，第一个多项式不为空时，将第一个多项式用新节点产生。当第一个多项式空，第二个多项式不为空时，将第二个多项式用新节点产生。 (2)一元多项式的减法运算它从两个多项式的头部开始，两个多项式的某一项都不为空时，如果指数相等的话，系数就相减；相加的和不为零的话，用头插法建立一个新的节点。p的指数小于q的指数的话，就应该复制q的节点到多项式中。P的指数大于q的指数的话就应该复制p的节点到多项式中，并且建立的节点的系数为原来的相反数；当第二个多项式空，第一个多项式不为空时，将第一个多项式用新节点产生。当第一个多项式空，第二个多项式不为空时，将第二个多项式用新节点产生，并且建立的节点的系数为原来的相反数。 2、概要设计 (1)主函数流程图：（注：a代表第一个一元二次方程，b代表第二个一元二次方程）

两个一元多项式相加-c++版

《数据结构》实验报告 ——两个一元多项式相加一、实验题目：两个一元多项式相加二、实验内容：根据所学的数据结构中线性结构（线性表）的逻辑特性和物理特性及相关算法，应用于求解一个具体的实际问题----------两个多项式相加三、设计思想：（1）建立两个顺序列表，分别用来表示两个一元多项式；顺序列表奇数位，存储该多项式的系数；顺序列表的偶数位，存储该相应多项式的指数。（2）用成员函数merg(qList&l2)实现两多项式的相加。实现的大致方法为：比较第二个多项式列表与第一个多项式列表的偶数位的数值大小（指数），如果相同，则将他们的前一位数（系数）相加；如果不同，就将他的前一位数（系数）及它自己（指数）插入第一个多项式列表的后面。（3）建立函数shu(double a[],int j)实现多项式的输入。四、源程序代码 #include "stdafx.h" #include using namespace std; template class List { private: Telem * elem; int curlen; int maxlen; public: List(int maxsz=100):maxlen(maxsz) { curlen=0; elem=new Telem{maxlen}; }; List(Telem a[],int n,int maxsz=100):maxlen(maxsz) { curlen=n; elem=new Telem[maxlen]; for(int i=0;i

一元多项式的运算

数据结构课程设计实验报告专业班级：学号：姓名： 2011年1月1日

题目：一元多项式的运算 1、题目描述一元多项式的运算在此题中实现加、减法的运算，而多项式的减法可以通过加法来实现（只需在减法运算时系数前加负号）。在数学上，一个一元n次多项式P n(X)可按降序写成： P n(X)= P n X^n+ P(n-1)X^(n-1)+......+ P1X+P0 它由n+1个系数惟一确定，因此，在计算机里它可以用一个线性表P来表示： P=(P n，P(n-1)，......，P1，P0) 每一项的指数i隐含在其系数P i的序号里。假设Q m(X)是一元m次多项式，同样可以用一个线性表Q来表示： Q=(q m,q(m-1)，.....，q1，q0) 不是一般性，假设吗吗m