一元多项式相加问题的实验报告
一元多项式的相加实验报告
一元多项式的相加实验报告一元多项式的相加实验报告引言：一元多项式是数学中常见的概念，它由一个变量和一系列常数乘积的和组成。
在本实验中，我们将研究一元多项式的相加运算，并通过实验验证相加运算的性质和规律。
实验目的：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. 一元多项式的相加运算满足交换律和结合律。
实验报告——一元稀疏多项式的加法
程序2：一元稀疏多项式加法运算［问题描述］设计一个求解一元稀疏多项式加法运算的程序。
［基本要求］（1）输入并建立多项式。
（2）输出多项式，输出形式为整数序列：n,c1,e1,c2,e2,…,c n,e n,其中n是多项式的项数，c i和e i分别是第i项的系数和指数，序列按指数降序排列。
（3）多项式a和b相加，建立多项式a＋b［算法实现］#include<stdio.h>#include<stdlib.h>typedef struct Node{int cofe;//系数域int expn;//指数域struct Node *next;}LNode,*LinkList;void InitList(LinkList &L)//初始化{L=(LinkList)malloc(sizeof(LNode));if(!L)exit(0);L->next=NULL;}int Input(LinkList &L)//输入{LinkList p;int i=0;p=(LinkList)malloc(sizeof(LNode));L->next=p;printf("输入多项式的系数与指数，按“系数指数”格式，且指数按从小到大顺序输入，以(0 0)结束：\n");while(1){scanf("%d %d",&p->cofe,&p->expn);if((p->cofe)==0)break;p->next=(LinkList)malloc(sizeof(LNode));p=p->next;++i;}p->next=NULL;return i;}void Output(LinkList &L)//输出{LinkList p;p=L->next;printf("多项式为：\n");if((p->expn)==0)printf("%d",p->cofe);else if(p->expn==1)printf("%dx",p->cofe);else if((p->cofe)==1||(p->cofe)==-1){if((p->cofe)==1)printf("x^%d",p->expn);else if((p->cofe)==-1)printf("-x^%d",p->expn);}elseprintf("%dx^%d",p->cofe,p->expn);p=p->next;for(;(p->cofe!=0);p=p->next){if((p->expn==0)&&(p->cofe!=0)){if((p->cofe)>0)printf("+%d",p->cofe);else if((p->cofe)<0)printf("%d",p->cofe);}else if((p->expn==1)&&(p->cofe==1))printf("+x",p->cofe);else if((p->cofe)==1||(p->cofe)==-1){if((p->cofe)==1)printf("+x^%d",p->expn);else if((p->cofe)==-1)printf("-x^%d",p->expn);}else if((p->cofe)>0)printf("+%dx^%d",p->cofe,p->expn);else if((p->cofe)<0)printf("%dx^%d",p->cofe,p->expn);}printf("\n");}void Add(LinkList &L1,LinkList L2)//计算L1，L2的和，放入L1{LinkList p,q,per,r;//p为指向L1的指针，p2为指向L2的指针,per指向p的前驱,r 为中间变量int x;//存放和的结果p=L1->next;q=L2->next;per=L1;while((p!=NULL)&&(q!=NULL))if((p->expn)>(q->expn))//p的指数大于q的指数，将q插到p之前{r=q->next;q->next=p;//先让q的next指向p，并将q的next存入rper->next=q;per=q;q=r;//再让p的前驱的next指向q，此时，q就成为p 的前驱，所以令per=q，q（前驱）的next指向q原来的next}else if((p->expn)==(q->expn)){x=(p->cofe)+(q->cofe);//求和if(x!=0)//和不为0，代替原值，并将p做为先驱（为下次计算做准备）{p->cofe=x;per=p;}else//和为0，释放p结点：将p前驱的next指向p的next，再释放p的空间即可{per->next=p->next;free(p);}p=per->next;r=q;q=q->next;free(r);//将q向后移一位}else if((p->expn)<(q->expn))//p的指数小于q的指数，将q插到p之后{per=p;p=p->next;}if(q!=NULL)//将q中多余的项（即指数在p中没有的）移入p的后面per->next=q;free(L2);//释放：L2}void main(){LinkList L1,L2;int i,j;printf("输入L1：");InitList(L1);i=Input(L1);printf("共%d项\n",i);Output(L1);printf("\n");printf("输入L2：");InitList(L2);j=Input(L2);printf("共%d项\n",j);Output(L2);printf("\n");Add(L1,L2);printf("L1与L2的和");Output(L1);printf("\n");}[实验结果]。
一元多项式相加问题实验报告
一元多项式相加问题实验报告一元多项式相加问题一、问题描述通过键盘输入两个形如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 为头指针的一个新链表中。
一元多项式相加实验报告
一元多项式相加实验报告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而言，每一个子项都是由“系数”和“指数”两部分来组成的，因此可将多项式抽象成一个“系数、指数对”构成的线性表，其中多项式的每一个系数非零的子项作为线性表中的一个元素。
两个一元多项式相加-c++版
《数据结构》实验报告——两个一元多项式相加一、实验题目：两个一元多项式相加二、实验内容：根据所学的数据结构中线性结构（线性表）的逻辑特性和物理特性及相关算法，应用于求解一个具体的实际问题----------两个多项式相加三、设计思想：（1）建立两个顺序列表，分别用来表示两个一元多项式；顺序列表奇数位，存储该多项式的系数；顺序列表的偶数位，存储该相应多项式的指数。
（2）用成员函数merg(qList<Telem>&l2)实现两多项式的相加。
实现的大致方法为：比较第二个多项式列表与第一个多项式列表的偶数位的数值大小（指数），如果相同，则将他们的前一位数（系数）相加；如果不同，就将他的前一位数（系数）及它自己（指数）插入第一个多项式列表的后面。
（3）建立函数shu(double a[],int j)实现多项式的输入。
四、源程序代码#include "stdafx.h"#include<iostream>using namespace std;template<class Telem>class List{private:Telem * elem;int curlen;int maxlen;public:List(int maxsz=100):maxlen(maxsz){curlen=0;elem=new Telem{maxlen};};List(Telem a[],int n,int maxsz=100):maxlen(maxsz){curlen=n;elem=new Telem[maxlen];for(int i=0;i<n;i++)elem[i]=a[i];};~List(){delete[] elem;};Telem gete(int i){if(i>=1&&i<=curlen)return elem[i-1];else return NULL;};int leng(){return curlen;};List<Telem>&merg(List<Telem>&l2);//声明两多项式相加的成员函数};template<class Telem>List<Telem>&List<Telem>::merg(List<Telem>&l2)//两多项式相加的成员函数的实现{int i,j,m,n,k(0);m=curlen;n=l2.curlen;if(m+n<=maxlen){for(i=0;i<n/2;i++){for(j=0;j<m/2;j++)if(elem[2*j+1]==l2.elem[2*i+1]){k++;elem[2*j]+=l2.elem[2*i];break;}if(j==m/2){elem[m+2*(i-k)]=l2.elem[2*i];elem[m+2*(i-k)+1]=l2.elem[2*i+1];}}}curlen=m+n-2*k;return *this;}void fun(double a[],int j)//该函数实现：输入2j个double型的数，并将其存储到数组中{int i;for(i=0;i<j;i++){double m,n;cout<<"请输入第"<<i+1<<"项的系数和指数:";cin>>m>>n;a[2*i]=m;a[2*i+1]=n;}}void main(){int i,j,k;cout<<"第一个多项式的个数:";cin>>j;double *a=new double[2*j];fun(a,j);cout<<"第二个多项式的个数为:";cin>>k;double *b=new double[2*k];shu(b,k);List<double>s1(a,2*j);List<double>s2(b,2*k);s1.merg(s2);cout<<"二个多项式相加结果为：";for(i=1;i<=s1.leng()/2;i++)//用for循环将这二个多项式结果输出{cout<<s1.gete(2*i-1)<<"X^"<<s1.gete(2*i);if(i!=s1.leng()/2)cout<<"+";}cout<<endl;}五、程序运行结果截图。
[计算机]一元多项式相加完整实验报告
[计算机]一元多项式相加完整实验报告一元多项式的相加一实验内容根据所学的数据结构中线性结构(线性表)的逻辑特性和物理特性及相关算法，应用于求解一个具体的实际问题----------两个多项式相加二需求分析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输出已输出的多项式否是否输入正确合并同类项结束四详细设计根据一元多项式相加的运算规则:对于两个一元多项式中所有指数相同的项，对应系数相加，若其和不为零，则构成“和多项式”中的一项，对于两个一元多项式中所有指数不相同的项，则分别复抄到“和多项式”中去。
数据结构-实验一-一元多项式相加
数据结构实验报告实验一：一元多项式相加姓名：周成学号： 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、在建立链表和多项式相加时，新生成链表的头指针做为参数传递时，曾忽略了参数的标识“&”，致使建立链表失败。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
{
ﻩ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ｅ（ｑ)
ﻩﻩ{
ﻩﻩw＝ｑ;
q＝ｑ->next;
ﻩﻩr->next＝w；
ﻩr=w;
ﻩ}
}
⑸最后将c中的最后一个结点的指针域置为空,并返回c的地址。
⑴当(ｐ－>eｘp)＜(q－>ｅxｐ)时，操作如下:
w=p；
ﻩﻩｐ=p->nｅxｔ;
ﻩｒ-＞next=w;
ﻩr＝w;
即定义一个结点ｗ,将结点p赋给它,然后将p结点后移，指向a中下一个待处理结点,然后将ｗ移动到新生成链表ｃ的尾结点的后面,最后将ｗ赋给ｒ，使得r仍指向链表c的尾结点。
⑵当p->exp＞q->exp时,采取如下操作：
ﻩｐ＝ｐ－>nｅxt;
}
输出的多项式的形式形如：P1Ｘ^1+P２X^２+…＋PｎＸ^n
3、多项式相加的功能函数
函数为:node＊pｌｕs_fun(nｏｄe *a,nodｅ*ｂ)
此函数根据在1中初始化的两个多项式进行相加运算,并存放在以c为头指针的一个新链表中。
设指针p,q,ｒ分别指向描述多项式的链表a,b,c的头部,其中将a也赋给c。p,q两个指针同时移动,并根据p,q两结点对应的指数的大小采取不同的操作。
p－>ｃoｅf=x;
ﻩﻩｗ＝ｐ；
ﻩﻩﻩﻩp=p-＞ｎexｔ;
ﻩr－>next=w；
ﻩﻩr＝ｗ;
ﻩﻩw=q;
ﻩﻩﻩｑ=q->nｅxｔ；
delete w；
即将x的值赋给p的系数域,之后将结点ｐ赋给ｗ，然后将p结点后移，指向a中下一个待处理结点，然后将w移动到新生成链表ｃ的尾结点的后面，最后将ｗ赋给ｒ,使得r仍指向链表ｃ的尾结点。同时,将ｑ的内存空间释放，并使得ｑ指向b中下一个待处理结点。
⑵当输入的系数为零时，不为其分配存储空间存储
ｗhile(x==0) {ｃiｎ>>x＞>ｙ; cｏntｉnue;}
即若系数为0，不再进行动态分配并新建结点,而是重新提取用户输入的下一个子项的系数和指数,利用ｃｏntinｕe进入下一次循环。
⑶初始化完成后将最后一个结点的指针域置为空，并返回该新建链表的首地址。
一元多项式相加问题的实验报告
———————————————————————————————— 作者：
———————————————————————————————— 日期：
ﻩ
一元多项式相加问题
一、问题描述
通过键盘输入两个形如P0+Ｐ1X1+P2X2+…+PnX
的多项式，经过程序运后在屏幕上输出它们的相加和。
当x为0时，采取如下操作:
ﻩｗ=p;
p=p->next;
ﻩﻩdelete w；
ﻩﻩｗ=q;
ﻩﻩﻩq=ｑ->next;
ﻩﻩﻩｄelｅte w；
即将pq的空间释放，并分别使其指向各自链表中下一个待处理结点。
⑷当上面的循环进行完后，至少有一个链表已被遍历完，然后只需将另一个链表剩余的所有结点都移动到ｃ中即可。
对于正数,输出时在前面加“+”,头指针除外;对于负数，直接将系数输出即可,即：
ｐ=ａ;
ﻩ
wｈｉle(p)
ﻩ{
if(p=＝a)ｃout<<ｐ－>ｃｏｅf<<"*x^"<＜p－>ｅｘｐ；
ﻩeｌsｅif(p->ｃｏef<0) coｕt<<ｐ－>coｅf＜<"*x^"<<p－>ｅxp；
ﻩelseif(p->coeｆ＞０) cout<<＂+＂<<p->coｅｆ<＜"*ｘ^"<＜p->ｅxp;
ﻩintexp；//指数域
sｔｒuct node *ｎexｔ;
｝;
node*in＿fun（)
{
ｎｏde＊p,*a,*q，*r;
ﻩa=q=NUＬL;
fｌoatｘ;
int y;
cin＞＞x>>y;
ｗhile（ｘ!=０|｜ｙ!=0)
{
ﻩwhile(x=＝0)
⑴控制用户按照指数递增的顺序输入
ｒ=a;
wｈiｌe(r!=ｑ－＞next)
ﻩﻩ{
ﻩﻩif(y<=ｒ->eｘp）
ﻩ{
ﻩﻩﻩcout<＜＂请按照指数递增顺序输入，请重新输入";
ﻩﻩﻩｃｉn>>x>＞y；
ﻩﻩﻩbreaｋ；
ﻩ}
ﻩﻩr=r－>ｎext;
ﻩ｝
环，让用户重新输入。
r->ｎｅxt=NULＬ;
ﻩretuｒnc;
4、主函数功能设计
采用循环的形式可以多次进行两个多项式的初始化和求和。
四、界面设计
提示用户进行每一步操作以及每一步输出的内容，界面简明清晰。
五、运行与调试
六、源代码
#inｃlｕｄe<iostｒeaｍ.h＞
struct noｄe
{
flｏat coef；／/系数域
ﻩw=q;
q=q->ｎext；
r->ｎｅxｔ=w;
ﻩﻩr=ｗ;
即此时将q赋给w,然后使ｑ结点指向链表b中下一个待处理结点,然后将w移动到新生成链表c的尾结点的后面，最后将w赋给r,使得r仍指向链表c的尾结点。
⑶当p->eｘｐ=＝q->exｐ时，定义一个fｌoａt类型的变量x，当ｘ不为0时,采取如下操作: