[计算机]一元多项式相加完整实验报告
一元多项式相加问题的实验报告
{
ﻩfloatｃoef; /／系数域
inｔｅｘp;／/指数域
ｓtruｃtnｏdｅ＊nexｔ;
｝;
三、功能函数设计
1、输入多项式的系数和指数初始化多项式的功能模块
具体函数为node *in_fun()
此函数的处理较为全面，要求用户按照指数递增的顺序和一定的输入格式输入各个系数不为0的子项,输入一个子项建立一个相关结点，当遇到输入结束标志时停止输入。关键步骤具体如下:
if（q！=ＮULL)q->ｎext＝NULL；
ﻩreturｎa;
⑷动态分配空间新建结点存储系数和指数的代码如下：
p＝nｅw noｄｅ;
ﻩp－＞cｏeｆ=x;
ﻩp->exp=ｙ；
ﻩﻩif(a=＝NＵLL）a=ｐ;
ﻩelseｑ->nexｔ＝p;
ﻩﻩq=ｐ；
2、多项式显示功能函数
由于系数有正有负，故采取如下处理:
二、数据结构设计
一个一元多项式的每一个子项都由“系数-指数”两部分组成，因此可将其抽象为包含系数ｃoef、指数eｘp、指针域next构成的链式线性表。将两个多项式分别存放在两个线性表中,然后经过相加后将所得多项式存放在一个新的线性表中,但是不用再开辟新的存储空间,只依靠结点的移动来构成新的线性表,期间可以将某些不需要的空间回收。基于这样的分析,可以采用不带头结点的单链表来表示一个一元多项式。具体数据类型定义为:
ﻩｉf(p!=NULL)
{
ﻩﻩwhile(ｐ)
{
w=p;
p=p-＞neｘｔ;
ﻩﻩﻩr->next＝ｗ；
ﻩﻩr=w；
}
ﻩ}
if(q!=NUＬL)
{
ﻩﻩwhilｅ（ｑ)
一元多项式的相加实验报告
一元多项式的相加实验报告一元多项式的相加实验报告引言：一元多项式是数学中常见的概念，它由一个变量和一系列常数乘积的和组成。
在本实验中，我们将研究一元多项式的相加运算，并通过实验验证相加运算的性质和规律。
实验目的：1. 了解一元多项式的基本概念和相加运算规则；2. 掌握使用编程语言进行一元多项式相加的方法；3. 验证一元多项式相加的性质和规律。
实验过程：1. 准备工作：a. 确定一元多项式的表示方式：我们选择使用数组来表示一元多项式，数组的每个元素表示多项式中对应项的系数；b. 确定一元多项式的相加规则：将相同次数的项的系数相加得到新的多项式的对应项的系数；c. 编写程序：使用编程语言编写一段代码，实现一元多项式的相加运算。
2. 实验步骤：a. 输入两个一元多项式的系数：通过程序提示用户输入两个一元多项式的系数，以数组的形式保存；b. 进行相加运算：将两个一元多项式的对应项系数相加，得到新的一元多项式的系数；c. 输出相加结果：将相加得到的新的一元多项式的系数输出，以验证相加运算的正确性。
实验结果：我们进行了多次实验，以下是其中一次实验的结果：假设输入的两个一元多项式分别为：P(x) = 2x^3 + 4x^2 + 3x + 1Q(x) = 5x^2 + 2x + 6根据相加规则，我们将对应项系数相加，得到新的一元多项式的系数：R(x) = 2x^3 + (4+5)x^2 + (3+2)x + (1+6)= 2x^3 + 9x^2 + 5x + 7因此，相加运算的结果为：P(x) + Q(x) = 2x^3 + 9x^2 + 5x + 7实验结论：通过多次实验，我们验证了一元多项式的相加运算的正确性。
根据实验结果，我们可以得出以下结论：1. 一元多项式的相加运算是可行的，可以通过将相同次数的项的系数相加得到新的多项式的对应项的系数；2. 一元多项式的相加结果仍然是一元多项式，其次数和各项的系数均可能发生变化；3. 一元多项式的相加运算满足交换律和结合律。
一元多项式相加问题实验报告
一元多项式相加问题实验报告一元多项式相加问题一、问题描述通过键盘输入两个形如P 0 +P 1 X 1 +P 2 X 2 +…+P n X 的多项式，经过程序运后在屏幕上输出它们的相加和。
二、数据结构设计一个一元多项式的每一个子项都由“系数-指数”两部分组成，因此可将其抽象为包含系数coef、指数exp、指针域next 构成的链式线性表。
将两个多项式分别存放在两个线性表中，然后经过相加后将所得多项式存放在一个新的线性表中，但是不用再开辟新的存储空间，只依靠结点的移动来构成新的线性表，期间可以将某些不需要的空间回收。
基于这样的分析，可以采用不带头结点的单链表来表示一个一元多项式。
具体数据类型定义为：struct node {float coef;//系数域int exp;//指数域struct node *next; }; 三、功能函数设计1、输入多项式的系数和指数初始化多项式的功能模块具体函数为node *in_fun() 此函数的处理较为全面，要求用户按照指数递增的顺序和一定的输入格式输入各个系数不为0 的子项，输入一个子项建立一个相关结点，当遇到输入结束标志时停止输入。
关键步骤具体如下：⑴控制用户按照指数递增的顺序输入r=a; while(r!=q-next){if(y=r-exp){cout“请按照指数递增顺序输入,请重新输入“;cinxy;break;}r=r-next;} 从头开始遍历，若遇到目前输入的指数不是最大时，就跳出循环，让用户重新输入。
⑵当输入的系数为零时，不为其分配存储空间存储while(x==0) { cinxy; continue;} 即若系数为0，不再进行动态分配并新建结点，而是重新提取用户输入的下一个子项的系数和指数，利用continue 进入下一次循环。
⑶初始化完成后将最后一个结点的指针域置为空，并返回该新建链表的首地址。
if(q!=NULL)q-next=NULL;return a; ⑷动态分配空间新建结点存储系数和指数的代码如下：p=new node;p-coef=x;p-exp=y;if(a==NULL) a=p;else q-next=p;q=p; 2、多项式显示功能函数由于系数有正有负，故采取如下处理：对于正数，输出时在前面加“+”，头指针除外；对于负数，直接将系数输出即可，即：p=a;while(p){if(p==a)coutp-coef"*x^"p-else if(p-coef0)coutp-coef"*x^"p-else if(p-coef0)cout"+"p-coef"*x^"p-p=p-next;} 输出的多项式的形式形如：P 1 X^1+P 2 X^2+…+P n X^n 3、多项式相加的功能函数函数为：node *plus_fun(node *a,node *b) 此函数根据在 1 中初始化的两个多项式进行相加运算，并存放在以c 为头指针的一个新链表中。
完整word版一元多项式求和实验报告范文_
完整word版一元多项式求和实验报告范文_实验一、线性结构综合应用一、实验题目：顺序表的应用二、实验内容：一元多项式求和。
把任意给定的两个一元多项式P(某),Q(某)输入计算机，计算它们的和并输出计算结果。
三、设计分析：实现要定义的一元多项式应采用链式存储结构。
根据一元多项式相加的运算法则，对于两个多项式中所有指数相同的项，对应系数相加，若其和不为零，则构成新多项式的一项；对于两个多项式中所有指数不同的项，分别复制到新多项式中。
新多项式不必另外生成，而是在原来的两个多项式中摘取结点即可。
采用顺序存储结构存储多项式系数A，使多项式的某些运算变得更简洁。
但在实际使用时，多项式的阶数可能很高，不同的多项式阶数可能相差很大，这使顺序存储结构的最大长度难以确定。
而且，最高次幂与最低次幂项之间缺项很多时，采用顺序存储结构显然十分浪费存储空间，因此，一般情况下多采用链式存储结构来存储高阶多项式。
在用线性链表来存储一个多项式时，多项式中的每个非零项系数对应一个结点，结点由数据元素项和指针组成。
数据元素项中包含系数和指数值，设计中先定义定义数据元素中的数据，其中有指数、系数级指针ne某t等。
并要先构造一元多项式。
在定义输出、删除、合并等模块。
假设指针qa和qb分别指向多项式A和B中当前进行操作的某个结点，比较这个结点的指数项，可能有三种情况：①指针qa->e某p<qb->e某p,则摘取qa指针所指结点插入到和多项式中；②指针qa->e某p<qb->e某p,则摘取qb指针所指结点插入到和多项式中；③指针qa->e某p=qb->e某p,则将系数相加，若和数不为零，则修改qa->coef的值，同时释放qb所指结点，反之，从多项式A的链表中删除相应的结点，并释放指针Pa和Pb所指结点；还有就是在输入是采取的降序输入，也好使两个多项式进行合并。
并输出。
在主函数中将前面也的这些功能都运用起来就可以了四、程序代码：#include<iotream>#defineNULL0uingnamepacetd;typedeftructPolynomial{floatcoef;//系数inte某p;//指数tructPolynomial某ne某t;}Polynomial;Polynomial某CreatPolyn(){//输入m项的系数和指数，建立一元多项式floatmod;intind;Polynomial某H,某p,某;H=newPolynomial;=H;潣瑵请输入多项式的系数和指数：(按0结束输入)<<endl; cin>>mod>>ind;while(mod){p=(Polynomial某)newPolynomial;p->coef=mod;p->e某p=ind;->ne某t=p;=p;cin>>mod>>ind;}->ne某t=NULL;returnH;}voidPrint(Polynomial某pa){//打印输出一元多项式pwhile(pa->ne某t!=NULL){pa=pa->ne某t;cout<<pa->coef<<某某^<<pa->e某p;if(pa->ne某t!=NULL&&pa->ne某t->coef>0) cout<<+;}}voidDelete(Polynomial某pa){//删除一元多项式Polynomial某p,某q;p=pa->ne某t;while(p){q=p;p=p->ne某t;deleteq;}pa->ne某t=NULL;}voidAddPolyn(Polynomial某pa,Polynomial某pb) {//用于链表的合并使用完成多项式的相加运算floatum;Polynomial某p,某q,某pre,某temp;p=pa->ne某t;q=pb->ne某t;pre=pa;while(p!=NULL&&q!=NULL){if(p->e某p>q->e某p){pre->ne某t=p;pre=pre->ne某t;p=p->ne某t;}eleif(p->e某p==q->e某p) {um=p->coef+q->coef;if(um!=0){p->coef=um;pre->ne某t=p;pre=pre->ne某t;p=p->ne某t;temp=q;q=q->ne某t; deletetemp;}ele{temp=p->ne某t;deletep;p=temp;temp=q->ne某t;deleteq;}}ele{pre->ne某t=q;pre=pre->ne某t;q=q->ne某t;}}if(p!=NULL)//将多项式A中剩余的结点加入到和多项式中pre->ne某t=p;elepre->ne某t=q;}intmain(){intc;intt=1;cout<<某某某某某某某某某某某某某某某某某某菜单某某某某某某某某某某某某某某某某某<<endl<<endl;cout<<.创建并显示一元多项式A和B，计算一元多项式A加B并显示和<<endl<<endl;cout<<.退出程序.<<endl;cin>>c;witch(c){cae1:Polynomial某p1,某p2;p1=CreatPolyn();潣瑵一元多项式A是:;Print(p1);cout<<endl;p2=CreatPolyn();潣瑵一元多项式B是:;Print(p2);cout<<endl;AddPolyn(p1,p2);潣瑵一元多项式A加B的和是:;Print(p1);cout<<endl;Delete(p1);break;cae2:t=0;break;}}ytem(paue);return0;}五、测试用例：六、实验总结通过这次实验，对于链表的应用知识有了更加深刻的认识，虽然中间出了很多问题，但是经过调试以后都得以解决。
一元多项式相加实验报告
一元多项式相加实验报告1. 引言本实验旨在研究一元多项式的相加操作。
一元多项式是数学中的一个重要概念，常用于代数运算和函数表达。
相加操作是多项式运算中的基本操作之一，通过对多项式的系数进行相加，可以得到一个新的多项式。
2. 实验目的本实验的主要目的是通过编写代码实现一元多项式的相加操作，并对相加操作进行测试和验证。
具体的实验目标包括： - 设计一种数据结构来表示一元多项式 -实现一元多项式的相加操作 - 编写测试代码，对相加操作进行验证3. 实验方法本实验使用Python编程语言实现一元多项式的相加操作。
具体步骤如下：3.1 设计数据结构首先，我们需要设计一种数据结构来表示一元多项式。
在本实验中，我们选择使用列表来表示一元多项式。
列表的每个元素表示一个项，项由系数和指数组成。
3.2 实现相加操作基于设计的数据结构，我们可以编写代码实现一元多项式的相加操作。
相加操作的基本思路是遍历两个多项式的项，将对应指数的系数相加，并将结果保存到一个新的多项式中。
3.3 编写测试代码为了验证相加操作的准确性，我们需要编写一些测试代码。
测试代码的主要功能是创建一些多项式，并调用相加操作进行计算。
通过比较计算结果和预期结果，可以验证相加操作的正确性。
4. 实验结果经过实验，我们成功地实现了一元多项式的相加操作。
在测试代码中，我们通过比较计算结果和预期结果，验证了相加操作的准确性。
5. 结论与讨论在本实验中，我们通过编写代码实现了一元多项式的相加操作，并进行了测试和验证。
实验结果表明，相加操作的实现是正确的。
然而，相加操作只是一元多项式运算中的基本操作之一。
在实际应用中，还需要考虑其他运算，如相减、乘法和除法等。
此外，实验中使用的数据结构可能还可以进行优化，以提高运算效率。
总的来说，本实验为进一步研究和应用一元多项式提供了基础。
通过进一步的研究和实践，可以深入理解一元多项式的运算规则，并将其应用于更广泛的数学和工程领域。
一元多项式相加问题实验报告
一元多项式相加问题一．问题描述设计算法实现一元多项式的简单运算。
二．数据结构设计分析任意一元多项式的描述方法可知，一个一元多项式的每一个子项都由“系数---指数”两部分组成，所以可以将它抽象成一个由“系数----指数对”构成的线性表。
基于这样的分析，可以采用一个带有头结点的单链表来表示一个一元多项式。
具体数据类型定义为：typedef struct node{float cofe; //系数域int exp; //指数域struct node* next; //指针域指向下一个子项}*polynode,poly;Polynode head_a,head_b,head_c;这三个指针分别作为链表A，B和C的头指针。
三．功能设计1.输入并建立多项式的功能模块此模块要求按照“系数---指数对”的输入格式输入各个子项，输入一个子项，通过遍历链表比较指数的大小，将新结点插在合适的位置，使多项式的指数按递增的顺序存储。
当遇到输入结束标志是停止输入，而转去执行程序下面的部分。
具体函数构造为：polynode creat_polynode(){polynode A ,p,q,s; //建立这种类型的头指针，尾指针，遍历指针和动态指针float a;int b;A=new poly;A->next=NULL;q=A;p=A;cin>>a;cin>>b;while(a!=0||b!=0){s=new poly;s->cofe=a;s->exp=b;while(q->next){if(q->next->exp<b)q=q->next; //遍历链表，若指数大于原链表指数，指针后移一个else{s->next=q->next;q->next=s;break; //若不是，将结点插入指针后面}}if(q->next==NULL){s->next=p->next;p->next=s;p=s; //q遍历到链表尾仍未插入，将结点插入最后，改变尾指针使其指向新结点}q=A; //让q返回头指针处，以便下一次遍历链表cin>>a;cin>>b;}if(p!=NULL)p->next=NULL;return A;}2.多项式相加的功能模块此模块根据在1中建立的两个多项式进行相加运算，并存放在以C为头指针的一个新链表中。
一元多项式实验报告
实验题目一元多项式的加法运算班级：姓名：学号：日期：一、需求分析1.程序的基本功能：(1 ) 输入两个稀疏的一元n次多项式。
(2) 分别输出这两个多项式。
(3) 计算两个多项式的和。
多项式相加的运算规则为：对于两个一元多项式中指数相同的子项，对应的系数相加，若和非灵，将其构成和多项式中的一个子项；对于两个一元多项式中指数不同的子项，则分别复制到和多项式中去。
(4) 输出和多项式。
2.输入输出要求：(1) 输入多项式：按照指数递增的顺序和指定的输入格式输入各个的子项：“系数、指数”（当输入子项个数达到预设数量的时候停止）。
(2) 输出多项式：在文本界面下，采用类似数学表达式的方式输出多项式、例如：多项式A=3+6x3-2x8+12x20，可在屏幕显示为：A=3+6x^3-2x^8+12x^20要求：a.系数值为1的非零项输出形式中省略系数1，如子项“1x8”的输出形式为“x8”，项“-1x3”的输出形式为“x3”。
b.指数为0的输出形式中省略指数部分，如“3x0”的输出形式应为“3”；指数为“1”的项输出时略去“1”。
c.多项式第一项系数为正时，不输出“+”，其他项要输出“+”、“-”符号。
3.测试数据：① (x+3x6-8.6x11)+(6-3x6+21x9)=6+x+21x9-8.6x11② (3x-3-x+4.1x2-1.2x9)+(-3x-3-5.1x2+7.8x12)=-x-x2-1.2x9+7.8x12③ (x+x3）+(-x-x3)=0④ (x+x100)+(x100+x200)=x+2x100+x200⑤ (x+x2+x3)+0= x+x2+x3二、概要设计1.抽象数据类型的定义：对于一元n次多项式P（x,n）=P0+P1x1+P2x2+……+P n x n而言，每一个子项都是由“系数”和“指数”两部分来组成的，因此可将多项式抽象成一个“系数、指数对”构成的线性表，其中多项式的每一个系数非零的子项作为线性表中的一个元素。
数据结构-实验一-一元多项式相加
数据结构实验报告实验一：一元多项式相加姓名：周成学号： 13083511专业：软件工程任课教师：马慧珠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"stdafx.h"#include<stdio.h>#include<stdlib.h>#include<malloc.h>#include<stdio.h>#define NULL 0typedef struct NODE{float coef; //系¦Ì数ºyint expn; //指?数ºystruct 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);/*创ä¡ä建¡§链¢¡ä表À¨ª*/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("请?输º?入¨?系¦Ì数ºy和¨ª指?数ºy : ");scanf("%f%d", ¤t->coef, ¤t->expn);previous->next = current;previous = current;}previous->next = NULL;return head;}/*一°?元a多¨¤项?式º?的Ì?想?加¨®，ê?总Á¨¹体¬?考?虑?，ê?可¨¦分¤?qa的Ì?指?数ºy比À¨¨qb小?，ê?或¨°等̨¨于®¨²pb(如¨?果?系¦Ì数ºy相¨¤加¨®等̨¨于®¨²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; /*系¦Ì数ºy的Ì?和¨ª*/if(sum != 0.0) { /*如¨?果?不?是º?0.0*/qa->coef = sum; /*改?变À?系¦Ì数ºy*/ha = qa;}else{free(Delfirst(ha, qa));}free(Delfirst(hb, qb));qa = ha->next;qb = hb->next; /*qb释º¨ª放¤?后¨®要°a重?新?赋3值¦Ì*/ 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;}/*删¦?除y结¨¢点Ì?q*/NODE *Delfirst(NODE *p1, NODE *q){p1 -> next = q -> next;return (q);}/*插?入¨?结¨¢点Ì?,引°y入¨?结¨¢点Ì?p,可¨¦以°?让¨?p插?入¨?到Ì?p2和¨ªp1之?间?*/ void InsertBefore(NODE *p1, NODE *p2){NODE *p;p = p1->next;p1->next = p2;p2->next = p;}/*打䨰印®?,为a了¢?美¨¤观?程¨¬序¨°分¤?开a打䨰印®?*/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);//system（ꡧ"pause");}int main(){NODE *head1, *head2, *head3;int n1, n2;printf("请?输º?入¨?你?需¨¨要°a的Ì?多¨¤项?式º?的Ì?项?数ºy n1 : "); scanf("%d", &n1);head1 = Creat(n1);printf("第̨²一°?个?多¨¤项?式º?的Ì?显?示º? : \n");print(head1);printf("\n请?输º?入¨?你?需¨¨要°a的Ì?多¨¤项?式º?的Ì?项?数ºy n2 : "); scanf("%d", &n2);head2 = Creat(n2);printf("\n第̨²二t个?多¨¤项?式º?的Ì?显?示º? : \n");print(head2);head3 = AddPolyn(head1, head2);printf("\n合?并¡é后¨®的Ì?多¨¤项?式º?的Ì?显?示º? : \n");print(head3);printf("\n");}运行结果：实验数据1如图：输入一个四次二项式X^3+2X^4，一个五次二项式X^4+2X^5，输出如图：实验数据2如图：输入一个五次四项式X^2+X^3+X^4+X^5，还有一个五次五项式1+X+X^3+2X^4+2X^5输出如图所示实验数据3如图：输入一个七次三项式1+2x^5+3X^7，还有一个五次四项式1+2X^2+3X^4+4X^5,输出如图：6.实验总结本来我对编程很没有信心，做这样一个课程设计感觉有点吃力，虽然有些人觉得很简单，但是我还是坚持做下来了，我不断的看书，翻阅资料，询问同学，上网搜索，总算有模有样地把这个程序编的能运行了。
实验报告示例(实验一_一元多项式相加)
实验一一元多项式相加（实验报告示例）一、需求分析1、本演示程序中，多项式的系数限定为整数，多项式的长度由用户预先输入，利用链表实现队列的构造。
每次输入一项的系数和指数，可以输出构造的一元多项式。
2、演示程序以用户和计算机的对话方式执行，即在计算机终站上显示“提示信息”之后，由用户在键盘上输入演示程序中规定的运行命令；最后根据相应的输入数据（滤去输入中的非法字符）建立的多项式以及多项式相加的运行结果在屏幕上显示。
多项式显示的格式为：c1x^e1+c2x^e2+…+cnx^en3、程序执行的步骤包括：1）输入多项式的项数及系数，建立多项式；2）实现多项式的相加；3）输出相加结果4、测试数据：(1)(2x+5x^8-3x^11)+(7-5x^8+11x^9)(2)(3-x+4^x2-2x^9)+(-6^x+5x^2+7x^15)(3)(x+x2+x3)+0(4)(x+x^3)+(3-x)二、概要设计为了实现上述程序功能，根据一元多项式的特点，可以构造链式存储的线性表存放一元多项式各式的信息。
1、主要思想：根据多项式的结构特点，利用线性链表来实现多项式相加，结点中存放各项的系数和指数，在默认用户按升幂次序输入多项式的各项后，构造相应的多项式。
从头扫描两个多项式，用两个指针分别指示两个多项式的当前项，根据多项式相加的规则，对于指数相同的项，将其对应系数相加，若和不为零，则构成“和多项式”中的一项；对于两个多项式中指数不同的项，可直接复制到和多项式中，并按从小到大的升幂排列2、本程序包含四个模块1）主函数void main(){初始化；建立两个链表A和B；输出建立的链表；A与B的相加，并输出}2）建立多项式函数createpoly()——根据用户输入的项数，提示用户输入系数和指数，建立链式存储的一元多项式3）输出多项式函数outpoly()——根据日常的阅读习惯将多项式按格式输出4）多项式相加函数addpoly()——按照多项式相加的法则实现两个多项式的相加各模块之间的调用关系及接口如下：三、详细设计1、元素类型、结点类型和指针类型：typedef int ElemType;typedef struct mulpoly{ElemType coef;ElemType exp;struct mulpoly * next;};2、主函数和其他函数清单struct mulpoly * createpoly(int n) //根据用户输入的项数n，提示用户输入n组系数和指数，并构建链式线性表存储多项式信息{}void outpoly(struct mulpoly * head)// 将以head为头指针的链表按多项式的格式输出{}struct mulpoly * addpoly(struct mulpoly * ha,struct mulpoly *hb)// 将以ha,hb为头指针的两个链式按多项式相加的法则进行合并，放在hc中，并将hc返回void main(){}四、调试分析1、在建立链表和多项式相加时，新生成链表的头指针做为参数传递时，曾忽略了参数的标识“&”，致使建立链表失败。
数据结构一元多项式求和实验报告
xx大学xxx学院算法与数据结构试验报告设计名称：算法与数据结构设计题目：链表的应用学生学号：xx专业班级：xx学生姓名：xx学生成绩：指导教师（职称）：课题工作时间：2012年4月10日说明：实验课程类别：课程内实验实验课程性质：必修适用专业、年级：2010级计算机工程、计算机网络开课院、系：计算机科学与工程学院计算机工程教研室学时：18编写依据：《算法与数据结构》实验教学大纲修订时间：2012年2月《算法与数据结构》课程实验指导书（以下简称：指导书）是针对计算机学院所开设的对应课程的上机实验而编写的教学文件，供学生上机实验时使用。
上机的工作环境要求：Windows 2000或以上操作系统、VC++ 6.0或者其它高级程序设计语言。
学生应按指导教师的要求独立完成实验，并按要求撰写实验报告。
每一个实验，编程上机调试并且提交电子文档实验报告，以学号姓名作为文件名上传。
报告内容至少包含如下内容：1、学生基本情况：专业班级、学号、姓名2、实验题目、实验内容3、设计分析4、源程序代码5、测试用例（尽量覆盖所有分支）6、实验总结一．实验内容与学时分配一、试验课题链表的应用二、试验内容一元多项式求和。
把任意给定的两个一元多项式P(x),Q(x)输入计算机，计算它们的和并输出计算结果。
三、试验分析系数指数一元多项式链表的结点结构四、源程序代码#include<stdio.h> #include<stdlib.h> /*链表数据类型定义*/ typedef struct LNode {int x,z;struct LNode *next; }LinkList;void OutLinkList(LinkList *L); /*输出函数*/void PutLinkList(LinkList *&L,int n); /*输入函数*/LinkList *AddLinkList(LinkList *a,LinkList *b); /*求和函数*/ void OutXLinkList(LinkList *L); void OutZLinkList(LinkList *L); void main() {int n,m;LinkList *a,*b,*c;printf("\t\t\t本程序可以完成两个一元多项式的加法运算。
一元多项式相加 数据结构实验报告
南昌航空大学实验报告课程名称：数据结构实验名称：实验二线性表的链式存储结构班级：080611 学生姓名：学号：08指导教师评定：签名:题目：设计并实现以下算法：给出用单链表存储多项式的结构，利用后接法生成多项式的单链表结构，实现两个多项式相加的运算，并就地逆置相加后的多项式链式。
一、需求分析1.用户可以根据自己的需求分别输入两个一元多项式，并且能够实现输入的一元多项式的显示。
2.能够完成两个一元多项式的相加功能，而且还能显示相加后的逆置的一元多项式。
3.程序执行的命令包括：（1）构造链表A （2）构造链表B （3）两个链表的相加（4）求链表的长度（5）打印（显示）已有的链表（6）将已相加的链表进行逆序排列二、概要设计⒈为实现上述算法，需要线性表的抽象数据类型：ADT Polynomial {数据对象：D={a i:|a i∈TermSet,i=1…n,n≥0TermSet 中的每个元素包含一个表示系数的实数和表示指数的整数} 数据关系：R1={<a i-1,a i>|a i-1,a i∈D,且a i-1中的指数值< a i中的指数值i=2,…n≥0}基本操作:initlink(& L)操作结果：构造一个空的链表L。
Creatlink(&L,n)操作结果：输入n项的系数和指数，建立一个非空的一元多项式L。
LinkLength(L)初始条件：链表L已经存在。
操作结果：返回一元多项式L中的项数。
Displaylink（L）初始条件：链表L已经存在。
操作结果：打印输出一元多项式L。
Addpolyn(A,B,&C)初始条件：一元多项式A和B已存在。
操作结果：完成多项式相加运算，即：C=A+B，并且带回C。
subtracypolyn(&La,&Lb,)初始条件：一元多项式La和Lb已存在。
操作结果：完成多项式的相减运算La=La+Lb，并且销毁多项式Lb。
一元多项式相加实验报告
一元多项式相加实验报告一元多项式相加实验报告引言：一元多项式是高中数学中的重要概念，它在代数运算中具有广泛的应用。
本次实验旨在通过实际操作，探究一元多项式的相加规律，并验证其正确性。
实验步骤：1. 准备工作：将实验所需材料准备齐全，包括纸张、铅笔、计算器等。
2. 设定实验目标：选择两个一元多项式进行相加操作，并记录相加过程。
3. 编写一元多项式：根据实验要求，编写两个一元多项式，如P(x)和Q(x)。
4. 相加操作：按照一元多项式相加的规则，对P(x)和Q(x)进行相加操作。
5. 记录结果：将相加的结果记录下来，并进行必要的化简。
6. 分析结果：分析相加结果的特点和规律，并与理论知识进行对比。
7. 总结实验：总结实验过程中的收获和体会，并提出相加操作的注意事项。
实验结果：通过实验操作，我们得到了两个一元多项式相加的结果。
例如，设定P(x) =2x^3 + 5x^2 - 3x + 1，Q(x) = -x^3 + 4x^2 + 2x - 2，经过相加操作后，得到R(x) = x^3 + 9x^2 - x - 1。
可以看出，相加结果的次数和系数分别是两个一元多项式次数和系数的相加。
结果分析：从实验结果中可以发现，一元多项式相加的规律是将相同次数的项的系数相加，并保留该次数的项。
这与我们在学习一元多项式时所掌握的知识是一致的。
通过实验操作，我们验证了一元多项式相加的正确性。
实验总结：本次实验通过实际操作验证了一元多项式相加的规律，加深了对一元多项式的理解。
在实验过程中，我们还发现了一些注意事项。
首先，要注意相加过程中的计算准确性，尤其是在涉及到多项式次数较高时。
其次，要注意对相加结果进行化简，以便更好地观察和分析。
最后，实验过程中要保持仔细和认真，确保实验结果的可靠性。
结论：通过本次实验，我们验证了一元多项式相加的规律，并得出了相加结果的特点和规律。
一元多项式相加是代数运算中的重要内容，掌握相加规律对于深入理解和应用一元多项式具有重要意义。
一元多项式的表示及相加实验报告
显示多项式中用swichcase语句表示当系数为01或者更多的情况剩下的是主函数的实现调用linklist构建l1l2两个多项式实现相加相加时分系数相等l1系数大于l2l1系数小于l2三种情况l2入到l1中则要考虑l1l2的长度当l1或l2为空时则直接插入另一链表
测试过程： （实验中出现的问题、错误、解决方法） 刚开始逻辑出现问题，运行时，总是显示不出来， 然后问同学才知道在 showList 这个成员函数中 Node *curr = this->head->next; 没有具体说明 curr 该怎样用和 public 中没声明 Node* getHead(){return head;} int deleteNode(Node *cur);是后面的 main 函数 wufayunxing
一元多项式的表示及相加 验证性 实验时间 2011.09.29
实验环境 C++给认真掌握 签名任亚平 2011-10-13 月 日 年
WindowsXP 系统 DEV C+&了解线性表的各种存储结构。 2.熟练掌握在各种存储结构上进行插入、删除等操作的算法。
3.通过线性表结构解决现实中的一些问题。
实验内容：
一元多项式的表示及相加。
while(p1!=0&&p2!=0){ if(p1->zhishu=p2->zhishu){ p1->xishu=p1->xishu+p2->xishu; if(p1->xishu=p2->xishu){ Node *c1=p1; Node *c2=p2; p1 = p1->next; p2 = p2->next; l1.DeleteList(pre1,c1); l2.DeleteList(pre2,c2); } else{ Node *c2=p2; pre1=pre1->next; p1 = p1->next; p2 = p2->next; l2.DeleteList(pre2,p2); } } if(p1->xishu < p2->xishu){ pre1=pre1->next; p1=p1->next; } if(p1->xishu > p2->xishu){ Node *temp = p2->next; l1.InsertList(pre1,p2); pre1 = pre1->next; p2 = temp; } } if(p1 == NULL && p2!=NULL){ pre1->next = p2; }
一元多项式实验报告
实验二一元多项式相加问题本实验的目的是进一步熟练掌握应用链表处理实际问题的能力。
一、【问题描述】一元多项式相加是通过键盘输入两个形如P0+P1X1+P2X2+…+P n X n 的多项式，经过程序运算后在屏幕上输出他们的相加和。
二、【数据结构设计】分析任意一元多项式的描述方法可知，一个一元多项式的每一个子项都是有“系数－指数”两部分来组成的，所以将它可以抽象成一个由“系数－指数对”构成的线性表，由于对多项式中系数为0的子项可以不记录它的指数值，对于这样的情况就不再付出存储空间来存放它了。
基于这样的分析，我们可以采用一个带有头结点的单链表来表示一个一元多项式。
具体数据类型定义为：typedef struct Polynomial{Float coe; //系数int exp; //指数struct Polynomial *next;}*Polyn,Polynomial; 这三个指针分别作为链表A、B、C的头指针。
三、【功能（函数）设计】1、输入并建立多项式的功能模块：此模块要求按照指数递增的顺序和一定的输入格式输入各个系数不为0的子项的“系数－指数对”，输入一个子项建立一个相关结点，当遇到输入结束标志的时候就停止输入，而转去执行程序下面的部分。
2、多项式相加的功能模块此模块根据在1中建立的两个多项式进行相加的运算，并存放在以C为头指针的一个新链表中。
可以采用如下的方法进行设计：设指针p、q、r分别指向描述多项式的链表A、B、C头部，p指针按照A中结点顺序一个一个的移动，每移动一个结点，就通过q指针的移动来寻找B中是否有与p→exp相同的，（1）如果有，在C中合适的位置（注意多项式存储是按照指数递增有序的）建立新结点，并做如下赋值操作：r→coef=p→coef＋q→coef;r→exp=p→exp;p→flag=1;q→flag=1; /*标志子项已参与过运算*/p=p→next;q=head_b;（2）如果没有，在C中合适的位置（注意多项式存储是按照指数递增有序的）建立新结点，并做如下赋值操作：r→coef=p→coef;r→exp=p→exp;p=p→next;q=head_b;注意：当A、B中可以相加的两项的系数和为0的时候，在C中就不用分配新的空间来进行存储了。
C++一元多项式合并实验报告
实验二一元多项式相加问题本实验的目的是进一步熟练掌握应用链表处理实际问题的能力。
一、问题描述一元多项式相加是通过键盘输入两个形如P0+P1X1+P2X2+···+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=1ex=2ce=0ex=0 //输入结束标志input ce & ex and end with 0：ce=2ex=2ce=0ex=0 //输入结束标志输入后程序将分别建立两个链表来描述两个一元多项式：A=X^2B=2X^2这两个多项式的相加的结果应该为：C=3X^22、多项式相加的功能模块此模块根据在1中建立的两个多项式进行相加运算，并存放在以C为头指针的一个新建表中。
可以采用以下方法进行设计：开始时a，b分别指向A,B的开头，如果ab不为空，进行判断：如果a所指的结点的指数和b所指的结点的指数相同，将它们的系数相加做成C式中的一项，如果不一样则将小的一项加到C中。
一元多项式相加的实验报告
《数据结构》实验报告1、实验名称:实现一元多项式的加法2、实验日期: 2011-3-73、基本要求：1）编程实现一元多项式的加法；2）设计一个测试主函数。
4、实验目的：通过实验使学生掌握链表的最基本和最主要的操作：插入和删除操作。
5、测试数据：随意输入两个一元多项式的系数和指数：第一个：系数：4 8 6 7；指数：2 3 4 5第二个：系数：5 9 3 8；指数：1 3 5 6两式相加后输出结果。
6、算法思想或算法步骤:1）用尾插入法创建单链表（PLoy *create_Ploy_LinkList(void)）2）输出单链表中所有结点的值，得到一元多项式（void output_Ploy_LinkList(PLoy *L, char ch)）3）进行多项式的相加，采用链式存储表示加法，根据结点类型定义，若指数不同，则进行链表的合并；若指数相同，则进行系数相加；若和为0，则去掉结点；若和不为0，则修改结点的系数域。
（PLoy *add_ploy(PLoy *La, PLoy *Lb)）7、模块划分：1）头文件stdiob.h。
头文件stdiob.h中包括：结点结构体定义、一元多项式的系数和指数的输入、一元多项式的输出以及两式相加输出结果的操作等；2）实现文件yydxsxj.cpp。
包含主函数int main()，其功能是测试所设计的一元多项式加法的正确性。
8、数据结构：链表中的结点的结构体定义如下：typedef struct Node{float coef; /*系数部分*/int expn; /*指数部分*/struct Node *next ;} PloyNode;9、源程序：源程序存放在两个文件中，即头文件stdiob.h和实现文件yydxsxj.cpp。
//头文件stdiob.htypedef struct Node{float coef; /*系数部分*/int expn; /*指数部分*/struct Node *next ;} PloyNode;PloyNode *create_Ploy_LinkList(void){/* 尾插入法创建单链表,链表的头结点head作为返回值 */ float coef ; int expn ;PloyNode *head, *p, *q;head=p=(PloyNode *)malloc(sizeof(PloyNode));p->next=NULL; /* 创建单链表的表头结点head */while (1){printf("\n请输入一元多项式的系数(0表示结束): ") ;scanf("%f",&coef);if (coef==0) break ;else{printf("\n请输入一元多项式的指数: ") ;scanf("%d",&expn);q=(PloyNode *)malloc(sizeof(PloyNode));q->coef=coef ; /* 指数部分赋值 */q->expn=expn ; /* 系数部分赋值 */q->next=p->next; p->next=q; p=q ;/* 钩链，新创建的结点总是作为最后一个结点 */ }}return(head);}void output_Ploy_LinkList(PloyNode *L, char ch)/* 输出以L为头结点的单链表中所有结点的值 */ {PloyNode *p;p=L->next; /* 使p指向第一个结点 */if (p==NULL) printf("\n此多项式为空!!\n\n") ;else{printf("f(x)= \n",ch) ;while (p!=NULL){if (p->coef>0)printf("%+g",p->coef) ;else printf("%g",p->coef) ;if (p->expn!=0){printf("X^") ;printf("%d",p->expn);}p=p->next;}} /* 移动指针p */printf("\n\n") ;}PloyNode *add_Ploy(PloyNode *La, PloyNode *Lb){PloyNode *Lc , *pc , *pa , *pb ,*ptr ; float x ;Lc=pc=La ; pa=La->next ; pb=Lb->next ;if(pa==NULL&&pb==NULL)printf("两个式子之和也为空项");while (pa!=NULL&&pb!=NULL){if (pa->expn< pb->expn){pc->next=pa ; pc=pa ; pa=pa->next ; } else{if (pa->expn>pb->expn){ pc->next=pb ; pc=pb ; pb=pb->next ; }else{x=pa->coef+pb->coef ;if (x==0){ ptr=pa ; pa=pa->next ;ptr=pb ; pb=pb->next ;}else{ pc->next=pa ; pa->coef=x ;pc=pa ; pa=pa->next ;ptr=pb ; pb=pb->next ;}}}}if (pa==NULL) pc->next=pb ;else pc->next=pa ;return (Lc) ;}//实现文件yydxsxj.cpp#include<iostream>#include<malloc.h>#include"stdiob.h"using namespace std;int main(){PloyNode * pa,* pb;char pc,pd;cout<<"请输入第一个多项式(按指数递增顺序输入):"<<endl; pa=create_Ploy_LinkList();output_Ploy_LinkList(pa,pc);cout<<"请输入第二个多项式(按指数递增顺序输入):"<<endl; pb=create_Ploy_LinkList();output_Ploy_LinkList(pb,pd);cout<<"多项式相加结果是:"<<endl;add_Ploy(pa,pb);output_Ploy_LinkList(pa,pc);return 0;}10、测试情况：1）程序运行输出为：第一个多项式为：f(x)=+4x^2+8x^3+6x^4+7x^5第二个多项式为：f(x)=+5x^1+9x^3+3x^5+8x^6两式相加之和为：f(x)=+5x^1+4x^2+17x^3+6x^410x^5+8x^6 2）测试结果分析：程序运行结果和预测的完全相同，说明所设计的一元多项式的加法是正确的。
一元多项式相加
实验报告：一元多项式相加院系：数学系专业：数学与应用数学学号：2010114036姓名：郭奇瑞一、实验名称：一元多项式相加二、实验日期：2012年10月10日三、实验要求：编程实现一元多项式的相加四、实验目的：通过实验掌握链表的最基本和最主要的操作：插入和删除操作五、程序代码：#include<stdio.h>#include<malloc.h>typedef struct node{int exp,coef;struct node *link;}PolyNode,*Polylinklist;Polylinklist Creat(int n){Polylinklist p,r=NULL,list=NULL;int coef,exp,i;for(i=1;i<=n;i++){scanf("%d %d",&coef,&exp);p=(Polylinklist)malloc(sizeof(PolyNode));p->coef=coef;p->exp=exp;p->link=NULL;if(list==NULL)list=p;elser->link=p;r=p;}return(list);}Polylinklist ATTACH(int coef,int exp,Polylinklist r) {Polylinklist w;w=(Polylinklist)malloc(sizeof(PolyNode));w->exp=exp;w->coef=coef;r->link=w;return w;}Polylinklist PADD(Polylinklist a,Polylinklist b){Polylinklist c;Polylinklist r,p=a,q=b;int x;c=(Polylinklist)malloc(sizeof(PolyNode)); r=c;while(p!=NULL&&q!=NULL)if(p->exp==q->exp){x=p->coef+q->coef;if(x!=0)r=ATTACH(x,q->exp,r);p=p->link;q=q->link;}else if(p->exp<q->exp){r=ATTACH(q->coef,q->exp,r);q=q->link;}else {r=ATTACH(p->coef,p->exp,r);p=p->link;}while(p!=NULL){r=ATTACH(p->coef,p->exp,r); p=p->link;}while(q!=NULL){r=ATTACH(q->coef,q->exp,r); q=q->link;}r->link=NULL;p=c;c=c->link;free(p);return c;}void Result(Polylinklist w){Polylinklist m;m=w;while(w==NULL){printf("0");break;} while(w!=NULL){if(w->exp==0)printf("%d",w->coef);elseprintf("%d*x^%d",w->coef,w->exp);w=w->link;while(w!=NULL){if(w->coef>0){if(w->exp==0)printf("+%d",w->coef);elseprintf("+%d*x^%d",w->coef,w->exp);}else{if(w->exp!=0)printf("%d*x^%d",w->coef,w->exp);elseprintf("%d",w->coef);}w=w->link;}}}void main(){Polylinklist c=NULL;PolyNode *Lengtha;PolyNode *Lengthb;int a1,b1;printf("请输入多项式a的长度:");scanf("%d",&a1);Lengtha=Creat(a1);printf(" a=");Result(Lengtha);printf("\n");printf("请输入多项式b的长度:");scanf("%d",&b1);Lengthb=Creat(b1);printf(" b=");Result(Lengthb);printf("\n");c=PADD(Lengtha,Lengthb);printf("\n");printf(" c=");Result(c);printf("\n");}六、调试分析：采用单链表形式按照指数降幂排列并输出一元多项式，在相加的过程中，指数相同的多项式系数相加，否则就把大的项直接写入，从而完成两个多项式相加，将新得到的单节链表输出，该算法的时间复杂度为两个多项式之和。
一元多项式相加
电子信息工程学系实验报告课程名称：数据结构Array实验项目名称：一元多项式相加实验时间：班级：姓名：学号：实验目的:1.了解线性表的链式存储结构，熟练掌握链表。
2.了解作为链表的多项式存贮方式。
3.熟悉掌握多项式加法的算法。
实验环境:一人一台微机， Windows XP / Wintc。
实验内容及过程:建立两个单链表p和q，以p为循环条件，到p 为空时跳出循环。
在循环中p中的指数跟q中的每个指数比较，如果指数相等，则把p的系数跟q的系数相加放入q中,如果不等，把该p结点接入q链表的尾部，p指向下一结点，继续循环直至跳出。
产生新的q链表，里包括原两链表的信息。
程序：#include<stdio.h>#include<alloc.h>#include<string.h>#include<stdlib.h>typedef struct node {int coef;int exp;struct node *link;}PNode,*PLinkList;PLinkList A TTACH(int co,int ex,PLinkList r)/*课本的是按幂指数升高来生成的多项式*/{PLinkList w;w=(PLinkList)malloc(sizeof(PNode));w->exp=ex;w->coef=co;r->link=w;return w;}PLinkList PADD(PLinkList A,PLinkList B){PLinkList C;PLinkList r,p=A,q=B;int x;C=(PLinkList)malloc(sizeof(PNode));r=C;while(p!=NULL&&q!=NULL)if(p->exp==q->exp){x=p->coef+q->coef;if(x!=0)r=A TTACH(x,p->exp,r);p=p->link;q=q->link;}else if(p->exp>q->exp) /*这就是按幂指数升高的原因*/{r=ATTACH(q->coef,q->exp,r);q=q->link;}else{r=ATTACH(p->coef,p->exp,r);p=p->link;}while(p!=NULL) {r=ATTACH(p->coef,p->exp,r);p=p->link;}while(q!=NULL){r=ATTACH(q->coef,q->exp,r);q=q->link;}r->link=NULL;r=C;C=C->link;free(p);return C;}void main(){int i,m,n,;PLinkList o,o1,o2,r1,q1,s,t,f,c;printf("please input s and t de xiangshu(two numbers):"); /*输入两多项式s和t各有多少项*/ scanf("%d %d",&m,&n);o1=(PLinkList)malloc(sizeof(PNode));r1=o1;for(i=0;i<m;i++){ o=(PLinkList)malloc(sizeof(PNode));printf("please out:%d",i+1);printf("\n");scanf("%d%d",&o->coef,&o->exp);r1->link=o; r1=o;}s=o1;s=s->link;free(o1); /*这是生成多项式S*/o2=(PLinkList)malloc(sizeof(PNode));f=o2;for(i=0;i<n;i++){ q1=(PLinkList)malloc(sizeof(PNode));printf("please out:%d",i+1);printf("\n");scanf("%d %d",&q1->coef,&q1->exp);f->link=q1; f=q1;}t=o2;t=t->link;free(o2); /*这是生成多项式T*/c= PADD( s,t) ;while(c!=NULL){printf("%dX%d ",c->coef,c->exp);c=c->link;}getch();}要求测试的数据有，课本的A(X)=3X14 + 2X8 + 1 ; B(X)=8X14 - 3X10 – 2X8 + 4X6 -6; C(X)=11X4 – 3X10 + 4X6 – 5--→----→→-→-→-→-→--→--→预习报告要求的：2X + 3X2 + X7 – 5X90; 4X＋Ｘ３-→--→--→--→相加结果：→-→-→-→实验结果及分析：这是课本的例题。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
[计算机]一元多项式相加完整实验报告一元多项式的相加一实验内容根据所学的数据结构中线性结构(线性表)的逻辑特性和物理特性及相关算法，应用于求解一个具体的实际问题----------两个多项式相加二需求分析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输出已输出的多项式否是否输入正确合并同类项结束四详细设计根据一元多项式相加的运算规则:对于两个一元多项式中所有指数相同的项，对应系数相加，若其和不为零，则构成“和多项式”中的一项，对于两个一元多项式中所有指数不相同的项，则分别复抄到“和多项式”中去。
核心算法PolyAdd是把分别由pa和pb所指的两个多项式相加，结果为pa所指的多项式。
运算规则如下:相加时，首先设两个指针变量qa和qb分别从多项式的首项开始扫描(见图2-5-1)，比较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指向的链表即为两个多项式之和。
五源程序代码#include <stdio.h>#include <malloc.h>#include <stdlib.h>#define NULL 0typedef 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;}/*删除结点q*/NODE *Delfirst(NODE *p1, NODE *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);}六调试分析如图第八行，如果直接一次性输完两项的次数和项数，还是会显示“请输入系数和指数”纠正办法:输入时输完一项的系数和指数，按回车后继续输入。
七测试结果输入一个二次三项式X^2+3X^+1，一个三次四项式2X^3+4X^2+X+1 输出如图:八心得体会首先，我的C++学的不是很好，因此做这样一个课程设计感觉有点吃力，还好我不断的看书，翻阅资料，询问同学，上网搜索，总算像模像样地把这个程序编的能运行了。
功夫不负有心人。
其次，这次编程是我更多地理解掌握了线性链表的逻辑机构和物理特性。
对大一时学过的知识有了很好的巩固。
困难还是很多的，比如初次运行的时候，好几十个错误，当时真的感到非常崩溃。
幸亏我没有放弃，才最终完成。
长舒一口气。
最后，通过这次编程，不仅仅考察了我对知识的掌握，更重要的是锻炼了我的思维能力和耐心，在最困难的时候没有放弃，今天才能如此舒心。