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

试验一多项式相加

一. 实验内容：

多项式相加

二.实验目的和要求：

利用双向链表实现通讯录的建立、删除、检索和列表，并可保存至文件，可重新装入。

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

三．算法思想描述:

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->expexp){

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. 主函数调用，完成多项式相加。

四．程序结构：

1.数据结构

typedef struct node{

int coef; /*系数*/

int exp; /*幂*/

struct node *link; 下一个结点的指针*/

} *pnode; /*多项式结点的指针*/

2. 函数功能说明

pnode create():建立一个多项式链表

pnode add(pnode heada,pnode headb): 两个多项式单链表合并

void node(pnode head): 输出多项式单链表

五．测试结果与分析

上述程序在Visual C++ 6.0环境下加以实现。经过多次测试，程序运行正确。结果如图：

六．收获与体会

通过这次课程设计:

1.我又进一步巩固了C语言的基础。

2.通过程序加深了对链表方面知识的认识。

3.，提高了自己的编程能力，

4.程序不够简洁，还有待改进，功能还有待更完善。

数据结构实验多项式加法

数据结构实验报告 实验名称：多项式加减法 学号：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{

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

数据结构实验报告实验一：一元多项式相加 姓名：周成 学号： 专业：软件工程 任课教师：马慧珠 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 {

数据结构-多项式相加

数据结构课程设计 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)

C++一元多项式合并实验报告

实验二一元多项式相加问题本实验的目的是进一步熟练掌握应用链表处理实际问题的能力。 一、问题描述 一元多项式相加是通过键盘输入两个形如P 0+P 1 X1+P 2 X2+···+PnX n的多项式，经过程序运算后在屏幕上输出它 们的相加和。 二、数据结构设计 分析任意一元多项式的描述方法可知，一个一元多项式的每一个子项都由“系数—指数”两部分组成，所以可将它抽象成一个由“系数—指数对”构成线性表，由于对多项式中系数为0的子项可以不记录他的数值，对于这样的情况就不再付出存储空间来存放它了。基于这样的分析，可以采取一个带有头结点的单链表来表示一个一元多项式。具体数据结构定义为： typedef struct node { float ce; //系数域 float ex; //指数域 struct node *next; //指针域 }lnode,*linklist; 三功能（函数）设计 1、输入并建立多项式的功能模块 此模块要求按照指数递增的顺序和一定的输入格式输入各个系数不为0的子项的“系数—指数对”，输入一个子项建立一个相关的节点，当遇到输入结束标志时结束输入，而转去执行程序下面的部分。 屏幕提示： input ce & ex and end with 0： ce=1 ex=2 ce=0 ex=0 //输入结束标志 input ce & ex and end with 0： ce=2 ex=2 ce=0 ex=0 //输入结束标志 输入后程序将分别建立两个链表来描述两个一元多项式： A=X^2 B=2X^2 这两个多项式的相加的结果应该为： C=3X^2 2、多项式相加的功能模块 此模块根据在1中建立的两个多项式进行相加运算，并存放在以C为头指针的一个新建表中。可以采用以下方法进行设计： 开始时a，b分别指向A,B的开头，如果ab不为空，进行判断：如果a所指的结点的指数和b所指的结点的指数相同，将它们的系数相加做成C式中的一项，如果不一样则将小的一项加到C中。 if(a->ex==b->ex) //判断指数是否相等 {s->ce=a->ce+b->ce; if(s->ce!=0) s->ex=a->ex; else delete s; a=a->next; b=b->next; }

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

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

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

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

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

一元多项式的计算—加，减 摘要(题目)一元多项式计算 任务：能够按照指数降序排列建立并输出多项式； 能够完成两个多项式的相加、相减，并将结果输入； 目录 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) //显示输入的多项式

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

实验报告 课程名称：数据结构 题目：链表实现多项式相加 班级： 学号： 姓名： 完成时间：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)

数据结构——一元多项式的建立与相加

#include #include using namespace std; typedef struct PolyNode { int coef; //系数 int expn; //指数 struct PolyNode *next; } *PNode; //多项式结点的指针 void InitPoly(PNode &head,PNode &p) { head=(PNode)malloc(sizeof(struct PolyNode)); head->next=NULL; head->coef=0; head->expn=-1; p=head; } void CreatePoly(PNode &head,int a,int n) { PNode s; s=(PNode)malloc(sizeof(struct PolyNode)); //建立新的结点s->coef=a; s->expn=n; s->next=NULL; head->next=s; head=s; } void PrintPoly(PNode head) { int i=1;//控制第一对系数指数的显示 head=head->next;//指向表头结点的下一个 PNode p; p=head; while ((p->next)!=NULL) { if(i) //显示第一对的时候是不需要显示加号的 { if (p->expn==1) cout<coef<<"x"; else if (p->expn==0) cout<coef<

else cout<coef<<"x^"<expn; i=0; } else { if (p->expn==1) cout<coef<<"+x"; else if (p->expn==0) cout<<"+"<coef<coef<<"x^"<expn; } p=p->next; } cout<next; pb=pb->next; p=pc; while (pa!=NULL && pb!=NULL) { if (pa->expn>pb->expn) { s=(PNode)malloc(sizeof(struct PolyNode)); s->coef=pa->coef; s->expn=pa->expn; s->next=NULL; p->next=s; p=s; pa=pa->next; } else if (pa->expnexpn) { s=(PNode)malloc(sizeof(struct PolyNode)); s->coef=pb->coef; s->expn=pb->expn; s->next=NULL; p->next=s; p=s; pb=pb->next; }

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

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

一实验内容 根据所学的数据结构中线性结构（线性表）的逻辑特性和物理特性及相关算法，应用于求解一个具体的实际问题----------两个多项式相加 二需求分析 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 主程序流程图 四详细设计 根据一元多项式相加的运算规则：对于两个一元多项式中所有指数相同的项，对应系数相加，若其和不为零，则构成“和多项式”中的一项，对

一元多项式的运算

数据结构课程设计实验报告 专业班级： 学号： 姓名： 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

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

试验一多项式相加 一. 实验内容： 多项式相加 二.实验目的和要求： 利用双向链表实现通讯录的建立、删除、检索和列表，并可保存至文件，可重新装入。 用链式存储结构实现一元多项式的相加运算。 三．算法思想描述: 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->expexp){ 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);

两个一元多项式相加-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

数据结构多项式的加减(方法01)

数据结构多项式的加减(方法01).txt {float coef; int expn; struct node * next; }PLOY; 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->expnexpn) { 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; } 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; } PLOY *sub(PLOY *head,PLOY *pre) //多项式相减

[计算机]一元多项式相加完整实验报告

[计算机]一元多项式相加完整实验报告一元多项式的相加 一实验内容 根据所学的数据结构中线性结构(线性表)的逻辑特性和物理特性及相关算法，应用于求解一个具体的实际问题----------两个多项式相加 二需求分析 1掌握线性结构的逻辑特性和物理特性。 2建立一元多项式。 3将一元多项式输入，并存储在内存中，并按照指数降序排列输出多项式。 4能够完成两个多项式的加减运算，并输出结果。 三概要设计 1 本程序所用到的抽象数据类型: typedef OrderedLinkList polynomial; // 用带表头结点的有序链表表示多项式 结点的数据元素类型定义为: typedef struct { // 项的表示 oat flcoef; // 系数 int expn; // 指数 term, ElemType; Void 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 存储结构 一元多项式的表示在计算机内用链表来实现，同时为了节省存储空间，只存储其中非零的项，链表中的每个节点存放多项式的系数非零项。它包含三个域，分别存放多项式的系数，指数，以及指向下一个项的指针。 序数coef 指数exp 指针域next 创建一元多项式链表，对运算中可能出现的各种情况进行分析，实现一元多项式的相加相减操作。 3 模块划分 a) 主程序;2)初始化单链表;3)建立单链表; 4)相加多项式 4 主程序流程图 开始 申请结点空间 输入多项式各项的系数X，指数Y 输出已输出的多项式 否 是否输入正确 合并同类项 结束 四详细设计 根据一元多项式相加的运算规则:对于两个一元多项式中所有指数相

多项式

#include"iostream.h" #include"stdio.h" #include"stdlib.h" typedef struct link { int c; int e; struct link *next; }Link; Link * CreateList_L(int n) // 创建链表头插法正位序{ int i; Link *p,*q,*L; L=(Link *)malloc(sizeof(Link)); L->next=NULL; q=L; cout<<"请输入"<>p->c>>p->e; q->next=p; q=p; } q->next=NULL; return L; } void print(Link *L) { Link *p; p=L->next; if(p) do { cout<c<<" "<e<<" "; p=p->next; }while(p!=NULL); cout<next;

p2=h2->next; while(p1!=NULL&&p2!=NULL) if(p1->e>p2->e) {h->next=p1;h=p1;p1=p1->next;} else if(p2->e>p1->e) {h->next=p2;h=p2;p2=p2->next;} else if(p1->c+p2->c!=0) {p1->c=p1->c+p2->c;h->next=p1; h=p1;p1=p1->next; q=p2;p2=p2->next; free(q);} else { q=p1;p1=p1->next;free(q); q=p2;p2=p2->next;free(q); } if(p1!=NULL) h->next=p1; else h->next=p2; free(h2); } void main() { int n1,n2; Link *h1,*h2; cout<<"请输入h1表长:"; cin>>n1; cout<<"请输入h2表长:"; cin>>n2; h1=CreateList_L(n1); h2=CreateList_L(n2); cout<<"输出h1:"; print(h1); cout<<"输出h2:"; print(h2); plus(h1,h2); cout<<"多项式相加结果:"<

数据结构实验报告-一元多项式

数据结构课程设计报告 课题: 一元多项式 姓名： XX 学号： 201417030218 专业班级： XXXX 指导教师： XXXX 设计时间： 2015年12月30日星期三

目录 一、任务目标 (3) 二、概要设计 (4) 三、详细设计 (6) 四、调试分析 (8) 五、源程序代码 (8) 六、程序运行效果图与说明 (15) 七、本次实验小结 (16) 八、参考文献 (16)

一丶任务目标 分析 (1) a.能够按照指数降序排列建立并输出多项式 b.能够完成两个多项式的相加，相减，并将结果输入 要求：程序所能达到的功能： a.实现一元多项式的输入； b.实现一元多项式的输出； c.计算两个一元多项式的和并输出结果； d.计算两个一元多项式的差并输出结果； 除任务要求外新增乘法： 计算两个一元多项式的乘积并输出结果 （2）输入的形式和输入值的范围： 输入要求：分行输入，每行输入一项，先输入多项式的指数，再输入多项式的系数，以0 0为结束标志，结束一个多项式的输入。 输入形式： 2 3 -1 2 3 0 1 2 0 0 输入值的范围：系数为int型，指数为float型 （3）输出的形式： 第一行输出多项式1； 第二行输出多项式2； 第三行输出多项式1与多项式2相加的结果多项式； 第四行输出多项式1与多项式2相减的结果多项式； 第五行输出多项式1与多项式2相乘的结果多项式

二、概要设计 程序实现 a. 功能：将要进行运算的二项式输入输出； b. 数据流入：要输入的二项式的系数与指数； c. 数据流出：合并同类项后的二项式； d. 程序流程图：二项式输入流程图； e. 测试要点：输入的二项式是否正确，若输入错误则重新输入。

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

池州学院 CHIZHOU COLLEGE 《数据结构》 课程设计报告 学号：57 54 39 37 20 25 27 姓名：周田张永鹏武警温凯侨李坤 米昌华阮健健 班级：10计算机科学与技术（2）班 指导教师： 成绩： 数学与计算机科学系

一、课程设计基本情况 1、设计名称 一元多项式计算 2、主要功能 能够按照指数降序排列建立并输出多项式；能够完成两个多项式的相加、相减，并将结果输出； 3、设计平台 电脑、Visual c++ 6.0

二、系统设计 1、算法思想 根据一元多项式相加的运算规则：对于两个一元多项式中所有指数相同的项，对应指数相加（减），若其和（差）不为零，则构成“和（差）多项式”中的一项；对于两个一元多项式中所有指数不相同的项，则分别写到“和（差）多项式”中去。 因为多项式指数最高项以及项数是不确定的，因此采用线性链表的存储结构便于实现一元多项式的运算。为了节省空间，我采用两个链表分别存放多项式a 和多项式b，对于最后计算所得的多项式则利用多项式a进行存储。主要用到了单链表的插入和删除操作。 (1)一元多项式加法运算 它从两个多项式的头部开始，两个多项式的某一项都不为空时，如果指数相等的话，系数就应该相加；相加的和不为零的话，用头插法建立一个新的节点。P的指数小于q的指数的话就应该复制q的节点到多项式中。P的指数大于q的指数的话，就应该复制p节点到多项式中。当第二个多项式空，第一个多项式不为空时，将第一个多项式用新节点产生。当第一个多项式空，第二个多项式不为空时，将第二个多项式用新节点产生。 (2)一元多项式的减法运算 它从两个多项式的头部开始，两个多项式的某一项都不为空时，如果指数相等的话，系数就相减；相加的和不为零的话，用头插法建立一个新的节点。p的指数小于q的指数的话，就应该复制q的节点到多项式中。P的指数大于q的指数的话就应该复制p的节点到多项式中，并且建立的节点的系数为原来的相反数；当第二个多项式空，第一个多项式不为空时，将第一个多项式用新节点产生。当第一个多项式空，第二个多项式不为空时，将第二个多项式用新节点产生，并且建立的节点的系数为原来的相反数。 2、概要设计 (1)主函数流程图： （注：a代表第一个一元二次方程，b代表第二个一元二次方程）

多项式相加的函数(数据结构_C语言版)

一、编写一个程序用单链表存储多项式，并实现两个多项式相加的函数。【源程序】#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;icoef=a[i].coef; s->exp=a[i].exp; r->next=s; //将*s插入*r之后 r=s; } r->next=NULL; } void Sort(PolyNode *&head)//按exp域递减排序 { PolyNode *p=head->next,*q,*r; if(p!=NULL) { r=p->next; p->next=NULL; p=r; while(p!=NULL)