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

合集下载

一元多项式的加法数据结构

一元多项式的加法数据结构一元多项式是数学中常见的一种代数表达式形式，由多个单项式按照一定的规则相加而成。

在计算机科学中，为了方便对一元多项式进行处理，需要定义一种合适的数据结构来表示和操作一元多项式的加法运算。

一元多项式的加法数据结构可以使用链表来实现。

每个节点表示一个单项式，包含两个成员变量：系数和指数。

系数表示单项式的系数，指数表示单项式的指数。

通过将多个单项式的系数和指数组织成一个链表，即可表示一个一元多项式。

在链表中，每个节点按照指数从小到大的顺序排列。

这样可以方便进行多项式的加法运算。

当两个一元多项式相加时，只需按照指数的大小依次比较两个链表中的节点，并根据指数的大小关系进行相应的操作。

具体的加法算法如下：1. 创建一个新的链表作为结果链表。

2. 初始化两个指针分别指向两个原始链表的头节点。

3. 循环比较两个链表中的节点，直到其中一个链表遍历完为止。

4. 比较当前节点的指数大小关系：- 如果两个节点的指数相等，将它们的系数相加，并将结果添加到结果链表中。

- 如果第一个链表中的节点指数较小，将第一个链表的节点添加到结果链表中，并将指针指向下一个节点。

- 如果第二个链表中的节点指数较小，将第二个链表的节点添加到结果链表中，并将指针指向下一个节点。

5. 当其中一个链表遍历完后，将另一个链表中剩余的节点依次添加到结果链表中。

6. 返回结果链表作为两个一元多项式相加的结果。

通过上述算法，可以实现对一元多项式的加法运算。

这种链表结构的一元多项式加法数据结构具有以下优点：- 灵活性：可以表示任意长度的一元多项式，不受固定数组长度的限制。

- 高效性：在添加节点和遍历节点时，时间复杂度为O(n)，其中n 为一元多项式的项数。

- 可扩展性：可以方便地扩展其他操作，如乘法、求导等。

除了链表结构，还可以使用数组等数据结构来表示一元多项式的加法。

不同的数据结构适用于不同的应用场景。

链表结构适合于插入和删除操作较多的情况，而数组结构适合于随机访问和内存占用较小的情况。

数据结构综合实验报告_一元多项式

目录1 设计内容和要求 (1)1.1设计要求 (1)1.2设计内容 (1)2 概要设计 (1)2.1程序主要流程 (1)3 详细设计 (3)3.1源程序 (3)4 调试分析 (8)5 总结 (9)6 致谢 (10)参考文献 (11)1 设计内容和要求1.1 设计要求编写一个实现多项式相加和相减的程序。

1、首先，根据键盘输入的一元实系数多项式的系数与指数序列，对多项式进行初始化，并按未知数x的降幂形式输出多项式的合理表示。

2、对于从键盘输入的任意两个一元多项式，正确计算它们的和以及差的多项式，并输出结果。

1.2 设计内容利用单链表表示一元多项式，然后实现各个项的系数和指数的输入，并且进行建立和输出，以及实现各个一元多项式之间的相加和相乘的操作。

2 概要设计实现的方法是先定义多项式结点的结构，该多项式每个结点由三个元素：输入的系数、输入的指数、以及指向下一个结点的指针构成。

该链表采用链式存储结构。

然后通过多次的输入，依次得到两个一元多项式的各个项的系数与指数。

该输入以零结尾。

然后通过对结点的判断是否为零后，进行相加或者终止的操作。

再初始化一个链表LC，将LC的各项系数和指数的指针指向LA+LB所得的结果的值，完成了最后的输出。

2.1程序主要流程建立链表,将多项式的系数与数指数作为链表节点的数据；指示输入两个多项式的数据,分别存在LA与LB中；利用Getlength(PotyNode *L)函数计算出LA与LB的表长；使用循环语句进行两链表的相应数据相加,并将所得到的新链表存放到LC中；打印输出。

如图2－1就是程序主流程图。

在上交资料中请写明：存储结构、多项式相加的基本过程的算法（可以使用程序流程图）、源程序、测试数据和结果、算法的时间复杂度、另外可以提出算法的改进方法。

要求可以按照降指数次序进行排列，结合数据结构中排序的相关知识，运用相应函数实现，实现两个多项式的加减运算。

在此要建立多项式运算的相关规则。

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

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

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

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

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

实验一：完成多项式的相加运算（验证性、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为头指针的一个新链表中。

c语言数据结构实现——一元多项式的基本运算

文章标题：深入理解C语言中的数据结构实现——一元多项式的基本运算在C语言中，数据结构是非常重要的一个概念，它为我们处理各种复杂的数据提供了便利。

其中，一元多项式的基本运算是数据结构中的一个重要内容，它涉及到多种数据结构的操作和算法，是我们学习C 语言中数据结构的一个重要入口。

在本文中，我们将深入探讨C语言中一元多项式的基本运算，帮助读者更深入地理解这一重要的概念。

一、一元多项式的表示方式在C语言中，一元多项式可以使用数组来表示。

每个数组元素对应一个项，数组的下标对应每一项的次数，数组的值对应该项的系数。

一个一元多项式可以表示为：```cfloat polynomial[10] = {0, 1, 2, 0, 4}; // 表示多项式 1 + 2x + 4x^4 ```二、一元多项式的基本运算1. 一元多项式的加法有两个多项式 A 和 B，它们分别表示为 `float polynomialA[10]` 和`float polynomialB[10]`，那么它们的加法运算可以表示为：```cfor (int i = 0; i < 10; i++) {polynomialC[i] = polynomialA[i] + polynomialB[i];}```2. 一元多项式的减法一元多项式的减法是指将两个多项式相减得到一个新的多项式。

与加法类似，多项式 A 和 B 的减法运算可以表示为：```cfor (int i = 0; i < 10; i++) {polynomialC[i] = polynomialA[i] - polynomialB[i];}```3. 一元多项式的乘法式 A 和 B 的乘法运算可以表示为：```cfor (int i = 0; i < 10; i++) {for (int j = 0; j < 10; j++) {polynomialC[i+j] += polynomialA[i] * polynomialB[j];}}```4. 一元多项式的除法一元多项式的除法涉及到较为复杂的算法，需要考虑余数和商的处理。

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

数据结构实验报告实验一：一元多项式相加姓名：周成学号： 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.复习并熟练掌握数据结构所使用的程序设计语言——C语言；2.学会单步跟踪、调试自己的程序；3.加深对线性表特别是链表知识的理解和掌握，并能够运用相关知识来解决相关的具体问题，如一元多项式相加等；程序流程：1.定义一元多项式链表结构体类型；2.输入多项式项数以分配存储空间；3.输入多项式每项的系数和指数，将其插入当前多项式链表。

同时判断是否有与当前节点指数相同的项，若存在，则将两项系数相加合并。

此外，若存在系数为0的项，将其存储空间释放；4.进行多项数加法时，新建一个存储结果的链表，分别将两多项式各项依次插入结果多项式即完成多项式相加运算；5.进行多项数加法时，将减项多项式各项系数化为相反数后进行加法操作，即完成多项式相减运算；6.对x赋值后，将x值代入多项式进行运算得到多项式的值；7.输出多项式。

注意：进行完一次运算以后，应该及时销毁无用多项式以释放空间以便再次应用。

算法及注释：1）定义一元多项式链表结构体类型typedef struct Lnode{float cof; //定义系数int exp; //定义指数struct Lnode *next; //定义指针变量指向下一个节点}Lnode ,*Linklist; //定义新的变量类型2）建立多项式存储线性链表头结点void makehead(Linklist &head){head=(Linklist)malloc(sizeof(Lnode)); //建立新的节点head->exp=-1;head->next=NULL; //指针赋空head->cof=1;}3）将输入的多项式信息存储于节点中void makelnode(Lnode *&p){p=(Lnode*)malloc(sizeof(Lnode)); //建立新的节点printf("Input the cof and exp\n");scanf("%fx%d",&p->cof,&p->exp); //输入多项式底数指数信息p->next=NULL; //指针赋空}4）清除系数为零的多项式节点void clear(Linklist la){Lnode *p,*q; //定义两个指向结构体的指针p=la;q=p->next;while (q){if (fabs(q->cof)<=0.000001) { //判断系数为零p->next=q->next; //指针指向相隔的下一个节点free(q); //销毁系数为零的节点q=p->next; //指针后移一位}else {p=p->next; //p q分别后移一位q=q->next;}}}5）找到多项式中与当前节点同指数项位置int locate(Linklist l,Lnode *&p,Lnode*e){p=l;//标记表头if (!l->next)return(0);while(p&&e->exp!=p->exp){//当p存在且指数不相等时指针后移p=p->next;}if(p)return(p);//当p存在时，返回p地址else {//没找到时寻找出插入位置p=l;while (p->next&&e->exp<=p->next->exp)p=p->next;if (!p->next){p=p;return(0);}return(0);}}6）将多项式节点插入已有多项式链表中，同时完成系数运算void caseinsert(Linklist &l,Lnode *e){Lnode *p;if (locate(l,p,e)){//指数相同项系数相加p->cof += e->cof;free(e);}else{//插入新的项e->next=p->next;p->next=e;}}7）创建新的多项式链表void creat(Linklist &head,int m){Lnode *p;int i;makehead(head);//建立头结点for (i=1;i<=m;i++){p=(Linklist)malloc(sizeof(Linklist));//建立新的多项式单个节点空间makelnode(p);//建立赋值caseinsert(head,p);//将多项式节点插入已有多项式链表中，同时完成系数运算}clear(head);}8）输入多项式项数并创建节点进行存储void input(Linklist &l){int m;printf("Input the Poly numbers\n");scanf("%d",&m);creat(l,m);//建立一个l指向的头指针有m项的多项式链表}9）输出多项式void print(Linklist l){Lnode *p;p=l->next;printf("Poly：%6fx^%d",p->cof,p->exp);p=p->next;while (p){if(p->cof>0) printf("+");//系数正负号if (fabs(p->cof)<=0.000001); break;//不输出系数为零的项printf("%6fx^%d",p->cof,p->exp);p=p->next;//指针后移}printf("\n");}10）进行多项式加法运算void add(Linklist la,Linklist lb,Linklist &lc){ Lnode *p,*q,*q1,*p1;p=la->next;q=lb->next;makehead(lc);//建立一个新的表头while(p){p1=p->next;caseinsert(lc,p);//将多项式节点p插入已有多项式链表lc中，同时完成系数运算p=p1;//指针后移}while(q){q1=q->next;caseinsert(lc,q);//将多项式节点q插入已有多项式链表lc中，同时完成系数运算q=q1;}}11）将减项多项式转化为系数为相反数的多项式便于转化为加法运算void reverse(Linklist &l){Linklist p;p=l->next;while(p){p->cof*=-1;//系数自乘-1p=p->next;}}12）进行多项式减法运算void sub(Linklist la,Linklist lb,Linklist &lc){reverse(lb);add(la,lb,lc);clear(lc);//清除头结点}13）对x赋值进行多项式赋值运算float value(Linklist l,float x){float sum=0,t;int i;Linklist p=l->next;while(p){t=1;for (i=p->exp;i>0;i--)t*=x;sum=sum+t*p->cof;p=p->next;}return(sum);}14）销毁已有多项式，清除已有多项式占用的存储空间void destroy(Linklist la){Lnode *p,*q;p=la;while(p){q=p;p=p->next;free(q);}}15）创建主程序即菜单界面void main(){Linklist l[10];int c,n,m,i;float a;printf("Choose the number to operate：\n");printf(" 1：Creat a Poly\n");printf(" 2：Poly Addition\n");printf(" 3：Poly Substraction\n");printf(" 4：Evaluation\n");printf(" 5：Destroy a Poly\n");printf(" 6：Print a Poly\n");printf(" 0：Exit\n");printf("\nDestroy the Polys after used.\n");printf("\n*use ',' to separate\n");scanf("%d",&c);while (c){switch (c){case 1: printf("Input the Poly number 1~9\n");scanf("%d",&n);input(l[n]);break;case 2: printf(" Input the Poly number to add,and the Poly number stored in\n");scanf("%d,%d,%d",&n,&m,&i);add(l[n],l[m],l[i]);break;case 3: printf(" Input the Poly number to subtract,and the Poly number stored in\n");scanf("%d,%d,%d",&n,&m,&i);sub(l[n],l[m],l[i]);break;case 4: printf("Input the number to operate and the value of x:\n");scanf("%d,%f",&n,&a);printf("%f\n",value(l[n],a));break;case 5: printf("Input the Poly number:\n");scanf("%d",&n);destroy(l[n]);break;case 6: printf(" Input the Poly number:\n");scanf("%d",&n);print(l[n]);case 0: n=0;break;default:printf("ERROR!");}printf("Choose the number to operate:\n");scanf("%d",&c);}printf("OK!\n");程序运行截图：实验总结：这次实验室数据结构第一次上机实验，由于与C语言课程的学习相隔已经一个学期，对C语言有些生疏和遗忘，在编程过程中出现很多错误。

数据结构《一元多项式》

一元多项式相加问题实验报告本实验的目的是进一步熟练掌握应用链表处理实际问题的能力。

一、问题描述通过键盘输入两个形如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 进入下一次循环。

一元多项式的相加(数据结构)

实验报告课程名称：数据结构实验名称：一元多项式的相加班级： 1333 学生姓名：蔡景旺学号： 37一、需求分析1.用户可以根据自己的需求分别输入两个一元多项式（输入必须按指数递增顺序），并且能够实现输入的一元多项式的显示。

2.能够完成两个一元多项式的相加功能并显示结果。

3.程序执行的命令包括：（1）构造链表A （2）构造链表B （3）两个链表的相加（4）求链表的长度（5）打印（显示）已有的链表二、概要设计⒈为实现上述算法，需要线性表的抽象数据类型：ADT Polynomial {数据对象：D={a i:|a i∈TermSet,i=1…n,n≥0TermSet 中的每个元素包含一个表示系数的实数和表示指数的整数} 数据关系：R1={<a i-1,a i>|a i-1,a i∈D,且a i-1中的指数值< a i中的指数值i=2,…n≥0}基本操作:CreatPolyn(&p,m)操作结果：输入m项的系数和指数，建立一个一元多项式P。

DestroyPolyn(&p)初始条件：一元多项式P已存在。

操作结果：销毁一元多项式P。

PrintPolyn(P)初始条件：一元多项式P已存在。

操作结果：打印输出一元多项式P。

PolynLength(P)初始条件：一元多项式P已存在。

操作结果：返回一元多项式中P的项数。

AddPolyn(&Pa,&Pb)初始条件：一元多项式Pa和Pb已存在。

操作结果：完成一元多项式相加运算，即：Pa=Pa+Pb,销毁一元多项式Pb.}ADT Polynomailtypedef struct{ // 项的表示，多项式为linklist的数据元素float coef; //系数int evpn; //指数}term,ElemType; //两个类型名：term用于本ADT,ElemType为Linklist的数据对象名Typedef Linklist polynomial; //用带表头结点的有序链表表示多项式；Int cmp(term a,term b)；void CreatPolyn (polynomial &P,int m){//输入m项的系数和指数，建立表示一元多项式的有序链表PInitList (P); h = GetHead (P);e.coef = 0.0;e.expn = -1;SetCurElem (h,e); //设置头结点的数据元素for （i = 1;i<=m;++i）{//依次输入m项非零项scanf(e.coef,e.expn);if (! LocateElem(P,e,q,(*cmp)){ //当链表不存在指数项if(MakeNode (s,e)) InsFirst(q,s);//生成结点并插入链表}}}//CreatPolynvoid AddPolyn(polynomial &Pa, polynomial &Pb){//多项式加法：Pa=Pa+Pb，利用两个多项式的结点构成“和多项式”ha=Gethead(Pa); hb=Gethead(Pb);//ha和hb分别指向Pa和Pb的头结点qa=NextPos(Pa,ha); qb=NextPos(Pb,hb);// /ha和hb分别指向Pa和Pb的当前结点while(qa&&qb){//qa和qb均非空a=GetCurElem(qa); b=GetCurElem(qb);switch(*cmp(a,b)){case -1: //多项式PA中当前结点的指数值小ha=qa;qa= NextPos(Pa,ha);break;case 0://l两者的指数相等sum=a.cofe+b.cofe;if(sum!=0.0){//修改多项式PA中当前结点的系数值SetCurELem(qa,sum);ha=qa;}else {//删除当前结点Delfirst(ha,qa);FreeNode(qa);}Delfirst(ha,qa);FreeNode(qa); qb=NextPos(Pb,hb); qa=NextPos(Pa,ha);break;Case1://多项式PB中当前结点的指数值小DelFirst(hb,qb); InsFirst(ha,qb);qb=NextPos(Pb,hb); qa=NextPos(Pa,ha);break;}//swtich}//whileIf(!ListEmpty(Pb)) Append(Pa,qb);FreeNode(hb)://释放Pb头结点}//AddPolyn2. 数据结构分析：逻辑结构为线性表，采用链式存储结构。

数据结构实验报告-一元多项式的加法运算

问题描述：设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时，该项不输出当系数为负数时，不要再在前面输出+。

程序的流程程序由三个模块组成：输入模块：完成两个多项式的输入。

处理模块：将多项式按其指数大小进行排列。

输出模块：输出合并后的多项式。

三、详细设计算法的具体步骤：数组方法：struct code{int p,q;}a[1000],b[1000];//结构体数组，可以用二维数组代//替for(i=0;i<n;i++){for(j=i+1;j<n;j++){if(a[j].q>a[i].q) {temp=a[j].q;//指数排序a[j].q=a[i].q;a[i].q=temp;temp=a[j].p;//系数跟着变化a[j].p=a[i].p;a[i].p=temp;}}//对输入的指数进行排序，相应的系数跟着变化cout<<a[0].p<<"x^"<<a[0].q; //先输出第一项if(a[i].p>0)else if(a[i].p<0)cout<<a[i].p<<"x^"<<a[i].q;cout<<'+'<<a[i].p<<"x^"<<a[i].q;//完成运算符和其他项的输//出,然后类似于上面，对第二个多项式进行相应的操作。

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

数据结构多项式相加实验报告篇一：数据结构实验多项式加法数据结构实验报告实验名称：多项式加减法学号：1XX10419姓名：林强实验日期：XX.5.05一、实验目的通过实现多项式的加减法，对链表有更深入的了解二、实验具体内容1、实验题目1：（1）题目设计一个一元稀疏多项式简单的加减法计算器实现要求：一元稀疏多项式简单计算器的基本功能是：（1）输入并建立多项式：A(x)?7?3x?9x8?5x17；B(x)?8x?22x7?9x8（2）输出多项式（3）多项式A和B相加，建立多项式C＝A＋B，并输出相加的结果多项式C（4）选作：多项式A和B相减，建立多项式C＝A－B，并输出相加的结果多项式D（2）分析1：本程序的任务是实现两个多项式的加法其中多项式的系数为浮点型，指数为整数，输出的结果也为系数和指数。

（1）输入的形式和输入值的范围：输入多项式的系数a和未知数X的指数b，当a和b都为零时，输入结束。

输入值的范围：a为实数，b为整数。

（2）输出形式：输出多项式的系数和多项式未知数X 的指数即(a,b)形式。

（3）程序所能达到的功能，实现两个多项式的加法，并输出最后的结果2：整个程序运行期间实行动态创建节点，一边输入数据，一边创建节点当将全部数据输入到单链表中后再调用多项式加法这个函数，并一边实现多项式的相加，一边释放节点，有效防止了在程序反复运行过程中可能出现系统空间不够分配的现象（3）实验代码typedef int Status;#define OVERFLOW -1#define null 0typedef struct Lnode{float coef; //存储项系数int expn;//存储项指数struct Lnode *next;}Lnode,*LinkList;typedef LinkList polynomial;Status InitList_L(LinkList &L) {//初始化头节点L=(LinkList)malloc(sizeof(Lnode));if(!L)return(-1);L->next=null;return 1;}void AddPolyn(polynomial pa, polynomial pb){ //实现两个多项式相加的算法float x;polynomial qa;polynomial qb;polynomial s;polynomial u;qa=pa->next; qb=pb->next; s=pa;while(qa&&qb){if(qa->expnexpn){s=qa;qa=qa->next;}else if(qa->expn==qb->expn){x=qa->coef+qb->coef;if(x!=0){qa->coef=x;s=qa;qa=qa->next;u=qb;qb=qb->next;free(u);}else{s->next=qa->next;free(qa);qa=s->next;u=qb;qb=qb->next;free(u);}}else if(qa->expn>qb->expn){ u=qb->next;s->next=qb;s=qb;qb->next=qa;qb=u;}}if(qb)qa->next=qb;free(pb);}void main(){float a;int b;polynomial L1;polynomial L2; LinkList q;LinkList p;LinkList m;LinkList n;InitList_L(L1);q=L1;InitList_L(L2);p=L2;cout 请输入数据：" for(;;){ cin>>a;cin>>b;if(a==0&&b==0) break;m=new Lnode;m->coef=a;m->expn=b;q->next=m;q=m;q->next=null;}//循环输入第一个多项式的系数与指数for(;;){cin>>a;cin>>b;if(a==0&&b==0)break;n=new Lnode;n->coef=a;n->expn=b;p->next=n;p=n;p->next=null;}//循环输入第二个多项式的系数与指数AddPolyn(L1,L2);//调用多项式相加的算法while((L1->next)!=null){coutnext->coefnext->expn L1=L1->next;}//输出计算结果}三、实验小结通过编写多项加法这个程序，我将自己所学到的创建链表，初始化链表和多项式加法算法都应用了一次，这使我们不仅仅只是理论化的学习书本上的知识，而是将学习到的理论知识应用到实际的操作中来增强我们的实际操作能力，这使我增加了实际操作经验，也使我通过实际操作来认识到自己在程序编写上的不足从而增强了我的实际编写程序的能力。

一元多项式相加实验报告

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

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

实验步骤：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）输入并建立多项式：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指向要比较的下一个结点。

一元多项式求和数据结构

一元多项式求和数据结构
一元多项式是指只包含一个变量的多项式，例如 3x^2 + 2x + 1。

在计算机科学中，我们需要设计一种数据结构来存储和求解一元多项式的求和问题。

一种常见的数据结构是使用数组来表示一元多项式。

数组的索引表示变量的次数，而数组的值表示对应次数的系数。

例如，数组 [1, 2, 3] 表示的是 3x^2 + 2x + 1。

为了求解一元多项式的求和问题，我们可以按照如下的步骤进行计算：
1. 初始化一个变量 sum 为 0，用于累加多项式的和。

2. 遍历多项式数组，对于每个索引 i 和对应的系数 coef，执行如下操作：
- 计算变量的幂次 power = i。

- 计算当前项的值 term = coef * (x^power)。

这里的 x 是给定的变量值。

- 将当前项的值 term 累加到 sum 中。

3. 返回 sum 作为一元多项式的求和结果。

使用上述的方法，我们可以通过给定的一元多项式数组和变量值来求解一元多
项式的求和问题。

这种基于数组的数据结构简单且高效，并且可以方便地进行常见的多项式操作，如乘法、除法和求导等。

值得注意的是，一元多项式求和涉及到对指数为负数的情况的处理。

为了实现
更加通用的一元多项式求和，我们可以使用链表来存储多项式，其中每个节点包含指数和系数两个属性，通过链表的方式可以更灵活地处理任意次数的多项式。

总结而言，一元多项式求和数据结构既可以使用数组，也可以使用链表来实现。

通过合理的设计和操作，我们能够高效地求解一元多项式的求和问题，为实际应用中的多项式计算提供便利和可靠性。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

数据结构一元多项式的相加

B(x) 8x 22x7 9x8
C(x) A(x) B(x) 7 11x 22x7 5x17
A
-1
70
31
98
5 17 ^
B
-1
81
22 7 -9 8 ^
C
-1
70
11 1 22 7
5 17 ^
运算规则
设p,q分别指向A,B中某一结点，p,q初值是第一结点
p->exp < q->exp: p结点是结果多项式
•重点：线性表的顺序存储；线性表的链式存储；顺序表的插入、删除单链表的插入、删除
•难点：双向链表的系列操作线性表的应用。
if(x!=0){ p->coef=x; pre=p;} else { pre->next=p->next; free(p);}
p=pre->next; u=q; q=q->next; free(u); } else { u=q->next;q->next=p;pre->next=q;
pre=q; q=u; } } if(q!=NULL) pre->next=q; free(pb); }
算法描述
pre
p pre
p pre
pp
p
ppaa
--11
77 00
31111 111
99 88
55 1177 ^^
ppbb
--11
88 11
2222 77
--99 88 ^^ q=NULL
q
prqe
q
pa
-1
70
11 1
22 7
5 17 ^
Ch2_7.c

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

一元多项式的加法数据结构

数据结构综合实验报告_一元多项式

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

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

一元多项式相加实验报告

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

c语言数据结构实现——一元多项式的基本运算

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

数据结构_一元多项式的表示与相加

数据结构《一元多项式》

一元多项式的相加(数据结构)

数据结构实验报告-一元多项式的加法运算

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

一元多项式相加实验报告

数据结构实验-一元多项式的加法运算

一元多项式求和数据结构

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

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

数据结构一元多项式的相加

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