一元多项式的计算实验报告
一元多项式加减乘除运算
中国计量学院实验报告实验课程：算法与数据结构实验名称：一元二项式班级：学号：姓名：实验日期： 2013-5-7一．实验题目：①创建2个一元多项式②实现2个多项式相加③实现2个多项式相减④实现2个多项式相乘⑤实现2个多项式相除⑥销毁一元多项式实验成绩：指导教师：二．算法说明①存储结构：一元多项式的表示在计算机内可以用链表来表示，为了节省存储空间，只存储多项式中系数非零的项。
链表中的每一个结点存放多项式的一个系数非零项，它包含三个域，分别存放该项的系数、指数以及指向下一个多项式项结点的指针。
创建一元多项式链表，对一元多项式的运算中会出现的各种可能情况进行分析，实现一元多项式的相加、相减操作。
②加法算法三．测试结果四．分析与探讨实验数据正确，部分代码过于赘余，可以精简。
五．附录：源代码#include<>#include<>#include<>typedef struct Polynomial {float coef;int expn;struct Polynomial *next;}*Polyn,Polynomial;出多项式a和b\n\t2.多项式相加a+b\n\t3.多项式相减a-b\n");printf("\t4.多项式相除a*b\n\t5.多项式相除a/b\n\t6.销毁多项式\n");printf("\t7.退出\n*********************************** ***********\n");printf("执行:");scanf("%d",&flag);switch(flag){case(1):printf("多项式a：");PrintPolyn(pa); printf("多项式b：");PrintPolyn(pb);break;case(2):pc=AddPolyn(pa,pb);printf("多项式a+b：");PrintPolyn(pc);DestroyPolyn(pc);break;case(3):pd=SubtractPolyn(pa,pb);printf("多项式a-b：");PrintPolyn(pd);DestroyPolyn(pd);break;case(4):pf=MultiplyPolyn(pa,pb);printf("多项式a*b：");PrintPolyn(pf); DestroyPolyn(pf);break;case(5):DevicePolyn(pa,pb);break;case(6):DestroyPolyn(pa);DestroyPolyn(pb);printf("成功销毁2个一元二项式\n");printf("\n接下来要执行的操作:\n1 重新创建2个一元二项式 \n2 退出程序\n");printf("执行:");scanf("%d",&i);if(i==1){// Polyn pa=0,pb=0,pc,pd,pf;//定义各式的头指针，pa与pb在使用前付初值NULLprintf("请输入a的项数:");scanf("%d",&m);pa=CreatePolyn(pa,m);//建立多项式aprintf("请输入b的项数:");scanf("%d",&n);pb=CreatePolyn(pb,n);//建立多项式bbreak;}if(i==2)return 0; case(7): return 0;} } } }。
一元多项式的相加实验报告
一元多项式的相加实验报告一元多项式的相加实验报告引言：一元多项式是数学中常见的概念，它由一个变量和一系列常数乘积的和组成。
在本实验中，我们将研究一元多项式的相加运算，并通过实验验证相加运算的性质和规律。
实验目的：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;}五、测试用例：六、实验总结通过这次实验，对于链表的应用知识有了更加深刻的认识，虽然中间出了很多问题，但是经过调试以后都得以解决。
一元多项式相加实验报告
一元多项式相加实验报告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而言，每一个子项都是由“系数”和“指数”两部分来组成的，因此可将多项式抽象成一个“系数、指数对”构成的线性表，其中多项式的每一个系数非零的子项作为线性表中的一个元素。
课程设计报告--一元多项式计算
课程设计报告一元多项式计算订票系统系别专业年级学生姓名学号任课教师二○一二年三月一、题目内容实验二一元多项式计算**1．任务：能够按照指数降序排列建立并输出多项式；能够完成两个多项式的相加、相减、相乘，并将结果输出；2.在上交资料中请写明：存储结构、多项式相加的基本过程的算法（可以使用程序流程图）、源程序、测试数据和结果、算法的时间复杂度、另外可以提出算法的改进方法；实验三订票系统1．任务：通过此系统可以实现如下功能：1）录入：可以录入航班情况（数据可以存储在一个数据文件中，数据结构、具体数据自定）2）查询：可以查询某个航线的情况（如，输入航班号，查询起降时间，起飞抵达城市，航班票价，票价折扣，确定航班是否满仓）；可以输入起飞抵达城市，查询飞机航班情况；3）订票：（订票情况可以存在一个数据文件中，结构自己设定）可以订票，如果该航班已经无票，可以提供相关可选择航班；4）退票：可退票，退票后修改相关数据文件；客户资料有姓名，证件号，订票数量及航班情况，订单要有编号。
5）修改航班信息：当航班信息改变可以修改航班数据文件。
2．要求：根据以上功能说明，设计航班信息，订票信息的存储结构，设计程序完成功能。
二、解题分析（一）、一元多项式计算分析：①能够按照多项式变量的指数降序创建一个多项式；②能够对已创建的多项式进行显示；③能够对已创建的多项式之间的加法运算；④能够对已创建的多项式之间的减法运算；⑤能够对已创建的多项式之间的乘法运算；⑥能够实现计算器退出操作。
（二）、订票系统：①能够按照规定输入航班的各个信息；②能够对已输入的航班信息进行显示；③能够对已创建的信息按照要求进行排序；④能够对已创建的信息进行查找；⑤能够完成订票，退票操作；⑥能够实现系统退出操作。
三、所用数据结构的描述（用伪代码）（一）、一元多项式计算：1、定义节点类型：typedef struct node{float coef;int expn;struct node * next; }PLOY;2、查找位置插入新链节程序:void insert(PLOY *head,PLOY *inpt){PLOY *pre,*now;int signal=0;pre=head;/*pre定义为现在的前一个链节*/if(pre->next==NULL)pre->next=inpt;else {now=pre->next;while(signal==0) {if(inpt->expn<now->expn) { /*当新链节小于现在的连接时向后移一个链节*/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); }}}}}3、输入多项式：PLOY *creat(char ch) {PLOY *head,*inpt;float x;int y;head=(PLOY *)malloc(sizeof(PLOY));/*创建链表头*/head->next=NULL;printf("请输入一元多项式%c:(格式是：系数指数；以0 0 结束！)\n",ch);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);/*不然就查找位置并且插入新链节*/printf("请输入一元多项式%c的下一项:(以0 0 结束！)\n",ch);scanf("%f %d",&x,&y); }return head; }4、输出多项式：void print(PLOY *fun) {PLOY *printing;int flag=0;printing=fun->next;/*正在被打印的链节*/if(fun->next==NULL) { /*如果函数为空打印0*/printf("0\n");return; }while(flag==0) {if(printing->coef>0&&fun->next!=printing)printf("+");/*为正数时打印"+"号*/if(printing->coef==1);/*如果为"1"就不用打印系数了*/else if(printing->coef==-1)printf("-");/*如果为"-1"就打印"-"号就行了*/elseprintf("%f",printing->coef);/*其余情况都得打印*/if(printing->expn!=0) printf("x^%d",printing->expn);/*如果指数为"0"不打印指数项*/else if((printing->coef==1)||(printing->coef==-1))printf("1");if(printing->next==NULL)flag=1;/*如果现在的链节没有下一个就结束*/elseprinting=printing->next; }printf("\n"); }（二）、订票系统：1、定义结构体：typedef struct plane{char ID[10]; /*航班代号*/char BePlace[10];/*飞机起飞地点*/char EnPlace[10];/*飞机降落终点*/char data[15];/*飞机起飞时间*/int max;/*飞机最大乘客人数*/int price;/*飞机票价*/int num;/*飞机已售票数*/}PLANE;PLANE ti[N];2、输入信息：void input(int i){printf("请输入航班代号：\n");scanf("%s",ti[i].ID);printf("请输入起飞地点：\n");scanf("%s",ti[i].BePlace);printf("请输入降落地点：\n");scanf("%s",ti[i].EnPlace);printf("请输入起飞时间：\n");scanf("%s",ti[i].data);printf("请输入航班的最大载客人数：\n");scanf("%d",&ti[i].max);printf("请输入航班的票价：\n");scanf("%d",&ti[i].price);ti[i].num=0;}3、订票功能：void book(){int i;system( "cls" );printf("欢迎进入售票窗口!\n");i=search();if(i!=-1){if(ti[i].num>=ti[i].max)printf("\n该趟航班票已售完！");else{ti[i].num++;printf("\n订票成功!\n");}}elseprintf("该航班不存在!\n");getchar();getchar(); /*按任意健*/menu();}四、部分算法的描述（用伪代码）（一）、一元多项式计算：1、加法：PLOY *addPLOY(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; }2、减法：PLOY *minusPLOY(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=0-pre->coef;inpt->expn=pre->expn;inpt->next=NULL;insert(head,inpt); }/*否则把当前"g(x)"的链节插入到"y(x)"中*/ }return head; }3、乘法：PLOY *byPLOY(PLOY *head1,PLOY *head2) { /*多项式相乘*/PLOY *inpt,*res,*pre;int flag=0;res=(PLOY *)malloc(sizeof(PLOY));/*创建链表头*/res->next=NULL;head1=head1->next;pre=head2;while(flag==0) {if(pre->next==NULL) {pre=head2;/*当现在指向空时跳出循环*/head1=head1->next;continue; }if(head1==NULL) {flag=1;/*当现在指向空时跳出循环*/continue; }pre=pre->next;inpt=(PLOY *)malloc(sizeof(PLOY));/*创建新链节*/inpt->coef=pre->coef*head1->coef;inpt->expn=pre->expn+head1->expn;inpt->next=NULL;insert(res,inpt);/*把当前"g(x)"的链节插入到"y(x)"中*/ } return res; }（二）、订票系统：1、排序：void order() {/*排序模块(按平均成绩)*/int i,j;struct plane s;system( "cls" );for(i=0;i<n;i++) {/*冒泡法排序*/for(j=i+1;j<n;j++)if(strcmp(ti[i].data,ti[j].data)>0){s=ti[i];ti[i]=ti[j];ti[j]=s;}}browse();}2、查找：int search() { /*查找模块*/int i,k;struct plane s;k=-1;system( "cls" );printf("\n\n请输入要订票的起飞地点:");scanf("%s",s.BePlace); /*输入要到达的地方*/printf("\n\n请输入要订票的降落地点:");scanf("%s",s.EnPlace);printf("\n\n请输入要订票的起飞时间:");scanf("%s",s.data); /*输入出发的时间*/for(i=0;i<n;i++) {/*查找要修改的数据*/if(strcmp(s.BePlace,ti[i].BePlace)==0&&strcmp(s.EnPlace,ti[i].EnPlace)==0&&strcmp(s.data,ti[i].data)==0){k=i; /*找到要修改的记录*/printf_one(k);break; } /*调用显示一个记录的函数*/}if(k==-1){printf("\n\nNO exist!");return -1;}elsereturn k;}3、保存：void save(){int w=1;FILE *fp;int i;system( "cls" );if((fp=fopen("\\ticket.txt","wt"))==NULL) {/*以输出打开方式,在此前的记录被覆盖*/printf("\nCannot open file\n");return ;}for(i=0;i<n;i++)if(fwrite(&ti[i],sizeof(struct plane),1,fp)!=1){printf("file write error\n");w=0;}if(w==1)printf("file save ok!\n");fclose(fp);getchar();getchar();menu();}4、载入void load(){FILE*fp;int i,w;w=1;system( "cls" );if((fp=fopen("\\ticket.txt","rt"))==NULL){printf("\nCannotopen file\n");w=0;return ;}n=0;for(i=0;!feof(fp);i++){fread(&ti[i],sizeof( struct plane),1,fp);n++;}n=n-1; fclose(fp);if(w==1)printf("Load file ok!");getchar();getchar();menu();}五、算法复杂度的简单分析（一）、一元多项式计算：1、加法：O(n)2、减法：O(n)3、乘法：O(n)（二）、订票系统：1、排序：O(n^2)2、查找：O(n)3、保存：O(n)4、载入：O(n)六、程序测试数据（一）、一元多项式计算：1．F(x)=f(x)+g(x)=(2x^7+3x^5+2x^4+3x^1)+(2x^6+3x^2+43x^1)=(2x^7+2x^6+ 3x^5+2x^4+3x^2+46)2．F(x)=f(x)-g(x)=(3x^5+8x^2)-(54x^3+2x^2+5x^1)=(162x^8+6x^7+15x^6+43 2x^5+16x^4)3．F(x)=f(x)*g(x)=(3x^4+5x^3+3x^2)*(2x^4+2x^2+3x^1)=(6x^8+10x^7+12x^6 +19x^5+21x^4+9x^3)（二）、订票系统：部分截图：1.菜单2排序3.查询4.订票5退票七、程序清单#include <stdio.h>#include <string.h>#include <stdlib.h>#include<malloc.h>#define N 1000typedef struct node{/*定义节点类型*/float coef;int expn;struct node * next; }PLOY;typedef struct plane{char ID[10]; /*航班代号*/char BePlace[10];/*飞机起飞地点*/char EnPlace[10];/*飞机降落终点*/char data[15];/*飞机起飞时间*/int max;/*飞机最大乘客人数*/int price;/*飞机票价*/int num;/*飞机已售票数*/}PLANE;PLANE ti[N];int n;/*当前的航班数目*/void menu();void menu1();void start()/{ /*用户选择界面*printf("************************************\n");printf(" 欢迎进入一元多项式计算系统 \n");printf("************************************\n");printf("请选择操作:\n");printf("0.退出\n");printf("1.两个一元多项式相加\n");printf("2.两个一元多项式相乘\n");printf("3.两个一元多项式相减\n"); }void insert(PLOY *head,PLOY *inpt){ /*查找位置插入新链节程序*/ PLOY *pre,*now;int signal=0;pre=head;/*pre定义为现在的前一个链节*/if(pre->next==NULL)pre->next=inpt;else {now=pre->next;while(signal==0) {if(inpt->expn<now->expn) / { /*当新链节小于现在的连接时向后移一个链节*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;printf("请输入一元多项式%c:(格式是：系数指数；以0 0 结束！)\n",ch);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);/*不然就查找位置并且插入新链节*/printf("请输入一元多项式%c的下一项:(以0 0 结束！)\n",ch);scanf("%f %d",&x,&y); }return head; }PLOY *addPLOY(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 *minusPLOY(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=0-pre->coef;inpt->expn=pre->expn;inpt->next=NULL;insert(head,inpt); }/*否则把当前"g(x)"的链节插入到"y(x)"中*/ }return head; }PLOY *byPLOY(PLOY *head1,PLOY *head2) { /*多项式相乘*/PLOY *inpt,*res,*pre;int flag=0;res=(PLOY *)malloc(sizeof(PLOY));/*创建链表头*/res->next=NULL;head1=head1->next;pre=head2;while(flag==0) {if(pre->next==NULL) {pre=head2;/*当现在指向空时跳出循环*/head1=head1->next;continue; }if(head1==NULL) {flag=1;/*当现在指向空时跳出循环*/continue; }pre=pre->next;inpt=(PLOY *)malloc(sizeof(PLOY));/*创建新链节*/inpt->coef=pre->coef*head1->coef;inpt->expn=pre->expn+head1->expn;inpt->next=NULL;insert(res,inpt); } /*把当前"g(x)"的链节插入到"y(x)"中*/return res; }void print(PLOY *fun) { /*输出多项式*/PLOY *printing;int flag=0;printing=fun->next;/*正在被打印的链节*/if(fun->next==NULL) { /*如果函数为空打印0*/printf("0\n");return; }while(flag==0) {if(printing->coef>0&&fun->next!=printing)printf("+");/*为正数时打印"+"号*/if(printing->coef==1);/*如果为"1"就不用打印系数了*/else if(printing->coef==-1)printf("-");/*如果为"-1"就打印"-"号就行了*/elseprintf("%f",printing->coef);/*其余情况都得打印*/if(printing->expn!=0) printf("x^%d",printing->expn);/*如果指数为"0"不打印指数项*/else if((printing->coef==1)||(printing->coef==-1))printf("1");if(printing->next==NULL)flag=1;/*如果现在的链节没有下一个就结束*/elseprinting=printing->next; }printf("\n"); }int Polynomial_solve() {PLOY *f,*g;int sign=-1;/*设置标志*/start();while(sign!=0) {scanf("%d",&sign);switch(sign) {case 0:exit(0);break;/*退出*/printf("你选择的操作是多项式相加:\n");f=creat('f');/*输入多项式f(x)*/printf("f(x)=");print(f);g=creat('g');/*输入多项式g(x)*/printf("g(x)=");print(g);printf("F(x)=f(x)+g(x)=");f=addPLOY(f,g);/*两个多项式相加*/print(f);sign=-1;/*复位标志*/start();/*回复用户选择界面*/break; }case 2: {printf("你选择的操作是多项式相乘:\n");f=creat('f');/*输入多项式f(x)*/printf("f(x)=");print(f);g=creat('g');/*输入多项式g(x)*/printf("g(x)=");print(g);printf("F(x)=f(x)*g(x)=");f=byPLOY(f,g);/*两个多项式相加*/print(f);sign=-1;/*复位标志*/start();/*回复用户选择界面*/break; }case 3: {printf("你选择的操作是多项式相减:\n");f=creat('f');/*输入多项式f(x)*/printf("f(x)=");print(f);g=creat('g');/*输入多项式g(x)*/printf("g(x)=");print(g);printf("F(x)=f(x)-g(x)=");f=byPLOY(f,g);/*两个多项式相加*/print(f);sign=-1;/*复位标志*/start();/*回复用户选择界面*/break; }default: {printf("输入有误!请重新选择操作!\n");/*选择错误,返回选择界面*/break; }}}}void input(int i){printf("请输入航班代号：\n");scanf("%s",ti[i].ID);printf("请输入起飞地点：\n");scanf("%s",ti[i].BePlace);printf("请输入降落地点：\n");scanf("%s",ti[i].EnPlace);printf("请输入起飞时间：\n");scanf("%s",ti[i].data);printf("请输入航班的最大载客人数：\n");scanf("%d",&ti[i].max);printf("请输入航班的票价：\n");scanf("%d",&ti[i].price);ti[i].num=0;}void enter(){int i;system( "cls" );printf("请输入航班的数目(0-%d)?:",N);scanf("%d",&n); /*要输入的记录个数*/printf("\n请输入数据\n\n");for(i=0;i<n;i++){printf("\n请输入第 %d 航班记录.\n",i+1);input(i); }/*调用输入函数*/getchar();menu();}void printf_one(int i) { /*显示一个记录的函数*/printf("%11s %6s %10s %6s %6d %6d %6d",ti[i].ID,ti[i].BePlace,ti[i].EnP lace,ti[i].data,ti[i].price,ti[i].max,ti[i].num);}void browse(){int i;system( "cls" );puts("\n--------------------------------------------------------------------"); printf("\n\t航班代号起飞地点降落地点起飞时间票价最大乘客已售票数\n"); for(i=0;i<n;i++){printf_one(i);printf("\n");}getchar();getchar();void order(){/*排序模块(按平均成绩)*/int i,j;struct plane s;system( "cls" );for(i=0;i<n;i++){/*冒泡法排序*/for(j=i+1;j<n;j++)if(strcmp(ti[i].data,ti[j].data)>0){s=ti[i];ti[i]=ti[j];ti[j]=s;}}browse();}void search_time(){int i,m=0;struct plane s;system( "cls" );printf("\n\nEnter the time:");scanf("%s",s.data); /*输入出发的时间*/puts("\n--------------------------------------------------------------------"); printf("\n\t航班代号起飞地点降落地点起飞时间票价最大乘客已售票数\n"); for(i=0;i<n;i++){if(strcmp(s.data,ti[i].data)==0){m++;if((m!=0)&&(m%10==0)) {/*目的是分屏显示*/printf("\n\nPress any key to contiune . . .");getchar();puts("\n\n");}printf_one(i);printf("\n");}/*调用显示一个记录的函数*/}puts("\n--------------------------------------------------------------------"); getchar(); /*按任意健*/getchar();menu1();}void serch_end(){int i,m=0;struct plane s;system( "cls" );printf("\n\nEnter the end Place:");scanf("%s",s.EnPlace); /*输入要到达的地方*/puts("\n--------------------------------------------------------------------"); printf("\n\t航班代号起飞地点降落地点起飞时间票价最大乘客已售票数\n"); for(i=0;i<n;i++){if(strcmp(ti[i].EnPlace,s.EnPlace)==0){m++;if((m!=0)&&(m%10==0)) {/*目的是分屏显示*/printf("\n\nPress any key to contiune . . .");getchar();puts("\n\n");}printf_one(i);printf("\n");}/*调用显示一个记录的函数*/}puts("\n--------------------------------------------------------------------"); getchar(); /*按任意健*/getchar();menu1();}void menu1(){int n,w1;do{system( "cls" ); /*清屏*/puts("\t\t\t\t 飞机售票操作!\n\n");puts("\t\t*********************MENU*********************\n\n");puts("\t\t\t\t1.按照时间排序");puts("\t\t\t\t2.按照时间查找航班");puts("\t\t\t\t3.按照地点查找航班");puts("\t\t\t\t4.返回主菜单");puts("\n\n\t\t**********************************************\n");printf("Choice your number(1-4): [ ]\b\b");scanf("%d",&n);if(n<1||n>4){/*对选择的数字作判断*/w1=1;printf("your choice is not between 1 and 4,Please input again:");getchar();getchar();}else w1=0;} while(w1==1);switch(n){/*选择功能* /case 1:order();break;case 2:search_time();break;case 3:serch_end();break;case 4:menu();break; }}int search(){ /*查找模块*/int i,k;struct plane s;k=-1;system( "cls" );printf("\n\n请输入要订票的起飞地点:");scanf("%s",s.BePlace); /*输入要到达的地方*/printf("\n\n请输入要订票的降落地点:");scanf("%s",s.EnPlace);printf("\n\n请输入要订票的起飞时间:");scanf("%s",s.data); /*输入出发的时间*/for(i=0;i<n;i++){ /*查找要修改的数据*/if(strcmp(s.BePlace,ti[i].BePlace)==0&&strcmp(s.EnPlace,ti[i].EnPlace)==0&&strc mp(s.data,ti[i].data)==0){k=i; /*找到要修改的记录*/printf_one(k);break; }/*调用显示一个记录的函数*/}if(k==-1){printf("\n\nNO exist!");return -1;}elsereturn k;}void book(){int i;system( "cls" );printf("欢迎进入售票窗口!\n");i=search();if(i!=-1){if(ti[i].num>=ti[i].max)printf("\n该趟航班票已售完！");else{ti[i].num++;printf("\n订票成功!\n");}}elseprintf("该航班不存在!\n");getchar();getchar(); /*按任意健*/menu();}void back(){int i,k=-1;struct plane s;system( "cls" );printf("欢迎进入退票窗口!\n");printf("\n\n输入航班代号:");scanf("%s",s.ID); /*输入要到达的地方*/for(i=0;i<n;i++){/*查找要修改的数据*/if(strcmp(s.ID,ti[i].ID)==0){k=i; /*找到要修改的记录*/printf_one(k);break; }/*调用显示一个记录的函数*/}if(k==-1)printf("\n\nNO exist!");else{ti[i].num--;printf("\n退票成功!\n");}getchar(); /*按任意健*/getchar(); /*按任意健*/menu();}void save(){int w=1;FILE *fp;int i;system( "cls" );if((fp=fopen("\\ticket.txt","wt"))==NULL) { /*以输出打开方式,在此前的记录被覆盖*/printf("\nCannot open file\n");return ;}for(i=0;i<n;i++)if(fwrite(&ti[i],sizeof(struct plane),1,fp)!=1){printf("file write error\n");w=0;}if(w==1)printf("file save ok!\n");fclose(fp);getchar();getchar();menu();}void load(){FILE*fp;int i,w;w=1;system( "cls" );if((fp=fopen("\\ticket.txt","rt"))==NULL){printf("\nCannotopen file\n");w=0;return ;}n=0;for(i=0;!feof(fp);i++){fread(&ti[i],sizeof( struct plane),1,fp);n++;}n=n-1;fclose(fp);if(w==1)printf("Load file ok!");getchar();getchar();menu();}void menu(){int n,w1;do{system( "cls" ); /*清屏*/ /*清屏*/puts("\t\t\t\t 飞机售票管理系统!\n\n");puts("\t\t*********************MENU*********************\n\n");puts("\t\t\t\t1.输入新航班");puts("\t\t\t\t2.浏览 ");puts("\t\t\t\t3.航班操作");puts("\t\t\t\t4.订票");puts("\t\t\t\t5.退票");puts("\t\t\t\t6.保存");puts("\t\t\t\t7.载入");puts("\t\t\t\t8.退出");puts("\n\n\t\t**********************************************\n");printf("Choice your number(1-8): [ ]\b\b");scanf("%d",&n);if(n<1||n>8) { /*对选择的数字作判断*/w1=1;printf("your choice is not between 1 and 8,Please input enter to choice again:");getchar();getchar();}else w1=0;} while(w1==1);switch(n){ /*选择功能*/case 1:enter();break; /*输入模块*/case 2:browse();break; /*浏览模块*/case 3:menu1();break; /*查找模块*/case 4:book();break; /*订票模块*/case 5:back();break; /*退票模块*/case 6:save();break; /*保存模块*/case 7:load();break; /*加载模块*/case 8:exit(0);}}int Ticket_system(){menu();}int main(){char ucflag;hchar ucchar[2];do{printf("**********欢迎进入系统!**********\n"); printf("* 1:一元多项式求解. *\n"); printf("* 2:飞机售票操作. *\n"); printf("* 0:退出. *\n"); printf("*********************************\n"); printf("请选择:\n");scanf(" %c",&ucflag);gets(ucchar);if(strlen(ucchar))ucflag='3';switch(ucflag-'0'){case 0:printf("谢谢使用!\n");break;case 1:Polynomial_solve();break;case 2:Ticket_system();break;default:printf("输入错误!请重新输入!\n");break;}}while(ucflag!='0');return 0;}欢迎下载，资料仅供参考!!!资料仅供参考!!!h。
一元多项式实验报告
数据结构实验报告实验名称：实验一一元多项式学生姓名：叶远锋班级：2010211111班内序号：18学号：10210328日期：2011年11月9日1．实验要求实验目的●熟悉C++语言的基本编程方法，掌握继承编译环境的调试方法；●学习指针、模板类、异常处理的使用；●掌握线性表的操作实现方法；●培养使用线性表解决实际问题的能力。
实验内容利用线性表实现一个一元多项式Polynomial：f（x）=a0+a1X+a2X^2+……+anX^n具体要求如下：①能够实现一元多项式的输入和输出；②能够进行一元多项式相加；③能够进行一元多项式相减；④能够计算一元多项式在x处的值；⑤能够计算一元多项式的导数（选作）；⑥能够进行一元多项式相乘（选作）；⑦编写main（）函数测试算法的正确性。
2. 程序分析2.1 存储结构存储结构：顺序表a[0]a[1]a[2]……a[n].2 关键算法分析1、关键算法：加法、减法、求导、乘法、求值✧加法时间复杂度O（n）输出参数：返回一个新一元多项式c输入参数：两个一元多项式PolyList类对象的引用a、b[1] 从第一项开始，比较a和b 的指数，直到其中一个多项式比较到最后一项[1.1] 如果a对应项的指数小于b对应项的指数，把a的对应项复制给C的对应项，再把a的下一项和b的当前项比较[1.2] 如果a对应项的指数大于b对应项的指数，把b的对应项复制给C的对应项，再把b的下一项和a的当前项比较[1.3] 如果a的对应项指数等于b的对应项指数，则c的对应项的系数等于a的对应项系数和b的对应项系数相加，c的对应项的指数等于a或b的对应项指数，再把a的下一项和b的下一项比较[2] 如果a或b其中有一个没有比较完，就把没有比较的项都复制到c中[3] 返回c✧减法时间复杂度O（n）输出参数：返回一个新一元多项式c输入参数：两个一元多项式PolyList类对象的引用a、b[1] 将多项式b的每一项系数都乘以-1[2] 调用加法，把a+b的值赋给c[3] 返回c✧求导时间复杂度O（n）输出参数：返回一个新一元多项式a输入参数：无[1] 从第一项开始，直到最后一项，如果指数不等于零，则a的对应项系数等于现有项系数乘以现有项指数，a的对应项指数等于现有项指数减一[2] 返回a✧乘法时间复杂度O（mn）输出参数：返回一个新一元多项式 c输入参数：两个一元多项式PolyList类对象的引用a、b[1] 从a的第一项开始，直至最后一项，逐项和b相乘[2] 将每一次相乘得到的多项式相加，并把相加的结果赋给c[3] 返回c✧求值时间复杂度O（n）输出参数：返回一个float型数输入参数：输入一个float型数[1] 从第一项开始，直至最后一项，依次计算每一项的值[2] 将每次计算得到的结果相加，并把相加结果赋给value[3] 返回value3. 程序运行结果1、测试主函数流程：流程图如图所示2、测试条件1)输入项数应少于100项2)输入多项式项数是大于零的整数3)输入多项式时，要从低次项到高次项依次逐项输入，先输入系数，再输入指数4)按屏幕提示输入3、测试结论1)程序可以实现多项式的输入输出操作2)程序可以进行多项式的加减乘及求导和求值运算4. 总结1.调试时出现的问题及解决方法1)问题：main函数中，在定义term结构数组时使用整型n，m变量作为数组的长度遇到系统报错解决方法：为数组申请动态内存2)问题：main函数中，当输入多项式项数小于1时无法报错解决方法：在用户输入完毕后增加if判断语句来实现报错3)问题：用户无法循环输入多项式解决方法：在程序末尾增加按键判断语句，如果用户选择要重新输入多项式则返回程序开头重新执行，否则程序结束2.心得体会1）通过这次编程练习，我加深了对顺序表的理解与运用。
[计算机]一元多项式相加完整实验报告
![[计算机]一元多项式相加完整实验报告](https://img.taocdn.com/s3/m/e064b28a33d4b14e84246841.png)
[计算机]一元多项式相加完整实验报告一元多项式的相加一实验内容根据所学的数据结构中线性结构(线性表)的逻辑特性和物理特性及相关算法，应用于求解一个具体的实际问题----------两个多项式相加二需求分析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输出已输出的多项式否是否输入正确合并同类项结束四详细设计根据一元多项式相加的运算规则:对于两个一元多项式中所有指数相同的项，对应系数相加，若其和不为零，则构成“和多项式”中的一项，对于两个一元多项式中所有指数不相同的项，则分别复抄到“和多项式”中去。
数据结构《一元多项式》
一元多项式相加问题实验报告本实验的目的是进一步熟练掌握应用链表处理实际问题的能力。
一、问题描述通过键盘输入两个形如Po+P₁X¹+P₂X²+…+PX的多项式，经过程序运算后在屏幕上输出它们的相加和。
二、数据结构设计分析任意一元多项式的描述方法可知，一个一元多项式的每一个子项都由“系数-指数”两部份组成，因此可将其抽象为包含系数coef、指数 exp、指针域next 构成的链式线性表。
对多项式中系数为0的子项可以不记录它的指数值，将两个多项式分别存放在两个线性表中，然后经过相加后将所得多项式存放在一个新的线性表中，但是不用再开辟新的存储空间，只依靠结点的挪移来构成新的线性表，期间可以将某些不需要的空间回收。
基于这样的分析，可以采用不带头结点的单链表来表示一个一元多项式。
具体数据类型定义为：struct nodefloat coef;//系数域int exp; //指数域struct node *next;};三、功能函数设计1、输入并建立多项式的功能模块具体函数为node *in f un()此函数的处理较为全面，要求用户按照指数递增的顺序和一定的输入格式输入各个系数不为0的子项，输入一个子项建立一个相关结点，当遇到输入结束标志时住手输入。
关键步骤具体如下：(1)控制用户按照指数递增的顺序输入r=a;while(r!=q->next)if(y<=r->exp)cout<<"请按照指数递增顺序输入，请重新输入";cin>>x>>y;break;r=r->next;从头开始遍历，若遇到目前输入的指数不是最大时，就跳出循环，让用户重新输入。
(2)当输入的系数为零时，不为其分配存储空间存储while(x==0){cin>>x>>y;continue;}即若系数为0,再也不进行动态分配并新建结点，而是重新提取用户输入的下一个子项的系数和指数，利用continue 进入下一次循环。
实验2 一元多项式运算
实验1一元稀疏多项式运算（6学时）1.实验目的了解线性表的链式存储结构的特性，熟练掌握线性表的链式存储结构的描述方法并能灵活到运用到一元多项式的操作熟练。
2.实验内容完成如下操作：①输入并建立一元稀疏多项式；（输入格式自定）例如：4-2x=12x^3+123x^5-80x^10②输出所建立的一元多项式；（输出格式自定）例如：12-3x+x^3+230x^12③实现两个多项式相加运算并输出；.④实现两个多项式相减运算并输出；3．实验要求程序运行后，显示一个文本方式的用户界面：==================================================一元多项式运算0：退出；1：输入并建立多项式；2：输出多项式；3：两个多项式相加运算并输出；4：两个多项式相减运算并输出=================================================请选择：等待用户输入0~4数字后，即进入相应的操作。
部分参考程序#include “stdio.h”#define OK 1#define ERROR 0typedefint Status;typedefstructT {intc;inte;struct T *next ;} Pnode, *Plinklist;Plinklist L0;//头指针/************ 初始化一元多项式************/ Plinklist Init_P( ){ Plinklist L; //先建立头结点L=(Pnode * ) malloc ( sizeof(Pnode));If (!L){ printf(“无法建立空表“)；exit(0); };L->c=0; //暂时保留多项式的项数=0L->next=NULL:return L;}/************ 建立一元多项式************/ Plinklist Creat_P(){ int n, cof, exp ;Pnode *L, *s, *p;L=Init_P( );printf(“输入项数n= ”);scanf(“%d”,&n);L->c=n;//暂时保留多项式的项数p=L;while(n>0){ printf(“输入系数指数”);scanf(“%d %d”,&cof, &exp);s=(Pnode * ) malloc( sizeof(Pnode));if(!s) return ERROR;s->c=cof;s->e=exp;s->next=NULL;p->next=s;p=s;// P总是指向链表中最后一个结点n--;}return L;}/************ 输出一元多项式************/void Pint_P( Plinklist L){int n, cof, exp ;Pnode *s, *p;n=L->c;//取出多项式的项数p rintf(“ %d \n”, n);p=L->next;while(p){cof=p->c; exp=p->e;printf(“(%d %d)\n”, cof, exp);p=p->next;}}/************ 多项式相加并输出************/ Plinklist Add_P ( ){ intcof, exp1, exp2,n=0 ;Plinklist L1, L2;Pnode *p1, *p2, *p, *tmp;L1=Init_P( ); L1=Creat_P();L2=Init_P( ); L2=Creat_P( );p1=L1->next; p2=L2->next;p = L1;while( p1 && p2){ exp1 = p1->e; exp2 = p2->e;if (exp1 <exp2)// (1){ p→next=p1; n++;p=p1; p1=p1->next; }elseif (exp2< exp1)// (2){ p→next=p2; n++;p=p2; p2=p2->next; }else// (3) 指数相等{ cof=(p1->c) +(p2->c);// 系数相加if (cof)//相加后系数不等于0{ p1->c=cof; p->next=p1;p=p1; p1=p1->next; n++;tmp=p2; p2=p2->next;free(tmp); //释放2的结点} else// 相加后系数等于0{ tmp=p1; p1=p1->next;free(tmp);//释放1的结点tmp=p2; p2=p2->next;free(tmp); //释放2的结点}}} //whilewhile(p1){ n++; p->next=p1;p1=p1->next; }// 1的剩余的项直接链过去while(p2){ n++; p->next=p2;P2=p2->next; }// 2的剩余的项直接链过去free(L2);//释放2的头结点L1->c=n;return L1;}/************ 多项式相减并输出************/ Plinklist Sub_P ( ){ intcof, exp1, exp2 , n=0;Plinklist L1, L2;Pnode *p1, *p2, *p, *tmp;L1=Init_P( ); L1=Creat_P( );L2=Init_P( ); L2=Creat_P( );p1=L1->next; p2=L2->next;p = L1;while( p1 && p2){ exp1 = p1->e; exp2 = p2->e;if (exp1 <exp2) // (1){ p→next=p1; n++;p=p1; p1=p1->next; }elseif (exp2 < exp1) // (2){ p→next=p2; p->c = -(p->c);n++;p=p2; p2=p2->next; }else // (3) 指数相等{ cof=(p1->c) - (p2->c);// 系数相减if ( cof )//系数不等于0{ p1->c=cof; p->next=p1; n++;p=p1; p1=p1->next; tmp=p2; p2=p2->next;free(tmp); }else // 系数等于0{ tmp=p1; p1=p1->next;free(tmp);tmp=p2; p2=p2->next; free(tmp); }}} //whilewhile (p1) { p->next=p1; n++;p1=p1->next; }while(p2) { p->next=p2; n++;p2=p2->next; }free(L2);L1->c=n;return L1;}/************ 主函数************/int main (){ intch;while(1){ printf(“ 0：退出\n”);p rintf(“ 1：输入并建立多项式\n”)；p rintf(“ 2：输出多项式\n”)；p rintf(“3：两个多项式相加运算并输出\n”)；p rintf(“4：两个多项式相减运算并输出\n”);printf（“请输入：”）;scanf(“%d”, &ch);switch(ch){ case 0: exit(0);case 1: L0=Creat_P (); break;case 2: Pint_P (L0 ); break;case 3: L0=Add_P ();Pint_P (L0 ); break;case 4: L0=Sub_P ();Pint_P (L0 );}//switch} //whilesystem(“pause”);return 0;}数据结构(3)--线性表实现一元多项式加法发表于2016/2/5 0:00:38 2822人阅读分类：数据结构参考书籍：数据结构（C语言版）严蔚敏吴伟民编著清华大学出版社1.简要说明一元多项式的表示和相加多项式Pn(x)按升幂可写成：Pn(x) =P0+P1*x+p2*x^2+...+Pn*x^n,它由n+1个系数唯一确定，因此可用一个线性表p=(p0,p1,p2,...,pn),每一项的指数i隐含在系数pi 的序号里。
一元多项式相加实验报告
一元多项式相加实验报告一元多项式相加实验报告引言：一元多项式是高中数学中的重要概念，它在代数运算中具有广泛的应用。
本次实验旨在通过实际操作，探究一元多项式的相加规律，并验证其正确性。
实验步骤：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。
可以看出，相加结果的次数和系数分别是两个一元多项式次数和系数的相加。
结果分析：从实验结果中可以发现，一元多项式相加的规律是将相同次数的项的系数相加，并保留该次数的项。
这与我们在学习一元多项式时所掌握的知识是一致的。
通过实验操作，我们验证了一元多项式相加的正确性。
实验总结：本次实验通过实际操作验证了一元多项式相加的规律，加深了对一元多项式的理解。
在实验过程中，我们还发现了一些注意事项。
首先，要注意相加过程中的计算准确性，尤其是在涉及到多项式次数较高时。
其次，要注意对相加结果进行化简，以便更好地观察和分析。
最后，实验过程中要保持仔细和认真，确保实验结果的可靠性。
结论：通过本次实验，我们验证了一元多项式相加的规律，并得出了相加结果的特点和规律。
一元多项式相加是代数运算中的重要内容，掌握相加规律对于深入理解和应用一元多项式具有重要意义。
实验报告一元多项式
实验报告一元多项式实验报告：一元多项式引言：一元多项式是数学中的重要概念，它在代数学、数论、几何学等领域都有广泛的应用。
本实验旨在通过实际计算和推导，深入探讨一元多项式的特性和运算规则。
一、一元多项式的定义和表示一元多项式是指只含有一个变量的多项式。
一元多项式的一般形式为：P(x) = a_nx^n + a_{n-1}x^{n-1} + ... + a_1x + a_0，其中 a_n, a_{n-1}, ..., a_1, a_0 是常数系数，x 是变量。
一元多项式可以用系数和指数的形式表示，如 P(x) = 2x^3 + 3x^2 - 5x + 1。
二、一元多项式的运算规则1. 加法和减法：一元多项式的加法和减法运算与普通数的加法和减法类似，只需将相同次数的项合并即可。
例如，P(x) = 2x^3 + 3x^2 - 5x + 1 和 Q(x) = x^3 - 4x^2 + 2x + 3 的和为 R(x) = 3x^3 - x^2 - 3x + 4。
2. 乘法：一元多项式的乘法运算需要将每一项的系数相乘，并将指数相加。
例如，P(x) = 2x^3 + 3x^2 - 5x + 1 和 Q(x) = x^2 - 2x + 3 的乘积为 R(x) = 2x^5 - x^4 + 5x^3 - 11x^2 + 4x + 3。
3. 除法：一元多项式的除法运算可以通过长除法进行。
将除式的最高次项与被除式的最高次项相除，得到商的最高次项，并将商乘以除式后与被除式相减，得到新的被除式。
重复这个过程，直到被除式的次数小于除式的次数为止。
例如，将 P(x) = 2x^3 + 3x^2 - 5x + 1 除以 Q(x) = x^2 - 2x + 1，得到商 S(x) = 2x+ 5 和余数 R(x) = -3x + 6。
三、一元多项式的因式分解一元多项式的因式分解是将多项式表示为若干个不可再分解的因式的乘积。
常见的因式分解方法有提公因式法、配方法和求根法等。
一元多项式实验报告
实验二一元多项式相加问题本实验的目的是进一步熟练掌握应用链表处理实际问题的能力。
一、【问题描述】一元多项式相加是通过键盘输入两个形如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中就不用分配新的空间来进行存储了。
数据结构实验-一元多项式的加法运算
一元多项式加法一、实验目的通过实现多项式加法，对链表有更深入的了解二、实验内容问题描述：设计一个一元稀疏多项式简单的加法计算器实现要求：一元稀疏多项式简单计算器的基本功能是：（1）输入并建立多项式：1785937)(x x x x A +++=；879228)(x x x x B -+=（2）输出多项式（3）多项式A 和B 相加，建立多项式C ＝A ＋B ，并输出相加的结果多项式C（4）选作：多项式A 和B 相减，建立多项式C ＝A －B ，并输出相减的结果多项式D 方法说明：（1）多项式的输入与存储用带表头结点的单链表存储多项式，链表中的每个节点分别存储多项式各项的系数和指数，即每从键盘输入多项式的一对数（系数，指数），可对应建立链表的一个结点。
每个节点的结构为：建立两个链表，其中pa 和pb 分别为它们的头指针：pb结果链表Pa(或者是Pc)Pc（2）多项式数据类型的定义struct tagNode{float coef;int exp;struct tagNode *next;typedef struct tagNode Node;typedef struct tagNode* pNode;（3）主要算法①创建两个链表，分别存放多项式1和多项式2，这两个链表中的节点是按指数降序或者升序排列的②多项式相加，下面给出多项式相加的部分实现/*下面的函数实现两个多项式的相加，要相加的链表分别由pa和pb指向（其中，pa，pb都是分配了空间的头结点）。
相加的结果直接由pa指向的链表保存，即是在pa链表中添加或删除（当系数因为相加为0的情况下）一些结点，构成结果。
相加的链表中指数按从小到大的顺序排列好的，是升序链表。
*/void add_poly(Node *pa,Node *pb){Node *p=pa->pNext;//链表1，将来的结果也放在此Node *q=pb->pNext;//链表2Node *pre=pa;Node *u;//临时用float x;while (p!=NULL && q!=NULL)//当两个链表都不为空{if (p->exp<q->exp)//比较链表1跟链表2当前节点的指数大小，链表1也是存放结果的地方{pre=p;p=p->pNext;//p指向要比较的下一个结点。
一元多项式计算实验报告
计算机学院工程实践一元多项式的计算总报告小组序号：编撰人：年级班级：指导教师：提交日期：1. 项目组成员分工表 1 项目组成员分工2. 程序功能(程序实现的功能，功能结构图)实现功能：一元多项式的加、减、乘运算 功能结构图：乘减加创建多项式开始保存结束3. 程序设计简介(包括：类及其属性和方法、类之间关系、关键代码等的说明)1.class Node{public:Node();Node(float c, int e, Node* next);~Node(){};float coef; //系数int exp; //指数Node* Next; //指向下一项的指针friend class Polynominal;};节点类，储存一元多项式每一项的信息。
该内含有两个构造函数，一个析构函数及存储系数、指数和Next指针等成员变量。
与Polynominal是友元关系，允许Polynominal的访问。
具体成员函数如下：1)Node::Node(){}默认构造函数。
2)Node::Node(float c, int e, Node* next){coef = c;exp = e;Next = next;}重载的自定义构造函数，用于给成员变量coef、exp和Next存入数据，Next指向传参来的next指针指向的地址，用于构造链表。
2.class Polynominal{public:Polynominal();Polynominal(Polynominal &a); //拷贝构造函数void GetMSG(CString TempPloy); //获取由对话框输入的字符串并处理CString Output_Node(); //输出最后结果void PolyAdd(Polynominal &a, Polynominal &b); //加法void PolySubtract(Polynominal &a, Polynominal &b); //减法void PolyMultiply(Polynominal &a, Polynominal &b); //乘法void PolySort(); //排序函数，用于乘法之后的按指数排序void OutFile(); //文本输出函数void OutFile(Polynominal &a, Polynominal &b, string ch); //重载文本输出函数void OpposeCoef(Polynominal &a, Node *temp); //系数取反，用于减法运算Node theList; //头节点ofstream FOut; //输出流};此类用于构造一元多项式。
一元多项式实验报告
武汉工程大学计算机科学与工程学院__数据结构__课程实验报告专业班级：学号：学生姓名：实验室：指导教师：成绩：日期：_2012_年__5_月_22_日第__十五_周星期_二_节次_9-10_程序运行结果：程序代码：# include <stdio.h># include <malloc.h># include <stdlib.h>typedef struct Polynomial{float coef; //系数int exp; //指数struct Polynomial * next;}S, *ps; //S等价于struct Polynomial，ps等价于struct Polynomial *ps creat(void); //初始化链表S并返回一个头指针void sort(ps S); //链表排序void print(ps p); //输出链表ps PolyAdd(ps pa, ps pb); //求和int main(void){ps p = NULL, q = NULL;printf("一元多项式P(x)：\n");p = creat();printf("排序前：\n");printf("P(x) = ");print(p);printf("排序后：\n");sort(p);printf("P(x) = ");print(p);printf("\n\n");printf("一元多项式Q(x)：\n");q = creat();printf("排序前：\n");printf("Q(x) = ");print(q);printf("排序后：\n");sort(q);printf("Q(x) = ");print(q);printf("\n\n");p = PolyAdd(p, q);printf("P(x) + Q(x) = ");print(p);return 0;}ps creat(void){int len, e;float c;ps head = (ps)malloc(sizeof(S));if(NULL == head){printf("动态内存分配失败\n");exit(-1);}ps tail = head;tail->next = NULL;printf("\t输入该多项式的项数：");scanf("%d", &len);for(int i=0;i<len;i++){ps pNew = (ps)malloc(sizeof(S));printf("\t分别输入第%d项的系数与指数：", i+1);scanf("%f %d", &c, &e);pNew->coef = c;pNew->exp = e;if(NULL == pNew){printf("动态内存分配失败\n");exit(-1);}tail->next = pNew;pNew->next = NULL;tail = pNew;}return head;}void print(ps p) //输出多项式{ps printing;int flag=0;printing=p->next;//正在被打印的链节if(p->next==NULL)//如果函数为空打印0{printf("0\n");return;}while(flag==0){if(printing->coef>0&&p->next!=printing)printf("+");//为正数时打印"+"号if(printing->coef==1);//如果为"1"就不用打印系数了else if(printing->coef==-1)printf("-");//如果为"-1"就打印"-"号就行了elseprintf("%0.2f",printing->coef);//其余情况都得打印if(printing->exp!=0) printf("x^%d",printing->exp);//如果指数为"0"不打印指数项else if((printing->coef==1)||(printing->coef==-1))printf("1");if(printing->next==NULL)flag=1;//如果现在的链节没有下一个就结束elseprinting=printing->next;}printf("\n");}void sort(ps S) //链表排序{ps p = S->next; //p指向第一个结点ps q,r;if(p != NULL) //若原单链表中有一个或一个以上的结点{r = p->next; //r保存*p结点直接后继结点的指针p->next = NULL; //构造只含一个结点的有序表p = r;while(p != NULL){r = p->next;q = S;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; //扫描原单链表余下的结点}}}ps PolyAdd(ps pa,ps pb) //求和{ps p,q,r,s;float x;p=pa->next;r=pa;q=pb->next;free(pb);while(p!=NULL&&q!=NULL)if(p->exp<q->exp){r=p;p=p->next;}else if(p->exp==q->exp){x = p->coef+q->coef;if(x==0){r->next=p->next;free(p);}else{p->coef=x;r=p;}p=r->next;s=q->next;free(q);q=s;}else{s=q->next;r->next=q;q->next=p;r=q;q=s;}if(q!=NULL)r->next=q;return(pa);}。
一元多项式相加的实验报告
《数据结构》实验报告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）测试结果分析：程序运行结果和预测的完全相同，说明所设计的一元多项式的加法是正确的。
一元多项式的运算 实验报告和代码
一．问题描述：设Pn (x)和Qm(x)分别两个一元多项式。
试编写程序实现一元多项式的加法运算。
二．需求分析：1. 本程序需要基于线性表的基本操作来实现一元多项式的加法，也可以用数组实现。
2．两个多项式都有键盘输入相应的系数和指数。
3．//第一个多项式为9x15+ 7x8+5x3+3x输入4 //表示第一个多项式的项数9，15（回车）//表示9x157，8 （回车）5，3 （回车）3，1 （回车）输出9x^15+ 7x^8+5x^3+3x^1//第二个多项式为-7x8+6x3+2输入3 //表示第二个多项式的项数6，3（回车）//表示9x15-7，8（回车）2，0 （回车）输出-7x^8+ 6x^3+2x^0求和结果9x^15+11x^3+3x^1+ 2x^0三．概要设计抽象数据类型：为实现上述程序的功能，应以整数存储用户的输入，以及计算的结果。
实现多项式的运算，利用数组的方式需开辟一个二维数组，利用链表的方式须创造两个链表。
算法的基本思想：数组实现：定义一个结构体数组,p存储系数,q存储指数。
分别输出两次输入的多项式。
将两次输入的多项式的指数按从大到小的顺序进行排列，同时相应的系数要进行交换。
输出时如果进行判断。
如果当前该项与下一项的的系数相同，将两项系数相加后输出，并跳过下一项。
如果不相等，直接输出。
输出时需注意的问题：当系数为0时，该项不输出当系数为负数时，不要再在前面输出+。
链表实现：定义一个结构体，分别用exp，coef来存储系数和指数，同时在结构体里面定义一个该结构类型指针。
对输入的第一个多形式和第二个多项式分别构建一个链表（按指数的大小）输出时，通过比较两个链表当前位置的指数大小，相同，系数相加后输出，两个链表同时向前推进。
如果其中一个大，只输出较大项，同时将其推进。
程序的流程：（1）输入模块：完成两个多项式的输入。
（2）处理模块：将多项式按其指数大小进行排列。
（3）输出模块：输出合并后的多项式。
一元多项式实验报告
一元多项式实验报告一元多项式实验报告引言：一元多项式是高中数学中的重要概念之一，它在代数学、几何学以及其他数学领域中都有广泛的应用。
通过实验，我们可以深入了解一元多项式的性质和运算规则，并且探索其在实际问题中的应用。
实验一：多项式的表示和运算1. 实验目的通过实验，了解多项式的表示方法和基本运算规则。
2. 实验步骤a) 多项式的表示方法选择一个简单的多项式，如3x^2 + 2x - 1，通过观察和分析，了解多项式的系数、次数和项的概念。
b) 多项式的加法和减法选择两个多项式，如2x^3 + 3x^2 - 4x + 1和x^2 + 2x - 3，进行多项式的加法和减法运算，并观察运算结果。
c) 多项式的乘法选择两个多项式，如(x + 1)(x - 2)和(2x - 1)(3x + 2)，进行多项式的乘法运算，并观察运算结果。
3. 实验结果与分析通过实验，我们可以发现多项式的表示方法是以字母和指数的形式来表示，其中字母代表未知数，指数代表该项的次数。
多项式的加法和减法运算与常规的数学运算类似，只需按照相同次数的项进行系数的加减运算。
多项式的乘法运算需要将每个项进行相乘，并按照指数的规则进行合并。
实验二：多项式的因式分解和求根1. 实验目的通过实验，了解多项式的因式分解和求根的方法。
2. 实验步骤a) 多项式的因式分解选择一个多项式，如x^2 + 3x + 2，通过观察和分析，尝试将其进行因式分解。
b) 多项式的求根选择一个多项式，如x^2 - 4，通过观察和分析，尝试求解其根的值。
3. 实验结果与分析通过实验，我们可以发现多项式的因式分解是将多项式拆解为若干个乘积的形式，每个乘积中的因子是多项式的一个因式。
多项式的求根是找到使得多项式等于零的未知数值，即方程的解。
通过因式分解和求根，我们可以进一步了解多项式的性质和特点。
实验三：多项式在实际问题中的应用1. 实验目的通过实际问题，探索多项式在实际应用中的作用。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
计算机学院工程实践一元多项式的计算总报告小组序号：编撰人：年级班级：指导教师：提交日期：1. 项目组成员分工表 1 项目组成员分工2. 程序功能(程序实现的功能，功能结构图)实现功能：一元多项式的加、减、乘运算 功能结构图：乘减加创建多项式开始保存结束3. 程序设计简介(包括：类及其属性和方法、类之间关系、关键代码等的说明)1.class Node{public:Node();Node(float c, int e, Node* next);~Node(){};float coef; //系数int exp; //指数Node* Next; //指向下一项的指针friend class Polynominal;};节点类，储存一元多项式每一项的信息。
该内含有两个构造函数，一个析构函数及存储系数、指数和Next指针等成员变量。
与Polynominal是友元关系，允许Polynominal的访问。
具体成员函数如下：1)Node::Node(){}默认构造函数。
2)Node::Node(float c, int e, Node* next){coef = c;exp = e;Next = next;}重载的自定义构造函数，用于给成员变量coef、exp和Next存入数据，Next指向传参来的next指针指向的地址，用于构造链表。
2.class Polynominal{public:Polynominal();Polynominal(Polynominal &a); //拷贝构造函数void GetMSG(CString TempPloy); //获取由对话框输入的字符串并处理CString Output_Node(); //输出最后结果void PolyAdd(Polynominal &a, Polynominal &b); //加法void PolySubtract(Polynominal &a, Polynominal &b); //减法void PolyMultiply(Polynominal &a, Polynominal &b); //乘法void PolySort(); //排序函数，用于乘法之后的按指数排序void OutFile(); //文本输出函数void OutFile(Polynominal &a, Polynominal &b, string ch); //重载文本输出函数void OpposeCoef(Polynominal &a, Node *temp); //系数取反，用于减法运算Node theList; //头节点ofstream FOut; //输出流};此类用于构造一元多项式。
包括加、减、乘各各功能函数，还有两个帮助运算的辅助函数，以及界面输入输出和文本输出函数。
成员变量有头节点和输出流。
具体成员函数如下：1)Polynominal::Polynominal(){}默认构造函数2)Polynominal::Polynominal(Polynominal &a){Node* temp = a.theList.Next;Node* tempNode = &theList;for (; temp != NULL;){tempNode->Next = new Node(temp->coef, temp->exp, NULL);temp = temp->Next;tempNode = tempNode->Next;}}拷贝构造函数，用于计算时对象间的赋值，防止误改数据。
3)void Polynominal::GetMSG(CString TempPoly){TempPoly.Remove(_T('^'));Node* TempNode = &theList;int i = 0;for (i;i<TempPoly.GetLength(); ){CString temp1 ;CString temp2 ;int j = 1;if (TempPoly.GetAt(i) ==_T('-')){temp1 = temp1 + TempPoly.GetAt(i);i++;}if (TempPoly.GetAt(i) == _T('+')){i++;}if (TempPoly.GetAt(i) == _T('x') ){temp1 = temp1 +_T('1');}while(j==1){if (TempPoly.GetAt(i) != _T('x')){temp1 = temp1 + TempPoly.GetAt(i);i++;}else j=0;}i++;if (i <(TempPoly.GetLength()-1) && TempPoly.GetAt(i) == _T('-')){ temp2 = temp2 + TempPoly.GetAt(i);i++;}if (i == (TempPoly.GetLength()-1) && TempPoly.GetAt(i) == _T('x')) temp2 = temp2 + _T('1');else{if (i == TempPoly.GetLength() && TempPoly.GetAt(i-1) == _T('x')) temp2 = temp2 + _T('1');else{while (i < TempPoly.GetLength() && TempPoly.GetAt(i) != _T('+') && TempPoly.GetAt(i) != _T('-')){temp2 = temp2 + TempPoly.GetAt(i);i++;}}}TempNode->Next = new Node(_ttof(temp1), _ttoi(temp2), NULL); //链表构建TempNode = TempNode->Next;}}此函数用于把从对话框获取的字符串进行处理，截取出多项式各项系数和指数，并转换为float型和int型，构造一元多项式链表。
4)CString Polynominal::Output_Node(){int first = 0;CString temp;CString temp_coef;CString temp_exp;Node* TempNode = theList.Next;for (; TempNode != NULL; TempNode = TempNode->Next){if (first == 1 && TempNode->coef > 0) temp = temp + _T("+") ;temp_coef.Format(_T("%g"), TempNode->coef);temp_exp.Format(_T("%d"),TempNode->exp);switch (TempNode->exp){case 0:temp = temp + temp_coef; break; //指数为0则推出case 1:if (TempNode->coef==1) //指数为1则直接输出Xtemp = temp + _T("x");else temp = temp + temp_coef + _T("x");break;default:if (TempNode->coef == 1) //其余指数输出“X^”形式temp = temp + _T("x")+temp_exp;else temp = temp + temp_coef + _T("x^")+temp_exp;break;}first = 1;}return temp;}输出函数，将计算所得结果输出到对话框。
5)void Polynominal::PolyAdd(Polynominal &a, Polynominal &b){Node *p, *q, *temp;temp = &theList;p = a.theList.Next;q = b.theList.Next;while (p != NULL && q != NULL){if ((p->exp) > (q->exp)){temp->Next = new Node(p->coef, p->exp, NULL);temp = temp->Next;p = p->Next;}else if ((p->exp) == (q->exp)){temp->Next = new Node(p->coef + q->coef, p->exp, NULL);temp = temp->Next;p = p->Next;q = q->Next;}else if ((p->exp) < (q->exp)){temp->Next = new Node(q->coef, q->exp, NULL);temp = temp->Next;q = q->Next;}}if (q != NULL){while (q != NULL){temp->Next = new Node(q->coef, q->exp, NULL);temp = temp->Next;q = q->Next;}}if (p != NULL){while (p != NULL){temp->Next = new Node(p->coef, p->exp, NULL);temp = temp->Next;p = p->Next;}}}加法函数，实现多项式的相加。
在其中需要判断各项指数的关系，已实现按指数大小关系构建链表。