实验一多项式求和

合集下载

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

ｓｔｒuct nodｅ
{
ﻩ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ｅ（ｑ)

一元多项式求和

一元多项式求和——链表编程一．实验名称：一元多项式求和——链表编程。

二．实验环境：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 =…（m<n ）。

其和多项式可表示为00111(,,,)m m m n R p q p p q q +=+++q ,?,?,q 。

2.一元多项式的链式存储：1）链式存储的结点结构：一元多项式中每一个非零项都由两部分构成——指数项和系数项。

下面为结点结构的定义：struct polynode{ int coef;int exp;polynode *next;} polynode, *polylist;2)建立一元多项式链式存储的算法：【算法思想】运用尾插法建立一元多项式的链表。

以输入系数0为结束标准，并约定建立一元多项式时，总是按指数从小到大的顺序排列。

算法如下：polylist polycreate(){ polynode *head,*rear,*s;int c,e;head=(polynode *)malloc(sizeof(polynode));rear=head;scanf("%d,%d",&c,&e);while(c!=0){ s=(polynode *)malloc(sizeof(polynode));s->codf=c;s->exp=e;rear->next=s;rear=s;scanf("%d,%d"&c,&e);}rear->next=NULL;return(head);}3.多项式相加的运算规则：【算法思想】以单链表polya和polyb分别表示两个一元多项式A和B，A+B，求和运算，就等同于单链表的插入问题。

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

一元多项式的相加实验报告一元多项式的相加实验报告引言：一元多项式是数学中常见的概念，它由一个变量和一系列常数乘积的和组成。

在本实验中，我们将研究一元多项式的相加运算，并通过实验验证相加运算的性质和规律。

实验目的：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. 一元多项式的相加运算满足交换律和结合律。

完整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;}五、测试用例：六、实验总结通过这次实验，对于链表的应用知识有了更加深刻的认识，虽然中间出了很多问题，但是经过调试以后都得以解决。

算法与数据结构实验报告实验一完成多项式的相加运算

实验一：完成多项式的相加运算（验证性、4学时）一、实验目的完成多项式的相加、相乘运算。

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

利用单链表实现。

三、算法描述及实验步骤1描述1、创建两个单链表A、B，分别调用CreatePolyn（）；2、输出多项式，分别调用PrintPolyn（）；3、多项式相加运算AddPolyn（）。

2算法流程图4 65inputA-B inputA-B inputA-B end3代码(注释)#include<stdio.h>#include<malloc.h>#include<math.h>typedef struct Polynomial{float coef;//系数变量int exp;//指数变量struct Polynomial *next;//定义next指针}*Polyn,Polynomial; //Polyn为结点指针类型void Insert(Polyn p,Polyn h) //插入新的结点p{if(p->coef==0) free(p); //系数为0的话释放结点else{Polyn q1,q2;q1=h;q2=h->next;while(q2&&p->exp<q2->exp) //查找插入位置{q1=q2;q2=q2->next;}if(q2&&p->exp==q2->exp) //将指数相同相合并{q2->coef+=p->coef;free(p);if(!q2->coef) //系数为0的话释放结点{q1->next=q2->next;free(q2);}}else //指数为新时将结点插入{p->next=q2;q1->next=p;}}}//Insertint f(float x)//判断输入是否为整形{float a;a=x-(long int)x;if(a==0&&x==fabs(x))return 1;elsereturn 0;}Polyn CreatePolyn(Polyn head,int m) //建立一个头指针为head、项数为m的一元多项式{int i;Polyn p;p=head=(Polyn)malloc(sizeof(struct Polynomial));head->next=NULL;for(i=0;i<m;i++){p=(Polyn)malloc(sizeof(struct Polynomial));//建立新结点以接收数据printf("please input NO.%d coef and exp:",i+1);scanf("%f %d",&p->coef,&p->exp);while(!f(p->coef)&&!f(p->exp)){printf("输入有错，请重新输入: ");scanf("%f %d",&p->coef,&p->exp);}Insert(p,head); //调用Insert函数插入结点}return head;}//CreatePolynvoid DestroyPolyn(Polyn p) //销毁多项式p{Polyn q1,q2;q1=p->next;q2=q1->next;while(q1->next){free(q1);q1=q2;//指针后移q2=q2->next;}}void PrintPolyn(Polyn P)//输出多项式{Polyn q=P->next;int flag=1; //项数计数器if(!q) //若多项式为空，输出0{putchar('0');printf("\n");return;}while (q){if(q->coef>0&&flag!=1) putchar('+'); //系数大于0且不是第一项if(q->coef!=1&&q->coef!=-1) //系数非1或-1的普通情况{printf("%g",q->coef);if(q->exp==1) putchar('X');else if(q->exp) printf("X^%d",q->exp);}else{if(q->coef==1){if(!q->exp) putchar('1');else if(q->exp==1) putchar('X');else printf("X^%d",q->exp);}if(q->coef==-1){if(!q->exp) printf("-1");else if(q->exp==1) printf("-X");else printf("-X^%d",q->exp);}}q=q->next;flag++;}//whileprintf("\n");}//PrintPolynint compare(Polyn a,Polyn b){if(a&&b){if(!b||a->exp>b->exp) return 1;else if(!a||a->exp<b->exp) return -1;else return 0;}else if(!a&&b) return -1;//A多项式已空，但B多项式非空else return 1;//B多项式已空，但A多项式非空}//comparePolyn AddPolyn(Polyn pa,Polyn pb)//求解并建立多项式A+B，返回其头指针{Polyn qa=pa->next;Polyn qb=pb->next;Polyn headc,hc,qc;hc=(Polyn)malloc(sizeof(struct Polynomial)); //建立头结点hc->next=NULL;headc=hc;while(qa||qb){qc=(Polyn)malloc(sizeof(struct Polynomial));switch(compare(qa,qb)) //功能选择{ case 1:{qc->coef=qa->coef;qc->exp=qa->exp;qa=qa->next;break;}case 0:{qc->coef=qa->coef+qb->coef;qc->exp=qa->exp;qa=qa->next;qb=qb->next;break;}case -1:{qc->coef=qb->coef;qc->exp=qb->exp;qb=qb->next;break;}}//switchif(qc->coef!=0){qc->next=hc->next;hc->next=qc;hc=qc;}else free(qc);//当相加系数为0时，释放该结点}//whilereturn headc;}//AddPolynPolyn SubtractPolyn(Polyn pa,Polyn pb){//求解并建立多项式A-B，返回其头指针Polyn h=pb;Polyn p=pb->next;Polyn pd;while(p){ //将pb的系数取反p->coef*=-1;p=p->next;}pd=AddPolyn(pa,h);for(p=h->next;p;p=p->next) //恢复pb的系数p->coef*=-1;return pd;}//SubtractPolynPolyn MultiplyPolyn(Polyn pa,Polyn pb){//求解并建立多项式A*B，返回其头指针Polyn hf,pf;Polyn qa=pa->next;Polyn qb=pb->next;hf=(Polyn)malloc(sizeof(struct Polynomial));//建立头结点hf->next=NULL;for(;qa;qa=qa->next){for(qb=pb->next;qb;qb=qb->next){pf=(Polyn)malloc(sizeof(struct Polynomial));pf->coef=qa->coef*qb->coef;pf->exp=qa->exp+qb->exp;Insert(pf,hf);//调用Insert函数以合并指数相同的项}}return hf;}//MultiplyPolynvoid DevicePolyn(Polyn pa,Polyn pb){//求解并建立多项式A/B，返回其头指针Polyn hf,pf,af,temp1,temp2,q;Polyn qa=pa->next;Polyn qb=pb->next;hf=(Polyn)malloc(sizeof(struct Polynomial));//建立头结点,存储商hf->next=NULL;pf=(Polyn)malloc(sizeof(struct Polynomial));//建立头结点，存储余数pf->next=NULL;temp1=(Polyn)malloc(sizeof(struct Polynomial));temp1->next=NULL;temp2=(Polyn)malloc(sizeof(struct Polynomial));temp2->next=NULL;temp1=AddPolyn(temp1,pa);while(qa!=NULL&&qa->exp>=qb->exp){temp2->next=(Polyn)malloc(sizeof(struct Polynomial));temp2->next->coef=(qa->coef)/(qb->coef);temp2->next->exp=(qa->exp)-(qb->exp);Insert(temp2->next,hf);pa=SubtractPolyn(pa,MultiplyPolyn(pb,temp2));qa=pa->next;temp2->next=NULL;}pf=SubtractPolyn(temp1,MultiplyPolyn(hf,pb));pb=temp1;printf("the quotient is :");PrintPolyn(hf);printf("the remainder is :");PrintPolyn(pf);}//DevicePolynint main(){int m,n,flag=0;float x;Polyn pa=0,pb=0,pc,pd,pe,pf;//定义各式的头指针，pa与pb在使用前付初值NULL printf("please input A number:");scanf("%d",&m);pa=CreatePolyn(pa,m);//建立多项式Aprintf("please input B number:");scanf("%d",&n);pb=CreatePolyn(pb,n);//建立多项式B//输出菜单printf("**********************************************\n");printf("choise：\n\t1.Output A and B\n\t2.CreatePolyn A+B\n");printf("\t3.CreatePolyn A-B\n\t4.CreatePolyn A*B\n");printf("\t5.CreatePolynA/B\n\t6.Return\n**********************************************\n");for(;;flag=0){printf("choise");scanf("%d",&flag);if(flag==1){printf("多项式A：");PrintPolyn(pa);printf("多项式B：");PrintPolyn(pb);continue;}if(flag==2){pc=AddPolyn(pa,pb);printf("多项式A+B：");PrintPolyn(pc);DestroyPolyn(pc);continue;}if(flag==3){pd=SubtractPolyn(pa,pb);printf("多项式A-B：");PrintPolyn(pd);DestroyPolyn(pd);continue;}if(flag==4){pf=MultiplyPolyn(pa,pb);printf("多项式a*b：");PrintPolyn(pf);DestroyPolyn(pf);continue;}if(flag==5){DevicePolyn(pa,pb);continue;}if(flag==6) break;if(flag<1||flag>6) printf("Error\n");continue;}//forDestroyPolyn(pa);DestroyPolyn(pb);return 0;}一、调试过程一次调试二次调试二、实验结果测试数据（1）多项式A:3x^4+11x^3+21x^2多项式B:2x^5+11x^4+12x^3+7x实验结果（1）多项式A+B=2x^5+14x^4+23x^3+21x^2+7x多项式A-B=-2x^5-8^4-x^3+21x^2-7x多项式A*B=6x^9+55x^8+199x^7+363x^6+273x^5+77x^4+147x^3多项式A/B=0实验截图（1）测试数据（2）：多项式A:2x^3+5x^-3多项式B:9x^2+6x^-2+11x^-3实验结果（2）：多项式A+B=2x^3+9x^2+6x^-2+16x^-3多项式A-B=2x^3-9x^2-6x^(-2)=16x^(-3)多项式A*B=18x^5+12x+22+45x^(-1)+30x^(-5)+55x^(-6)多项式A/B=0.222222x实验截图（2）：测试数据（3）多项式A:-x^7+3x^5多项式B:x^7-4x6%+7x^3实验结果（3）多项式A+B=-x^5+7x^3多项式A-B=-2x^7+7x^5-7x^3多项式A*B=-x^14+7x^12-19x^10+21x^8多项式A/B=-1实验截图（3）：三、总结1.在熟悉VC6.0环境的同时，对单链表的存储格式有了深刻的理解；2.复习C++语法的同时，对刚学的线性表进行综合性理解和表达，与之前所学融合。

一元多项式相加实验报告

一元多项式相加实验报告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为头指针的一个新链表中。

一元多项式相加数据结构实验一-1307班谭淇蔚

中南大学《数据结构与算法》课程实验实验报告题目实验一线性表的操作学生姓名谭淇蔚学生学号 3901130721 专业班级软件工程1307班完成日期2014年3月31日星期一实验一线性表的操作（一元多项式相加）1. 需求分析我们使用计算机处理的对象之间通常存在着的是一种最简单的线性关系，这类数学模型可称为线性的数据结构。

而数据存储结构有两种：顺序存储结构和链式存储结构。

线性表是最常用且最简单的一种数据结构。

所以我们做的是实验一-----------线性表的操作。

实验的目的是掌握线性表的基本操作，插入、删除、查找，以及线性表合并等运算在顺序存储结构和链接存储结构上的运算以及熟练运用掌握的线性表的操作，实现一元n次多项式的加法运算。

学习实现一元n次多项式的加法是符号多项式的操作，是表处理的典型用例，需要注意的是：顺序存储结构指的是用数组方法，使用数组方法实现时，在插入和删除的方面，数组不如链表灵活，方法复杂，删除其中一个需要将其后的数组元素改变位置，使其数组保持原有的顺序结构，在查找方面较链表简单，只需要知道其下标就可以知道。

链接存储结构指的是用链表方法,值得注意的是，删除和插入较为灵活，不需要变动大多数元素，但是查找过程相对于数组这种顺序存储结构来说较为复杂，耗时巨大。

我们要学习的是通过对两种方法基本操作的掌握来做到实现一元n次多项式的相加减。

我们程序的任务是：能进行简单的线性表操作（插入、删除、查找）以及线性表合并等运算。

能通过这些基本操作实现一元多项式相加。

明确规定：输入的形式：按照提示（比如：“请您输入第一个结构体数组的项数（不超过50项）：”、“请您输入第二个结构体数组的项数（不超过50项）：”、“请输入第n项的系数”、“请输入第n项的指数”等等），先输入多项式的项数，之后顺次输入每一项的系数与指数。

输入值的范围：项数没有要求，但不能过于巨大；系数取为float型数据，指数取为int 型数据，输出的形式：按照提示（比如：“您输入的第一个多项式为：”、“您输入的第二个多项式为：”等等），会输出原输入的多项式和经过排序和合并之后的降幂型多项式。

实验一多项式求和

韶关学院
学生实验报告册
实验课程名称：数据结构与算法
实验项目名称：实验一多项式求和
实验类型（打√）：（基础、综合、设计√）
院系：计算机科学学院专业：计算机科学技术姓名：*** 学号：*****
指导老师：***
韶关学院教务处编制
一、实验预习报告内容
二、实验原始（数据）记录
实验时间：2011 年9 月21 日（星期三第7，8 节）
实验同组人：
【程序运行结果】
运行结果1：
运行结果2：
通过分析输入数据和运行结果，证明程序顺利完成实验内容和要求。

指导教师
批阅及签名签名：年月日
三、实验报告内容
2011年9 月21 日
注：1、如有个别实验的实验报告内容多，实验报告册页面不够写，或有识图，画图要求的，学生应根据实验指导老师要求另附相同规格的纸张并粘贴在相应的“实验报告册”中。

2、实验报告册属教学运行材料，院系（中心）应按有关规定归档保管。

一元多项式求和

实验二一．学生基本情况：专业班级：学号：姓名：二．实验题目、实验内容1、实验目的：（1）熟练掌握链表结构及有关算法的设计；（3）掌握用链表表示特定形式的数据的方法，并能编写出有关运算的算法。

2、实验内容：一元多项式求和。

把任意给定的两个一元多项式P(x),Q(x)输入计算机，计算它们的和并输出计算结果。

三．设计分析先构造两个项链表，分别存储两个多项式的系数和指数，然后将每个链表按指数的大小从小到大排列，以便于后来的合并。

合并的伪代码如下：当然，多项式的输出也不简单，要考虑系数是否为1，为1时x前的系数不显示，指数是否为1，为1时也不显示。

还有最前面的项如果系数为正，则不显示+号。

四．源程序代码#include<stdio.h>#include<stdlib.h>#define M 50typedef struct node//项节点{float coef;//系数float exp;//指数node * next;//下一节点}Linode;void Initlinode(Linode * &L)//初始化{L=(Linode * )malloc(sizeof(Linode));L->coef=L->exp=0;L->next=NULL;}void Createlinode(Linode * &L,int n)//建立项链表{Linode * p,* s=L;int i;for(i=0;i<n;i++){printf("输入第%d个数的系数和指数:\n",i+1);p=(Linode * )malloc(sizeof(Linode));scanf("%f%f",&(p->coef),&(p->exp));s->next=p;p->next=NULL;s=p;}}void Destroylinode(Linode * &L)//销毁链表{Linode * p=L,* s=L->next;while(s!=NULL){free(p);p=s;s=s->next;}free(p);}bool Sort(Linode * &L)//排序{Linode * p, * pre,* q;if(L->next==NULL)return 0;p=L->next->next;L->next->next=NULL;while(p!=NULL){q=p->next;pre=L;while(pre->next!=NULL&&pre->next->exp<p->exp) pre=pre->next;p->next=pre->next;pre->next=p;p=q;}return 1;}bool Plus(Linode * &A,Linode * &B)//合并多项式{Linode * p=A->next, * q=B->next,* r=A,* s;if(q==NULL)return 0;while(p!=NULL&&q!=NULL){s=q->next;if(p->exp<q->exp){while(p!=NULL&&p->exp<q->exp){p=p->next;r=r->next;}}if(p!=NULL&&p->exp>q->exp){r->next=q;q->next=p;r=q;q=s;if(s!=NULL)s=s->next;}if(p!=NULL&&q!=NULL&&p->exp==q->exp){p->coef=p->coef+q->coef;if(p->coef==0){r->next=p->next;free(p);p=r->next;}else{p=p->next;r=r->next;}free(q);q=s;}}if(q!=NULL)r->next=q;return 1;}void Displinode(Linode * &L){Linode * p=L->next;while(p!=NULL){if(p->exp==0)printf("%.4f",p->coef);else if(p==L->next&&p->coef>=0){if(p->coef==1){if(p->exp==1)printf("x");elseprintf("x^%.2f",p->exp);}else{if(p->exp==1)printf("%.4fx",p->coef);elseprintf("%.4fx^%.2f",p->coef,p->exp);}}else{if(p->coef>=0){if(p->coef==1){if(p->exp==1)printf("+x");elseprintf("+x^%.2f",p->exp);}else{if(p->exp==1)printf("+%.4fx",p->coef);elseprintf("+%.4fx^%.2f",p->coef,p->exp);}}else{if(p->coef==-1){if(p->exp==1)printf("-x");elseprintf("-x^%.2f",p->exp);}else{if(p->exp==-1)printf("%.4fx",p->coef);elseprintf("%.4fx^%.2f",p->coef,p->exp);}}}p=p->next;}printf("\n");}void main(){int m,n;Linode* A;Linode* B;Initlinode(A);Initlinode(B);printf("输入P(x)的项数:");scanf("%d",&m);Createlinode(A,m);if(Sort(A)==1)printf("排序成功\n");printf("P(x)=");Displinode(A);printf("输入Q(x)的项数:");scanf("%d",&n);Createlinode(B,n);if(Sort(B)==1)printf("排序成功\n");printf("Q(x)=");Displinode(B);if(Plus(A,B)==1)printf("表达式为F(x)=");Displinode(A);Destroylinode(A);}五．测试用例（尽量覆盖所有分支）六．实验总结对于这个实验，我最开始的想法是输入字符串，然后将字符串拆分成几个项存入链表中，然后再排序，合并。

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

数据结构实验报告实验一：一元多项式相加姓名：周成学号： 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", &current->coef, &current->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、在建立链表和多项式相加时，新生成链表的头指针做为参数传递时，曾忽略了参数的标识“&”，致使建立链表失败。

一元多项式相加实验报告

一元多项式相加实验报告一元多项式相加实验报告引言：一元多项式是高中数学中的重要概念，它在代数运算中具有广泛的应用。

本次实验旨在通过实际操作，探究一元多项式的相加规律，并验证其正确性。

实验步骤：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。

可以看出，相加结果的次数和系数分别是两个一元多项式次数和系数的相加。

结果分析：从实验结果中可以发现，一元多项式相加的规律是将相同次数的项的系数相加，并保留该次数的项。

这与我们在学习一元多项式时所掌握的知识是一致的。

通过实验操作，我们验证了一元多项式相加的正确性。

实验总结：本次实验通过实际操作验证了一元多项式相加的规律，加深了对一元多项式的理解。

在实验过程中，我们还发现了一些注意事项。

首先，要注意相加过程中的计算准确性，尤其是在涉及到多项式次数较高时。

其次，要注意对相加结果进行化简，以便更好地观察和分析。

最后，实验过程中要保持仔细和认真，确保实验结果的可靠性。

结论：通过本次实验，我们验证了一元多项式相加的规律，并得出了相加结果的特点和规律。

一元多项式相加是代数运算中的重要内容，掌握相加规律对于深入理解和应用一元多项式具有重要意义。

数据结构—多项式求和

实验一多项式求和实验一、程序验证1、源代码：#include<iostream.h>//cout,cin#include"process.h"//exit()#define Max 20typedef struct{float coef;int exp;}PolyArray[Max];struct PolyNode{float coef;int exp;PolyNode *next;};class Poly{private:PolyNode *head;public:Poly();//构造函数，建立空多项式~Poly();//析构函数，释放多项式void Create(PolyArray a,int n);//键盘输入，创建多项式链表void Disp();//多项式显示void Sort();//有序表排序void Add (Poly LB);//多项式加//void Substract(PolyNode * hbQ);//多项式减//void Multiply(PolyNode * hb);//多项式乘};Poly::Poly(){ //创建一空多项式head=new PolyNode;head->next=NULL;}Poly::~Poly(){//释放多项式所占空间PolyNode *p;while(head!=NULL){//从头结点开始，依次释放结点p=head;head=head->next;delete p;}head=NULL;//头结点指向空}void Poly::Disp (){PolyNode *p;p=head->next;while(p!=NULL){cout<<p->coef <<"x^"<<p->exp<<'\t' ;p=p->next ;}cout<<endl;}void Poly::Create (PolyArray a,int n){//由多项式数组创建多项式链表PolyNode *s,*r;int i;r=head;for(i=0;i<n;i++){s=new PolyNode;s->coef =a[i].coef;s->exp =a[i].exp;s->next =NULL;r->next =s;r=s;}}void Poly::Sort(){PolyNode *p,*q,*r;p=head->next ;if(p!=NULL){r=p->next ;//r指向p的后继结点p->next =NULL;//构造只有一个结点的有序表p=r;while(p!=NULL){r=p->next;q=head;while(q->next!=NULL && q->next ->exp < p->exp )q=q->next ;//在有序表中插入*p的前驱结点*q p->next =q->next ;//*p插入到*q之后q->next =p;p=r;}}}void Poly::Add(Poly LB){float sum;PolyNode *pa,*pb,*qa,*qb;pa=head;qa=pa->next;pb=LB.head ;qb=pb->next;while (qa!=NULL && qb!=NULL ){if (qa->exp < qb->exp ){//pa=qa;qa=qa->next; }else if ( qa->exp > qb->exp ){ //pb->next =qb->next;qb->next=qa;pa->next=qb;pa=qb;qb=pb->next;}else{//sum=qa->coef+qb->coef;if (sum==0 ){//pa->next=qa->next;delete qa;qa=pa->next;pb->next=qb->next;delete qb;qb=pb->next;}else{qa->coef=sum;pa=qa; qa=qa->next;pb->next=qb->next;delete qb;qb=pb->next;}}}//whileif(qb!=NULL)qa->next=qb;//}//Addvoid main(){Poly LA,LB;PolyArray a={{7.0,0},{3.0,1},{9.0,8},{5.0,16}};PolyArray b={{8.0,1},{22,7},{-9.0,8}};LA.Create (a,4);LB.Create (b,3);cout<<"原多项式A为：";LA.Disp ();cout<<"原多项式B为：";LB.Disp ();LA.Sort ();LB.Sort ();cout<<"有序多项式A为：";LA.Disp ();cout<<"有序多项式B为：";LB.Disp();LA.Add (LB);cout<<"和多项式为：";LA.Disp ();}2、运行结果：实验二有序表合并一、实验设计1、问题描述把两个有序表归并为一个有序表。

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

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

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

三．算法思想描述: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. 主函数调用，完成多项式相加。

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

《数据结构》实验报告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）测试结果分析：程序运行结果和预测的完全相同，说明所设计的一元多项式的加法是正确的。

算法与数据结构实验一元多项式求和

《算法与数据结构》实验报告姓名：***班级：计科01学号：**********实验题目：链表的应用实验内容：一元多项式求和把任意给定的两个一元多项式P(x),Q(x)输入计算机，计算它们的和并输出计算结果。

设计分析：一元多项式可以用单链表表示，结点结构图示如下：Array一元多项式链表的结点结构一元多项式算法伪代码如下：源程序代码：#include"StdAfx.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本À?程¨¬序¨°可¨¦以°?完ª¨º成¨¦两¢?个?一°?元a多¨¤项?式º?的Ì?加¨®法¤¡§运?算?。

¡ê\n");printf("请?输º?入¨?一°?元a多¨¤项?式º?a的Ì?项?数ºym：êo");scanf("%d",&m);printf("请?按ã¡ä照?从ä¨®低Ì¨ª次ä?到Ì?高?次ä?的Ì?顺3序¨°依°¨¤此ä?输º?入¨?一°?元a多¨¤项?式º?a的Ì?系¦Ì数ºy和¨ª指?数ºy：êo\n");PutLinkList(a,m);printf("a=");OutLinkList(a);printf("请?输º?入¨?一°?元a多¨¤项?式º?b的Ì?项?数ºyn：êo");scanf("%d",&n);printf("请?按ã¡ä照?从ä¨®低Ì¨ª次ä?到Ì?高?次ä?的Ì?顺3序¨°依°¨¤此ä?输º?入¨?一°?元a多¨¤项?式º?b的Ì?系¦Ì数ºy和¨ª指?数ºy：êo\n");PutLinkList(b,n);printf("b=");OutLinkList(b);c=AddLinkList(a,b);printf("两¢?个?多¨¤项?式º?的Ì?和¨ª为a：êo\na+b=");OutLinkList(c);}void PutLinkList(LinkList *&L,int n){LinkList *s,*r;L=(LinkList *)malloc(sizeof(LinkList));r=L;for(int i=0;i<n;i++){s=(LinkList *)malloc(sizeof(LinkList));printf("请?输º?入¨?第Ì¨²%d项?的Ì?系¦Ì数ºy：êo",i+1);scanf("%d",&s->x);printf("请?输º?入¨?第Ì¨²%d项?的Ì?指?数ºy：êo",i+1);scanf("%d",&s->z);r->next=s;r=s;}r->next=NULL;}void OutLinkList(LinkList *L) {char FuHao;LinkList *p=L->next;FuHao=p->x>0? '+':'-';if(FuHao=='-'){printf("%c",FuHao);if(p->x==-1)printf("1");}OutXLinkList(p);OutZLinkList(p);p=p->next;while(p!=NULL){FuHao=p->x>0? '+':'-';printf("%c",FuHao);OutXLinkList(p);OutZLinkList(p);p=p->next;}printf("\n");}void OutXLinkList(LinkList *L) {int xi=L->x>0? L->x:-L->x;if(L->x==1||L->x==-1);elseprintf("%d",xi);}void OutZLinkList(LinkList *L) {if(L->z==0);else if(L->z==1||L->z==-1){if(L->z<0){if(L->x==1||L->x==-1)printf("1");printf("/");}printf("X");}else{if(L->z<0)printf("/");int zhi=L->z>0? L->z:-L->z;printf("X^%d",zhi);}}LinkList *AddLinkList(LinkList *a,LinkList *b){a=a->next;b=b->next;LinkList *c,*d,*s;c=(LinkList *)malloc(sizeof(LinkList));d=c;while(a!=NULL&&b!=NULL){if(a->z<b->z){s=(LinkList *)malloc(sizeof(LinkList));s->x=b->x;s->z=b->z;d->next=s;d=s;b=b->next;}else if(a->z>b->z){s=(LinkList *)malloc(sizeof(LinkList));s->x=a->x;s->z=a->z;d->next=s;d=s;a=a->next;}else{s=(LinkList *)malloc(sizeof(LinkList));s->x=a->x+b->x;s->z=a->z;if(s->x==0);else{d->next=s;d=s;}a=a->next;b=b->next;}}if(a!=NULL)d->next=a;else if(b!=NULL)d->next=b;elsed->next=NULL;return c;}测试用例：当a=3x^8-x^5+2x^3+7x^2+5x,b=5x^5+3x^4-7x^2-3x^(-3)时，运行结果如下：试验总结：通过本次试验，学会了链表的应用，加深了对链表的理解，知道了链表是把线性表中的元素按照链式储存方式到计算机中的一片连续的储存空间中。

☆C语言实验一(多项式求和)

1、参看书P48表3-3和二级考试软件的第三章单选第1题，验证字符变量赋字符B的六种不同常量表示方式：'B'；66；0x42；0102；'\x42'；'\102'；参考参考调试程序：思考和和验证：1、如果char x=’B’改成char x=66; 或char x=0x42; 或char x=0102；或char x=’\x42’或char x=’\102’; 显示结果是什么？2、如果char x=’B’改为char x=128;则显示什么？数值129-255分别赋给x时，各显示什么？有什么规律可遵循？3、对于TC30 int y=32768;显示什么？赋值32768-65535各显示什么？有什么规律可遵循？4、验证用小写的书上P365关键字作“标识符（P39）”来代替上述主函数中变量x，会产生什么后果？用大写关键字作为标识符，编译(Compiling)会成功吗？5、按照P38-P39对C语言”标识符”的规定，用上述主函数验证江苏省高校计算机二级考试C语言考题练习软件中的第三章选择题第9，11，15、20题的正确标识符答案是什么？2、查阅ftp://219.219.96.234/基础部教学空间/江苏省高校计算机二级考试C语言考题练习软件“单选题”的正确答案第一章单选题（2、4、7、8、9、10）；第三章部份关于标识符规定和数据定义的题目(9、11、15、20、22) 。

[要求]机械0822班在下周课上回答1-5 1-2、46-10 1-7、811-15 1-9、1016-20 3-9、1121-25 3-15、2226-32 3-12、221、阅读书45、48页关于整型常量、浮点型常量、字符型常量的表示方式，以及相应的变量声明方式。

用软件的第三章选择题第3、16题来验证之。

2、C语言算术表达式：阅读书54、书55、书56页C语言运算符及附录C“运算符及其结合性”（P365）用软件的第三章填空题第5、6、7、15、17、18、19、21题来验证之。

[训练]一元多项式求和

[训练]一元多项式求和实验二一( 学生基本情况:专业班级:学号:姓名:二( 实验题目、实验内容1、实验目的:(1)熟练掌握链表结构及有关算法的设计;(3)掌握用链表表示特定形式的数据的方法，并能编写出有关运算的算法。

2、实验内容:一元多项式求和。

把任意给定的两个一元多项式P(x) ,Q(x) 输入计算机，计算它们的和并输出计算结果。

三(设计分析先构造两个项链表，分别存储两个多项式的系数和指数，然后将每个链表按指数的大小从小到大排列，以便于后来的合并。

合并的伪代码如下:1. 工作指针p、q初始化;2. while(p存在且q存在)执行下列三种情形之一2.1 如果p->exp<q->exp，则指针p后移;2.2 如果p->exp>q->exp，则2.2.1 将结点q插入到结点p之前;2.2.2 指针q指向原指结点的下一个结点;2.3 如果p->exp=q->exp，则2.3.1 p->coef =p->coef+q->coef;2.3.2 如果p->coef ==0，则执行下列操作，否则，指针p后移;2.3.2.1 删除结点p;2.3.2.2 使指针p指向它原指结点的下一个结点;2.3.3 删除结点q;2.3.4 使指针q指向它原指结点的下一个结点;3. 如果q不为空，将结点q链接在第一个单链表的后面;当然，多项式的输出也不简单，要考虑系数是否为1，为1时x前的系数不显示，指数是否为1，为1时也不显示。

还有最前面的项如果系数为正，则不显示+号。

四(源程序代码#include<stdio.h>#include<stdlib.h>#define M 50typedef struct node//项节点{float coef;//系数float exp;//指数node * next;//下一节点 }Linode;void Initlinode(Linode * &L)//初始化 {L=(Linode * )malloc(sizeof(Linode));L->coef=L->exp=0;L->next=NULL;}void Createlinode(Linode * &L,int n)//建立项链表{Linode * p,* s=L;int i;for(i=0;i<n;i++){printf("输入第%d个数的系数和指数:\n",i+1); p=(Linode * )malloc(sizeof(Linode));>coef),&(p->exp)); scanf("%f%f",&(p-s->next=p;p->next=NULL;s=p;}}void Destroylinode(Linode * &L)//销毁链表{Linode * p=L,* s=L->next;while(s!=NULL){free(p);p=s;s=s->next;}free(p);}bool Sort(Linode * &L)//排序 {Linode * p, * pre,* q;if(L->next==NULL)return 0;p=L->next->next;L->next->next=NULL;while(p!=NULL){q=p->next;pre=L;while(pre->next!=NULL&&pre->next->exp<p->exp) pre=pre->next;p->next=pre->next;pre->next=p;p=q;}return 1;}bool Plus(Linode * &A,Linode * &B)//合并多项式{Linode * p=A->next, * q=B->next,* r=A,* s; if(q==NULL)return 0;while(p!=NULL&&q!=NULL){s=q->next;if(p->exp<q->exp){while(p!=NULL&&p->exp<q->exp){p=p->next;r=r->next;}}if(p!=NULL&&p->exp>q->exp){r->next=q;q->next=p;r=q;q=s;if(s!=NULL)s=s->next;}if(p!=NULL&&q!=NULL&&p->exp==q->exp) {p->coef=p->coef+q->coef;if(p->coef==0){r->next=p->next;free(p);p=r->next;}else{p=p->next;r=r->next;}free(q);q=s;}}if(q!=NULL)r->next=q;return 1;}void Displinode(Linode * &L) { Linode * p=L->next;while(p!=NULL){if(p->exp==0)printf("%.4f",p->coef);else if(p==L->next&&p->coef>=0){if(p->coef==1){if(p->exp==1)printf("x");elseprintf("x^%.2f",p->exp);}else{if(p->exp==1)printf("%.4fx",p->coef);elseprintf("%.4fx^%.2f",p->coef,p->exp); }}else{if(p->coef>=0){if(p->coef==1){if(p->exp==1)printf("+x");elseprintf("+x^%.2f",p->exp);}else{if(p->exp==1)printf("+%.4fx",p->coef);elseprintf("+%.4fx^%.2f",p->coef,p->exp); }}else{if(p->coef==-1){if(p->exp==1)printf("-x");elseprintf("-x^%.2f",p->exp);}else{if(p->exp==-1)printf("%.4fx",p->coef);elseprintf("%.4fx^%.2f",p->coef,p->exp); }}}p=p->next;}printf("\n");}void main(){int m,n;Linode* A;Linode* B;Initlinode(A);Initlinode(B);printf("输入P(x)的项数:");scanf("%d",&m);Createlinode(A,m);if(Sort(A)==1)printf("排序成功\n");printf("P(x)=");Displinode(A);printf("输入Q(x)的项数:");scanf("%d",&n);Createlinode(B,n);if(Sort(B)==1)printf("排序成功\n");printf("Q(x)=");Displinode(B);if(Plus(A,B)==1)printf("表达式为F(x)="); Displinode(A);Destroylinode(A); }五(测试用例(尽量覆盖所有分支)六(实验总结对于这个实验，我最开始的想法是输入字符串，然后将字符串拆分成几个项存入链表中，然后再排序，合并。

实验一 多项式求和

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

一元多项式求和

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

完整word版一元多项式求和实验报告范文_

算法与数据结构实验报告实验一 完成多项式的相加运算

一元多项式相加实验报告

一元多项式相加问题实验报告

一元多项式相加数据结构实验一-1307班谭淇蔚

实验一 多项式求和

一元多项式求和

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

实验报告示例(实验一_一元多项式相加)

一元多项式相加实验报告

数据结构—多项式求和

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

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

算法与数据结构实验一元多项式求和

☆C语言实验一(多项式求和)

[训练]一元多项式求和

实验一多项式求和

算法与数据结构实验报告实验一完成多项式的相加运算

实验一多项式求和