数据结构多项式求和

合集下载

数据结构多项式求和

数据结构多项式求和在计算机科学和数学领域中，数据结构的运用无处不在，而多项式求和就是一个典型的应用场景。

让我们一起来深入探讨一下这个有趣且重要的主题。

首先，我们需要明确什么是多项式。

简单来说，多项式就是由变量和系数组成的表达式。

比如，3x²＋ 2x 1 就是一个多项式，其中 3 、2 、－1 是系数，x 是变量，²是指数。

那么为什么要对多项式进行求和呢？这在很多实际问题中都有应用。

比如在物理学中，描述某些运动规律时会用到多项式；在工程学中，对信号的处理和建模也可能涉及到多项式求和。

接下来，我们看看如何用数据结构来表示多项式。

常见的数据结构有数组和链表。

用数组来表示多项式时，我们可以将系数存储在数组中。

假设一个多项式的最高次幂为n ，那么我们可以创建一个长度为n ＋1 的数组，数组的下标对应多项式的幂次，数组元素的值就是对应的系数。

这种表示方法简单直观，但是如果多项式的次数很高，而很多项的系数为0 ，就会浪费很多存储空间。

相比之下，链表是一种更灵活的数据结构。

每个节点可以存储系数、指数和指向下一个节点的指针。

这样，只有非零项才会被存储，节省了存储空间。

有了表示多项式的数据结构，接下来就是实现求和的算法。

对于用数组表示的多项式求和，我们需要从最高次幂开始，将对应幂次的系数相加。

如果相加后的系数为 0 ，那么在最终的结果中可以省略这一项。

而对于链表表示的多项式求和，我们需要遍历两个链表，找到相同幂次的项进行系数相加。

如果一个链表遍历完了，而另一个链表还有剩余项，直接将剩余项添加到结果链表中。

在实际编程中，还需要考虑一些特殊情况。

比如，如果两个多项式的最高次幂不同，那么在求和时要注意补齐。

另外，算法的效率也是我们需要关注的重点。

在选择数据结构和算法时，要根据具体的应用场景和需求来权衡空间复杂度和时间复杂度。

例如，如果多项式的操作频繁，而对空间要求不是很严格，那么使用数组可能更合适；如果多项式的项数不固定，而且有很多零系数项，链表可能是更好的选择。

数据结构-多项式相加

数据结构课程设计2012年12月班级：XXX学号：XXX姓名： XXX指导教师：XXX一元稀疏多项式计算器【问题描述】设计一个一元稀疏多项式简单计算器【基本要求】一元多项式简单计算器的基本功能是：1，输入并建立多项式;2，输出多项式，输出形式为整数序列:n,c1,e1,c2,c2,...,cn,en,其中n是多项式的项数，ci和ei分别是第i项的系数和指数，序列按指数降序排列;3,多项式a和b相加，建立多项式a+b;4,多项式a和b相减，建立多项式a-b.【算法设计思想】①一般情况下的一元n次多项式可写成pn(x)=p1xe1+p2xe2+……+pmxem其中，p1是指数为ei的项的非零系数，且满足0≦e1<e2<……<em=n ,若用一个长度为m且每个元素有两个数据项（系数项和指数项）的线性表（（p1,e1）,(p2,e2),……,(pm,em)）便可惟一确定多项式pn(x)。

②用两个带表头结点的单链表分别存储两个多项式③根据一元多项式相加的运算规则：对于两个一元多项式中所有指数相同的项，对应系数相加，若其和不为零，则构成“和多项式”中的一项；④只需要将第二个多项式的系数改为其相反数，然后根据一元多项式相加的运算规则便可以得到其相应的“差多项式”【【实现提示】用带表头结点的单链表存储多项式。

【程序代码】#include <stdio.h>#include <malloc.h>typedef struct node{float coef;int expn;struct node *next;}Lnode, *polynmial;void create(polynmial &L); //输入并建立多项式Lvoid display(polynmial L); //显示，输出多项式Lvoid sort(polynmial &L); //多项式L按指数排序void reverse(polynmial &L); //逆置void select(); //用户选择加减操作void add(polynmial La, polynmial Lb, polynmial &Lc); //多项式La,Lb相加void subtract(polynmial La, polynmial Lb, polynmial &Ld); //多项式La减去Lb，结果给Ldvoid create(polynmial &L) //输入并建立多项式L{int i, n;static struct node *p;scanf("%d", &n);L = (struct node *)malloc (sizeof(struct node));L->next = NULL;for(i = 0; i < n; i++){p = (struct node *)malloc(sizeof(struct node));scanf("%f %d", &p->coef, &p->expn);p->next = L->next;L->next = p;}}void display(polynmial L)//显示，输出多项式L{struct node *p, *q;int flag = 0;int k = 0;q = L->next;while(q)if(q->coef != 0)k++;q = q->next;}printf("%d, ", k);p = L->next;if(p->coef != 0){printf("%.1f,%d, ", p->coef, p->expn);flag++;}for(p = p->next; p; p = p->next){if(p->coef != 0){printf("%.1f,%d, ", p->coef, p->expn);flag++;}}if(flag == 0)printf("%d\n", flag);elseprintf("\n");}void sort(polynmial &L)//多项式L按指数排序{polynmial p, q, r, u;p = L->next;L->next = NULL;while(p != NULL){r = L;q = L->next;while((q != NULL) && (q->expn <= p->expn)) {r = q;q = q->next;}u = p->next;r->next = p;p->next = q;p = u;}void reverse(polynmial &L)//逆置{polynmial H;static struct node *p, *q, *s;H = (struct node*)malloc(sizeof(struct node));H->next = NULL;p = (struct node*)malloc(sizeof(struct node));s = L->next;p->coef = s->coef;p->expn = s->expn;p->next = s->next;while(s){p->coef = s->coef;p->expn = s->expn;p->next = s->next;q = H->next;H->next = p;p->next = q;p = (struct node*)malloc(sizeof(struct node));s = s->next;}p = H->next;q = L->next;while(p){q->coef = p->coef;q->expn = p->expn;q = q->next;p = p->next;}}void select() //用户选择加减操作{printf("请选择加减操作\n");printf("1.两个一元多项式相加\n");printf("2.两个一元多项式相减\n");}void add(polynmial La, polynmial Lb, polynmial &Lc)//多项式La,Lb相加{struct node *pa, *pb;static struct node *pc;Lc = (struct node*)malloc(sizeof(struct node));pa = La->next;pb = Lb->next;Lc->next = NULL;while(pa && pb){pc = (struct node*)malloc(sizeof(struct node)); if(pa->expn < pb->expn){pc->next = Lc->next;Lc->next = pc;pc->coef = pa->coef;pc->expn = pa->expn;pa = pa->next;}elseif(pa->expn == pb->expn){pc->next = Lc->next;Lc->next = pc;pc->expn = pa->expn;pc->coef = pa->coef + pb->coef;pa = pa->next;pb = pb->next;}else{pc->next = Lc->next;Lc->next = pc;pc->coef = pb->coef;pc->expn = pb->expn;pb = pb->next;}}while(pa){pc = (struct node*)malloc(sizeof(struct node)); pc->next = Lc->next;Lc->next = pc;pc->coef = pa->coef;pc->expn = pa->expn;pa = pa->next;}while(pb){pc = (struct node*)malloc(sizeof(struct node));pc->next = Lc->next;Lc->next = pc;pc->coef = pb->coef;pc->expn = pb->expn;pb = pb->next;}}void subtract(polynmial La, polynmial Lb, polynmial &Ld)//多项式La减去Lb，结果给Ld{struct node *pa, *pb;static struct node *pd;Ld = (struct node*)malloc(sizeof(struct node));pa = La->next;pb = Lb->next;Ld->next = NULL;while(pa && pb){pd = (struct node*)malloc(sizeof(struct node));if(pa->expn < pb->expn){pd->next = Ld->next;Ld->next = pd;pd->coef = pa->coef;pd->expn = pa->expn;pa = pa->next;}elseif(pa->expn == pb->expn){pd->next = Ld->next;Ld->next = pd;pd->expn = pa->expn;pd->coef = pa->coef - pb->coef;pa = pa->next;pb = pb->next;}else{pd->next = Ld->next;Ld->next = pd;pd->coef = pb->coef;pd->expn = pb->expn;pb = pb->next;}}while(pa){pd = (struct node*)malloc(sizeof(struct node)); pd->next = Ld->next;Ld->next = pd;pd->coef = pa->coef;pd->expn = pa->expn;pa = pa->next;}while(pb){pd = (struct node*)malloc(sizeof(struct node)); pd->next = Ld->next;Ld->next = pd;pd->coef = -pb->coef;pd->expn = pb->expn;pb = pb->next;}}int main(){int sign;polynmial La, Lb, Lc, Ld;printf("请输入第一个多项式：\n");create(La);sort(La);printf("请输入第二个多项式：\n");create(Lb);sort(Lb);select();scanf("%d", &sign);switch(sign){case 1:printf("多项式之和为:\n");add(La, Lb, Lc);sort(Lc);reverse(Lc);display(Lc);break;default:printf("多项式之差为:\n"); subtract(La, Lb, Ld); sort(Ld);reverse(Ld);display(Ld);break;}return 0;}【程序运行截图】。

数据结构（C语言）用单链表存储一元多项式,并实现两个多项式的相加运算

#include<stdio.h>#include<stdlib.h>#include<malloc.h>typedef int ElemType;/*单项链表的声明*/typedef struct PolynNode{int coef; // 系数int expn; // 指数struct PolynNode *next;}PolynNode,*PolynList;/*正位序(插在表尾)输入n个元素的值，建立带表头结构的单链线性表*/ /*指数系数一对一对输入*/void CreatePolyn(PolynList &L,int n){int i;PolynList p,q;L=(PolynList)malloc(sizeof(PolynNode)); // 生成头结点L->next=NULL;q=L;printf("成对输入%d个数据\n",n);for(i=1;i<=n;i++){p=(PolynList)malloc(sizeof(PolynNode));scanf("%d%d",&p->coef,&p->expn); //指数和系数成对输入q->next=p;q=q->next;}p->next=NULL;}// 初始条件：单链表L已存在// 操作结果: 依次对L的每个数据元素调用函数vi()。

一旦vi()失败,则操作失败void PolynTraverse(PolynList L,void(*vi)(ElemType, ElemType)){PolynList p=L->next;while(p){vi(p->coef, p->expn);if(p->next){printf(" + "); //“+”号的输出，最后一项后面没有“+” }p=p->next;}printf("\n");}/*ListTraverse()调用的函数(类型要一致)*/void visit(ElemType c, ElemType e){if(c != 0){printf("%dX^%d",c,e); //格式化输出多项式每一项}}/* 多项式相加，原理：归并 *//* 参数：两个已经存在的多项式 *//* 返回值：归并后新的多项式的头结点 */PolynList MergeList(PolynList La, PolynList Lb){PolynList pa, pb, pc, Lc;pa = La->next;pb = Lb->next;Lc = pc = La; // 用La的头结点作为Lc的头结点while(pa&&pb){if(pa->expn < pb->expn){pc->next = pa; //如果指数不相等，pc指针连上指数小的结点，pc = pa;pa = pa->next; //指向该结点的指针后移}else if(pa ->expn > pb->expn ){pc->next = pb; //pc指针连上指数小的结点，pc = pb;pb = pb->next; //指向该结点的指针后移}else//(pa ->expn = pb->expn ){pa->coef = pa->coef + pb->coef; //指数相等时，系数相加 pc->next = pa;pc = pa;pa = pa->next; //两指针都往后移pb = pb->next;}}pc->next = pa ? pa:pb; // 插入剩余段return Lc;}void main(){PolynList ha,hb,hc;printf("非递减输入多项式ha， ");CreatePolyn(ha,5); // 正位序输入n个元素的值printf("非递减输入多项式hb， ");CreatePolyn(hb,5); // 正位序输入n个元素的值printf("多项式ha :");PolynTraverse(ha, visit); printf("\n");printf("多项式hb :"); PolynTraverse(hb, visit); printf("\n");hc = MergeList(ha,hb); PolynTraverse(hc, visit); }。

数据结构多项式相加代码

数据结构多项式相加代码多项式可以使用数组或链表来存储。

其中，每个元素都代表一个项，包含系数和指数两个元素。

假设有两个多项式A和B，它们的项数分别为m和n。

以下是使用数组实现多项式相加的代码:1. 定义结构体表示多项式项，包含系数和指数两个元素。

struct PolyItem {int coefficient; // 系数int exponent; // 指数};2. 定义结构体表示多项式，包含项数和项的数组。

struct Polynomial {int numItems; // 项数PolyItem* items; // 项的数组};3. 定义函数实现多项式相加。

Polynomial add(Polynomial a, Polynomial b) {Polynomial c; // 存储结果的多项式c.numItems = 0; // 初始化项数为0c.items = new PolyItem[a.numItems + b.numItems]; // 申请空间存储项int i = 0, j = 0, k = 0; // 分别表示a、b、c的下标while (i < a.numItems && j < b.numItems) { // 当a和b都还有项时if (a.items[i].exponent > b.items[j].exponent) { // 当a 的指数大于b的指数时c.items[k++] = a.items[i++]; // 将a的项复制到c中} else if (a.items[i].exponent < b.items[j].exponent) { // 当a的指数小于b的指数时c.items[k++] = b.items[j++]; // 将b的项复制到c中} else { // 当a和b的指数相等时c.items[k].exponent = a.items[i].exponent; // 将指数赋值给cc.items[k++].coefficient = a.items[i++].coefficient + b.items[j++].coefficient; // 将系数相加后赋值给c}}// 将a或b剩余的项复制到c中while (i < a.numItems) {c.items[k++] = a.items[i++];}while (j < b.numItems) {c.items[k++] = b.items[j++];}c.numItems = k; // 将项数赋值给c return c; // 返回结果多项式}4. 调用add函数实现多项式相加。

数据结构多项式求和实验报告

1.实验题目设计一种用单链表存储多项式的结构（每个结点存储一项的系数和指数，类型都为int），并编写一个产生多项式链表的函数和一个实现两个多项式相加的函数。

2 .实验内容顺序存储结构的实现。

先输入多项式最高项数，然后按照（系数，指数）的格式输入顺序表类型定义如下：typedef struct term{int coef;int expn;struct term *next;}term,*Polynomial;3．实验要求（1）利用C语言完成算法设计和程序设计。

（2）上机调试通过实验程序。

（3）输入数据，检验程序运行结果。

（4）给出具体的算法分析，包括时间复杂度和空间复杂度。

（5）撰写实验报告。

4.实验步骤与源程序⑴实验步骤首先分析实验内容，要实现多项式求和，必须创建两个函数，然后先建立一个多项式a和多项式b，接着输入每个多项式的系数和指数，再实现多项式a和b的求和将求出的多项式放在多项式a中，最后输出求出的多项式的结果。

⑵源代码#include<stdio.h>#include<stdlib.h>#include<string.h>#include<time.h>#include<malloc.h>/*定义存储结构，用单链表存储多项式，链表中每个结点存储多项式中的一项。

*/typedef struct term{int coef;//定义多项式系数为coefint expn;//定义多项式指数为expnstruct term *next;}term,*Polynomial;void Create_Polynomial(Polynomial *P,int n){ /*建立多项式*/int i;term *t1,*t2;(*P)=(term *)malloc(sizeof(term));(*P)->coef=0;(*P)->expn=0;(*P)->next=NULL;t1=(*P);for(i=0;i<=n;i++){ /*输入每一项的系数和指数*/ t2=(term *)malloc(sizeof(term));scanf("%d,%d",&(t2->coef),&(t2->expn));t1->next=t2;t1=t1->next;}t2->next=NULL;}void Add_Polynomial(Polynomial *a,Polynomial *b){ /*多项式a和多项式b求和，结果存放在a中。

多项式相加数据结构

多项式相加数据结构多项式相加是一种常见的数学操作，它在数据结构中也有广泛的应用。

本文将介绍多项式相加的概念、实现方法以及应用场景。

## 一、多项式相加的概念多项式是由常数项和一系列幂次项组成的代数表达式，形如：P(x) = a0 + a1x + a2x^2 + ... + anx^n其中，ai为系数，x为变量，n为最高次数。

多项式相加即将两个或多个多项式相加得到一个新的多项式。

## 二、多项式相加的实现方法多项式相加的实现方法有多种，常见的有数组表示法、链表表示法和稀疏矩阵表示法。

1. 数组表示法：将多项式的系数存储在一个数组中，数组下标表示幂次，数组元素表示系数。

2. 链表表示法：将多项式的每一项用链表的形式连接起来，每个节点包含系数和幂次信息。

3. 稀疏矩阵表示法：对于稀疏的多项式，只存储非零项的信息，可以用矩阵的形式表示。

不同的表示方法适用于不同的场景，选择合适的实现方法可以提高多项式相加的效率和灵活性。

## 三、多项式相加的应用场景多项式相加在实际应用中有很多场景，以下列举几个常见的应用场景：1. 数据压缩：在某些情况下，数据具有稀疏性，多项式相加可以将稀疏数据压缩为较小的存储空间，减少数据传输和存储成本。

2. 图像处理：图像的滤波操作可以看作是将图像的像素值与一个多项式进行相加的过程，通过调整多项式的系数可以实现不同的滤波效果。

3. 信号处理：信号可以表示为一个多项式的形式，多项式相加可以实现信号的叠加和混合，用于音频合成、语音识别等应用。

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.实验总结本来我对编程很没有信心，做这样一个课程设计感觉有点吃力，虽然有些人觉得很简单，但是我还是坚持做下来了，我不断的看书，翻阅资料，询问同学，上网搜索，总算有模有样地把这个程序编的能运行了。

数据结构-单链表-多项式相加

数据结构-单链表-多项式相加【问题描述】编写⼀个程序⽤单链表存储多项式，并实现两个⼀元多项式A与B相加的函数。

A，B刚开始是⽆序的，A与B之和按降序排列。

例如：多项式A: 1.2X^0 2.5X^1 3.2X^3 -2.5X^5多项式B: -1.2X^0 2.5X^1 3.2X^3 2.5X^5 5.4X^10多项式A与B之和：5.4X^10 6.4X^3 5X^1【输⼊形式】任意两个多项式A和B的项数及对应的系数和指数，要查询的第⼏项【输出形式】多项式中某⼀项的系数与指数，系数保留⼀位⼩数【输⼊样例】4 1.2 0 2.5 1 3.2 3 -2.5 55 -1.2 0 2.5 1 3.2 3 2.5 5 5.4 102【输出样例】6.4 31 #include<bits/stdc++.h>2 #include<stdlib.h>3using namespace std;4 typedef long long ll;56struct node{7double data;8int index;9 node* next;10 node():index(0){}11 node* operator [] (int n){12 node* end=next;13while(end&&n--)end=end->next;14return end;15 }16bool operator < (const node &t) const {17return index>t.index;18 }19 node operator * (node& t);20 };2122void newList(node & head,int length){23 node *a=new node[length];//这是这个函数的解释node* operator [] (int n)P11⾏申请空间的⽅式 new int[10]申请10个int类型的空间再返回node指针类型24for(int i=0;i<length;++i)cin>>a[i].data>>a[i].index;25//a是node类型数组啊26 sort(a,a+length);//p16⾏的函数解释27 node* end=&head;28for(int i=0;i<length;++i){29 node* t=new node;30 t->data=a[i].data;31 t->index=a[i].index;32 end->next=t;33 end=t;34 }//他这好像就特别简单 end=xx 之后就申请了新节点赋值然后挂上去35delete[] a;36 }37void show(node& head){//传递的这个是引⽤38 node* end=head.next;//就还是这个类型所以⽤的是.39while(end){40if(end->index==1) cout<<end->data<<"X^"<<(end->next?" + ":"\n");41else cout<<end->data<<"X^"<<end->index<<(end->next?" + ":"\n");//末尾加的这个的意思是如果下⼀个节点还有就+上如果没有就换⾏42 end=end->next;43 }44 }4546///多项式相加：47void combine(node& a, node& b){//传递的是引⽤48 node* p,*q,*tail,*temp;49double s;50 p=a.next;51 q=b.next;52 tail=&a;//就直接修改a链表了53while(p&&q){54if(p->index>q->index){55 tail->next=p;tail=p;p=p->next;56 }else if(p->index==q->index){57 s=p->data+q->data;58if(s){59 p->data=s;60 tail->next=p; tail=p;p=p->next;61 temp=q;q=q->next;delete temp;62 }else{63 temp=p;p=p->next;delete temp;64 temp=q;q=q->next;delete temp;65 }//删除没有⽤的节点这点甚是符合朕⼼厉害66 }else{67 tail->next=q; tail=q; q=q->next;68 }69 }70if(p)tail->next=p;71else tail->next=q;72 }7374int main(){75 node a,b;76int n1,n2;cin>>n1;77 newList(a,n1);78 cin>>n2;79 newList(b,n2);80 combine(a,b);8182 cin>>n1;83 cout<<fixed<<setprecision(1)<<a[n1-1]->data<<""<<a[n1-1]->index<<endl;//这⾥可以这么骚也是因为p11⾏⽜逼84 show(a);//给引⽤传参数就是传本⾝不是传指针85 }。

数据结构多项式求和

#include <iostream>using namespace std;struct elem{int coef;int exp;elem *next;};class Multiple{private:elem *first;public:Multiple();Multiple(int a[][2],int n);~Multiple();void Print();friend void Add(Multiple &M1,Multiple &M2); };Multiple::Multiple(){first=new elem;first->next =NULL;}/*Multiple::Multiple(int a[][2],int n){elem *p;first=new elem;first->next =NULL;for(int i=0;i<n;i++){p=new elem;p->coef=a[i][0];p->exp=a[i][1];p->next=first->next ;first->next =p;}}*/Multiple::Multiple(int a[][2],int n){elem *r,*s;first=new elem;r=first;for(int i=0;i<n;i++){s=new elem;s->coef =a[i][0];s->exp =a[i][1];r->next =s;r=s;}r->next =NULL;}Multiple::~Multiple (){elem *p,*q;p=first;while(p){q=p;p=p->next;delete q;}}void Add(Multiple &M1,Multiple &M2){cout<<"**********多项式求和***********"<<endl;elem *p,*q;elem *pre,*qre;pre=M1.first ;qre=M2.first ;p=M1.first ->next ;q=M2.first->next ;while(p!=NULL && q!=NULL){if(p->exp<q->exp){pre=p;p=p->next ;}else if(p->exp>q->exp ){elem *v;v=q->next ;pre->next =q;q->next =p;q=v;}else{p->coef =p->coef +q->coef ;if(p->coef ==0){pre->next =p->next ;delete p;p=pre->next ;qre->next =q->next ;delete q;q=qre->next;}else{pre=p;p=p->next;qre->next =q->next ;delete q;q=qre->next;}}}if(q)pre->next =q;//delete M2.first ;//注意这句话不能添加，因为程序中定义了析构函数!}void Multiple::Print ()//心得：当考虑全局是无法达到预期结果的时候，不妨考虑单独每一项{cout<<"**********输出多项式***********"<<endl;elem *p;int i=0;p=first->next ;while(p){i++;if(i==1){if(p->exp==0)cout<<p->coef;elsecout<<p->coef<<"x^"<<p->exp;}else{if(p->exp==0)cout<<"+"<<p->coef;else{if(p->coef >0)cout<<"+"<<p->coef<<"x^"<<p->exp;elsecout<<p->coef<<"x^"<<p->exp;}}p=p->next ;}cout<<endl;}void main(){Multiple M0;int a[5][2]={{4,0},{3,2},{12,5},{-6,6},{7,8}};int b[4][2]={{3,0},{1,2},{-3,3},{5,6}};Multiple M1(a,5);Multiple M2(b,4);M1.Print ();M2.Print();Add(M1,M2);M1.Print ();}。

数据结构多项式相加实验报告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;}//输出计算结果}三、实验小结通过编写多项加法这个程序，我将自己所学到的创建链表，初始化链表和多项式加法算法都应用了一次，这使我们不仅仅只是理论化的学习书本上的知识，而是将学习到的理论知识应用到实际的操作中来增强我们的实际操作能力，这使我增加了实际操作经验，也使我通过实际操作来认识到自己在程序编写上的不足从而增强了我的实际编写程序的能力。

数据结构一元多项式求和实验报告

xx大学xxx学院算法与数据结构试验报告设计名称：算法与数据结构设计题目：链表的应用学生学号：xx专业班级：xx学生姓名：xx学生成绩：指导教师（职称）：课题工作时间：2012年4月10日说明：实验课程类别：课程内实验实验课程性质：必修适用专业、年级：2010级计算机工程、计算机网络开课院、系：计算机科学与工程学院计算机工程教研室学时：18编写依据：《算法与数据结构》实验教学大纲修订时间：2012年2月《算法与数据结构》课程实验指导书（以下简称：指导书）是针对计算机学院所开设的对应课程的上机实验而编写的教学文件，供学生上机实验时使用。

上机的工作环境要求：Windows 2000或以上操作系统、VC++ 6.0或者其它高级程序设计语言。

学生应按指导教师的要求独立完成实验，并按要求撰写实验报告。

每一个实验，编程上机调试并且提交电子文档实验报告，以学号姓名作为文件名上传。

报告内容至少包含如下内容：1、学生基本情况：专业班级、学号、姓名2、实验题目、实验内容3、设计分析4、源程序代码5、测试用例（尽量覆盖所有分支）6、实验总结一．实验内容与学时分配一、试验课题链表的应用二、试验内容一元多项式求和。

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

三、试验分析系数指数一元多项式链表的结点结构四、源程序代码#include<stdio.h> #include<stdlib.h> /*链表数据类型定义*/ typedef struct LNode {int x,z;struct LNode *next; }LinkList;void OutLinkList(LinkList *L); /*输出函数*/void PutLinkList(LinkList *&L,int n); /*输入函数*/LinkList *AddLinkList(LinkList *a,LinkList *b); /*求和函数*/ void OutXLinkList(LinkList *L); void OutZLinkList(LinkList *L); void main() {int n,m;LinkList *a,*b,*c;printf("\t\t\t本程序可以完成两个一元多项式的加法运算。

数据结构实验报告完成多项式的运算

简单介绍：本次作业力在学会链表表示线性表的插入、删除、查找等基本操作设计与实现，学习利用链表提供的接口去求解实际问题，同时熟悉链表的的存储方法。

再基于线性链表的基础设计完成多项式的相加运算程序。

一、实验目的和要求完成多项式的相加、相乘运算。

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

利用单链表实现。

2.实验原理使用单链表实现一元多项式的存储，并实现两个一元多项式的加法运算。

三、实验环境硬件：（1）学生用微机（2）多媒体教室或远程教学（3）局域网环境软件：（1）Windows XP中文操作系统（2）VC6.0四、算法描述及实验步骤1、描述：加法：输入建立一元多项式,进行简单加法运算,输出结果；通过建立单链表A和B分别存放多项式的a和b的各项系数及指数；并且利用A使得不产生新的节点而在A中存放数据运算结果；该过程通过定义指针变量p和q使它们分别指向两个多项式的第一个节点，之后依次比较它们所指向的项的指数，即一种情况指数相等时系数相加且和不为零，修改当前p所指项的系数（和），同时删除q所指项，若和为零则同时删除p和q各自所指；情况二，p当前项指数大于q当前项，将q所指插入p所指之前作为结果项之一；情况三，p当前项指数小于q当前项，p所指作为多项式和的一项，移动p指向下一项，进行比较，在移动p，q至其中以个链空，把另一个链余下节点插在p所指之后；乘法：定义指针p,q指向所操作节点，通过A链表的每一项与B链表各项相乘，指数相加，系数相乘，将值赋给新节点各自域，构成一新的链表，最后返回头结点。

可这样有一个问题，即新生成的链表，即最终结果混乱，没有对数据进行过滤，相同指数项应在执行加法运算，所以可以这样实现，通过A链表的每一项与B链表各项相乘的新生成节点单独构成一链表，并将第一个链表加入另一新链表，循环此操作将后生成的链表加之先前的链表，即可实现排序问题。

数据结构多项式求和

#include<stdio.h>#include<malloc.h>#include<stdlib.h>#define NULL 0typedef struct NODE {float coef; //系数int expn; //指数struct NODE *next;}NODE;NODE *Creat(int n);void print(NODE *head);NODE *AddPolyn(NODE *head1, NODE *head2); NODE *Delfirst(NODE *head, NODE *q);void InsertBefore(NODE *p1, NODE *p2);int compare(int a, int b);main(){NODE *head1, *head2, *head3;int n1, n2;printf("请输入你需要的多项数的数目n1 : "); scanf("%d", &n1);head1 = Creat(n1);printf("第一个多项式的显示: \n");print(head1);printf("\n请输入你需要的多项数的数目n2 : "); scanf("%d", &n2);head2 = Creat(n2);printf("\n第二个多项式的显示: \n");print(head2);head3 = AddPolyn(head1, head2);printf("\n合并后的多项式的显示: \n");print(head3);printf("\n");}/*创建链表*/NODE *Creat(int n){NODE *current, *previous, *head;int i;head = (NODE *)malloc(sizeof(NODE)); /*创建头结点*/previous = head;for(i = 0; i < n; i++){current = (NODE *)malloc(sizeof(NODE));printf("请输入系数和指数: ");scanf("%f%d", &current->coef, &current->expn);previous->next = current;previous = current;}previous->next = NULL;return head;}/*一元多项式的想加，总体考虑，可分qa的指数比qb小，或等于pb(如果系数相加等于0和不等于0),或大于pb里面由InsertBefore和Delfirst两个小模块组成一部分*/NODE *AddPolyn(NODE *head1, NODE *head2){NODE *ha, *hb, *qa, *qb;int a, b;float sum;ha = head1; /*ha和hb指向头结点*/hb = head2;qa = ha->next; /*qa和qb指向头结点的下一个结点*/qb = hb->next;while(qa && qb) /*qa和qb均非空*/{a = qa->expn;b = qb->expn;switch(compare(a, b)) {case-1 : /*qa->expn < qb->expn*/ha = qa;qa = qa->next;break;case 0 :sum = qa->coef + qb->coef; /*系数的和*/if(sum != 0.0) {/*如果不是0.0*/qa->coef = sum; /*改变系数*/ha = qa;}else{free(Delfirst(ha, qa));}free(Delfirst(hb, qb));qa = ha->next;qb = hb->next; /*qb释放后要重新赋值*/break;case 1 : /*如果qa-> expn > qb -> expn*/ Delfirst(hb, qb);InsertBefore(ha, qb); /*把qb插入到ha下一个结点之前*/qb = hb->next;ha = ha->next;break;}}if(qb)ha->next = qb; /*插入剩余的pb*/free(head2);return head1;}/*比较*/int compare(int a, int b){if(a < b)return-1;else if(a > b)return 1;elsereturn 0;}/*删除结点q*/NODE *Delfirst(NODE *p1, NODE *q){p1 -> next = q -> next;return (q);}/*插入结点,引入结点p,可以让p插入到p2和p1之间*/void InsertBefore(NODE *p1, NODE *p2){NODE *p;p = p1->next;p1->next = p2;p2->next = p;}/*打印,为了美观程序分开打印*/void print(NODE *head){NODE *current;current = head->next;while(current->next != NULL){printf("%0.f * x^%d + ", current->coef, current->expn); current = current -> next;}printf("%0.f * x^%d", current->coef, current->expn);}。

数据结构多项式相加

public interface LList<E> //线性表接口{boolean isEmpty(); //判断线性表是否为空int length(); //返回线性表长度E get(int index); //返回序号为index的对象E set(int index, E element); //设置序号为index对象为boolean add(int index, E element);//插入element对象，插入后对象序号为indexboolean add(E element); //插入element对象，插入位置没有约定E remove(int index); //移去序号为index的对象，返回被移去对象void clear(); //清空线性表}2.用栈实现括号的匹配public interface SStack<E> {boolean isEmpty(); //判断是否空栈boolean push(E element); //入栈E pop(); //出栈E get(); //取栈顶元素值}三．实验详细设计1.用单链表实现多项式相加创建三个类：结点类，链表类，主类结点类：创建结点，每个结点包括指数域，系数域，后继结点链，创建构造方法和带有参数的方法，获取，设置指数和系数，返回后继结点链表类：创建构造函数，设置并获得表头。

插入元素，多项式按照降幂排列，创建方法实现两链表相加，打印多项式链表主类：提示输入第两个多项式的长度和数据，存贮数据在两个数组之中，创建两个链表，并分别将数组的头地址赋给该链表，使用循环将元素插入后输出连个多项式和结果。

多项式降幂排列的实现，链表的相加在代码中均有详细注释代码如下：主类PoloMainpackage Polo;import javax.swing.JOptionPane;public class PoloMain {public static void main(String[] args) {String lengths = JOptionPane.showInputDialog("请输入第一个多项式长度 ");int length = Integer.parseInt(lengths);Node[] a = new Node[length];for(int i=0;i<length;i++){String getc1s = JOptionPane.showInputDialog("请输入第一个多项式中第 "+(i+1)+ "项的系数 ");int getc1 = Integer.parseInt(getc1s);String gete1s = JOptionPane.showInputDialog("请输入第一个多项式中第 "+(i+1)+ "项的指数 ");int gete1 = Integer.parseInt(gete1s);a[i]=new Node(getc1,gete1);}String length2s = JOptionPane.showInputDialog("请输入第二个多项式长度 ");int leng2th = Integer.parseInt(length2s);Node[] b = new Node[leng2th];for(int i=0;i<leng2th;i++){String getc2s = JOptionPane.showInputDialog("请输入第二个多项式中第 "+(i+1)+ "项的系数 ");int getc2 = Integer.parseInt(getc2s);String gete2s = JOptionPane.showInputDialog("请输入第二个多项式中第 "+(i+1)+ "项的指数 ");int gete2 = Integer.parseInt(gete2s);b[i]=new Node(getc2,gete2);}// Node []a={new Node(10,8),new Node(-3,7),new Node(4,9),new Node(12,-1),new Node(8,4)};// Node []b={new Node(7,8),new Node(6,9),new Node(14,6),new Node(-7,7),new Node(21,3)};PoloList A= new PoloList(a[0] );PoloList B= new PoloList( b[0]);for(int i=1;i<a.length;i++){A.insert(a[i]);}for(int j=1;j<b.length;j++){B.insert(b[j]);}System.out.println("多项式A为：");A.printList();System.out.println();System.out.println("多项式B为：");B.printList();System.out.println();System.out.println("两式相加结果为：");PoloList result=A.AddtwoList(B);result.printList();System.out.println();}}链表类PoloListpackage Polo;public class PoloList {private Node header;// 构造函数public PoloList(){header=null;}public PoloList(Node h){header=h;}// 设置表头public void setheader(Node newheader){ header=newheader;}// 获得表头public Node getheader(){return header;//找到表中某结点的前一元素public Node findprevious(Node n){Node temp=header;if(n.equals(header)){return header;}else{while(temp.getNext()!=null&&temp!=null){if(temp.getNext().equals(n))return temp;elsetemp=temp.getNext();}}return null;}// 插入某节点（按照次数降序排列）public void insert(Node n) {//要插入的结点的次数int indegree=n.getdegree();if(header==null)header=n;else{for(Node temp=header;temp!=null;temp=temp.getNext()){//如果链表中已有相同次数项，只需将系数相加即可。

数据结构—多项式求和

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

数据结构实验-多项式的相加减

集美大学数据结构课程实验报告课程名称：数据结构班级：网络0911实验成绩：指导教师：姓名：实验项目名称：多项式的相加减学号上机实践日期：实验项目编号：组号：上机实践时间：学时一、目的(本次实验所涉及并要求掌握的知识点)学习和掌握如何运用链表来实现一元稀疏多项式的相加减。

多项式的输入和输出的应注意的要点，规定输出的多项式的顺序。

二、实验内容与设计思想(设计思路、主要数据结构、主要代码结构、)实验内容：一元稀疏多项式的相加减设计思路：建立数据结构存放常数和系数以及指向下一个节点的指数，用链表存放各个节点，通过对常数和系数的的运算，实现多项式的相加减主要数据结构：结构体，链表主要代码结构：struct Polyn;void addPolyn(Polyn * a,Polyn * b,int add);void display( );void tip()’Polyn * CreatPolyn(int m);三、实验使用环境(本次实验所使用的平台和相关软件)Dev-C++、windows XP四、实验步骤和调试过程(实验步骤、测试数据设计、测试结果分析)需说明出，加入必要的截图说明。

#include<iostream>#include<vector>using namespace std;struct Polyn{float coef;int expn;Polyn *next;};//构建结构体vector <Polyn *> ve;void addPolyn(Polyn * a,Polyn * b,int add);void display(Polyn *n);//打印void tip();//屏幕显示Polyn * CreatPolyn(int m); //建立多项式int main(){tip();system("pause");}void tip(){Polyn *first, *second,*s;int m;for( int i=1;i;){cout<<" 多项式运算.\n";cout<<"======================="<<"\n"; cout<<" 1------ 构造多项式.\n";cout<<" 2------ 多项式相加.\n";cout<<" 3------ 多项式相减.\n";cout<<" 0------ 结束.\n";cout<<"======================="<<"\n"; cout<<" 请输入您的选择.\n";cin>>i;switch(i){case 1:cout<<"请输入多项式的项数.\n";cin>>m;s=CreatPolyn(m);display(s);ve.push_back(s);break;case 2:first=ve.back();ve.pop_back();second=ve.back();addPolyn(first,second,0);break;case 3:first=ve.back();ve.pop_back();second=ve.back();addPolyn( first,second,1);break;case 0:cout<<" 再见"<<"\n";break;};}}Polyn* CreatPolyn(int m){Polyn* px=new Polyn[m];cout<<" 输入系数.\n";for(int i=0;i<m;i++)cin>>px[i].coef;cout<<"输入与系数相对应的指数.\n";for(int i=0;i<m;i++){cin>>px[i].expn;if(i!=m-1)px[i].next=&px[i+1];elsepx[i].next=NULL;}return px;}void display(Polyn *n){int q=0;Polyn * r;r=n;for(;r;r=r->next){if(r->coef)q++;if(r==n){if(r->coef!=0)cout<<r->coef<<"X"<<"^"<<r->expn;}else{if( r->coef>0)cout<<"+"<<r->coef<<"X"<<"^"<<r->expn;if(r->coef<0)cout<<r->coef<<"X"<<"^"<<r->expn;}}cout<<"\n";if(q==0)cout<<"0"<<"\n";}void addPolyn(Polyn * a,Polyn * b,int add)//两个多项式的加减{float c;int a1=1,b1=1,s,e;Polyn *ha,*hb,*p,*r;ha=a;hb=b;p=ha;r=hb;for(int i=0;ha[i].next;++i)a1++;for(int i=0;hb[i].next;++i)b1++;ha[a1-1].next=hb;for(int j=0;j<b1;j++){for(int i=0;i<a1;i++){if(a[i].expn-b[j].expn==0){if(add)ha[i].coef=ha[i].coef-hb[j].coef;elseha[i].coef=ha[i].coef+hb[j].coef;if(hb!=&hb[j])hb[j-1].next=hb[j].next;else{hb=hb[j].next;ha[a1-1].next=hb;}i=a1;}}}for(;p;p=p->next){for( Polyn * t=p->next;t;t=t->next)if( p->expn>t->expn){e=p->expn;p->expn=t->expn;t->expn=e;c=p->coef;p->coef=t->coef;t->coef=c;}}display(ha);}五、实验小结(实验中遇到的问题及解决过程、实验体会和收获)至少两点1.刚开始实现多项式的相加减运算时，申请一个新的空间来存放结果，结果指针乱了，后来改成了现在的程序。

数据结构-实验2-多项式求和

数据结构-实验2-多项式求和数据结构实验 2 多项式求和在计算机科学和数学领域中，多项式的操作是一个常见且重要的任务。

本次实验 2 的重点是实现多项式的求和。

首先，让我们来理解一下什么是多项式。

简单来说，多项式就是由变量、系数和运算符组成的表达式。

例如，3x^2 ＋ 2x 1 就是一个多项式，其中 3、2 和－1 是系数，x 是变量，＾2 表示幂次。

那么为什么要进行多项式求和呢？在实际的应用中，我们经常会遇到需要对多个多项式进行运算的情况。

比如在数学建模中，通过对不同的多项式进行求和，可以得到更复杂的数学表达式，从而更准确地描述实际问题。

接下来，我们来探讨一下如何实现多项式的求和。

在数据结构中，有多种方式可以表示多项式。

常见的有顺序表和链表两种方式。

使用顺序表来表示多项式时，我们可以将多项式的每一项的系数和指数存储在数组的相应位置。

比如，数组的第一个元素存储第一项的系数和指数，第二个元素存储第二项的系数和指数，以此类推。

这种方式的优点是随机访问速度快，但是在进行多项式的加法运算时，可能需要移动大量的元素，效率较低。

相比之下，链表的方式则更加灵活。

我们可以为每一项创建一个节点，节点中包含系数、指数和指向下一项的指针。

在进行多项式的加法运算时，只需要遍历链表，根据指数的大小进行相应的操作即可。

下面我们通过一个具体的例子来看看如何进行多项式的求和。

假设有两个多项式：P1(x) ＝ 2x^3 ＋ 3x^2 1 和 P2(x) ＝ x^3 ＋ 2x 5 。

首先，我们创建两个链表分别表示这两个多项式。

然后，同时遍历这两个链表。

在遍历的过程中，比较当前节点的指数大小。

如果两个节点的指数相等，那么将它们的系数相加，创建一个新的节点，其系数为相加后的结果，指数不变，并将其插入到结果链表中。

如果一个节点的指数大于另一个节点的指数，那么将指数较小的节点直接插入到结果链表中，并继续遍历。

如果一个链表遍历完了，而另一个链表还有剩余的节点，那么将剩余的节点直接插入到结果链表中。

数据结构多项式求和

数据结构多项式求和多项式求和是数据结构中的一个重要问题，其中给定一个多项式，我们需要计算它的和。

在本文中，我们将讨论多项式求和的算法和数据结构。

多项式是一个数学表达式，由一系列项组成，每个项由一个系数和一个指数组成。

例如，多项式3x^2 + 2x + 1由三个项组成，分别是3x^2、2x和1。

在多项式求和问题中，我们需要计算给定多项式的所有项的总和。

为了解决多项式求和问题，我们可以使用两种主要的数据结构：链表和数组。

这两种数据结构都可以用来表示多项式，并且具有不同的优势和劣势。

链表是一种动态数据结构，可以方便地插入和删除元素。

在链表中，每个节点包含一个项的系数和指数，并且通过指针连接到下一个节点。

通过遍历链表，我们可以计算多项式的总和。

链表的一个主要优点是它可以适应多项式的大小变化，但它的缺点是访问指定位置的项的效率较低。

数组是一种静态数据结构，具有固定大小。

在数组中，每个元素存储一个项的系数和指数。

通过遍历数组，我们可以计算多项式的总和。

数组的一个主要优点是它可以提供快速的随机访问，但它的缺点是它的大小是固定的，无法适应多项式的大小变化。

基于链表的多项式求和算法如下：1. 创建一个空链表来存储多项式的和。

2. 遍历第一个多项式的链表。

3. 将每个项的系数和指数与第二个多项式的链表中的对应项相加。

4. 将结果项插入和链表中。

5. 遍历第二个多项式的链表，将未处理的项插入和链表中。

6. 返回和链表。

基于数组的多项式求和算法如下：1. 创建一个空数组来存储多项式的和。

2. 遍历第一个多项式的数组。

3. 将每个项的系数和指数与第二个多项式的数组中的对应项相加。

4. 将结果项存储在和数组的对应位置。

5. 遍历第二个多项式的数组，将未处理的项存储在和数组的对应位置。

6. 返回和数组。

无论使用链表还是数组，多项式求和的时间复杂度都是O(n)，其中n是多项式的项数。

但是，链表的空间复杂度是O(n)，而数组的空间复杂度是O(k)，其中k是多项式的最高指数。

多项式相加的函数（数据结构_C语言版）

多项式相加的函数（数据结构_C语言版）一、编写一个程序用单链表存储多项式，并实现两个多项式相加的函数。

【源程序】#include#include#define MAX 20typedef struct{ float coef;int exp;}PolyArray[MAX];typedef struct pnode{ float coef;//系数int exp;//指数struct pnode *next;}PolyNode;void DispPoly(PolyNode *L)//输出多项式{ PolyNode *p=L->next;while(p!=NULL){ printf("%gx^%d",p->coef,p->exp);p=p->next;}printf("\n");}void CreateListR(PolyNode *&L,PolyArray a,int n)//尾插法建立单链表{ PolyNode *s,*r;int i;L=(PolyNode *)malloc(sizeof(PolyNode)); //创建头结点L->next=NULL;r=L; //r始终指向终端结点,开始时指向头结点for (i=0;i<n;i++)< p="">{s=(PolyNode *)malloc(sizeof(PolyNode));//创建新结点s->coef=a[i].coef;s->exp=a[i].exp;r->next=s; //将*s插入*r之后r=s;}r->next=NULL;}void Sort(PolyNode *&head)//按exp域递减排序{ PolyNode *p=head->next,*q,*r;if(p!=NULL){ r=p->next;p->next=NULL;p=r;while(p!=NULL){ r=p->next;q=head;while(q->next!=NULL&&q->next->exp>p->exp)q=q->next;p->next=q->next;q->next=p;p=r;}}}void Add(PolyNode *ha,PolyNode *hb,PolyNode *&hc)//求两个有序集合的并{PolyNode *pa=ha->next,*pb=hb->next,*s,*tc;float c;hc=(PolyNode *)malloc(sizeof(PolyNode));tc=hc;while(pa!=NULL&&pb!=NULL){ if(pa->exp>pb->exp){ s=(PolyNode *)malloc(sizeof(PolyNode)); //复制结点s->exp=pa->exp;s->coef=pa->coef;tc->next=s;tc=s;pa=pa->next;}else if(pa->expexp){ s=(PolyNode *)malloc(sizeof(PolyNode)); //复制结点s->exp=pb->exp;s->coef=pb->coef;tc->next=s;tc=s;pb=pb->next;}else{ c=pa->coef+pb->coef;if(c!=0)//系数之和不为0事创建新结点{ s=(PolyNode *)malloc(sizeof(PolyNode));s->exp=pa->exp;s->coef=c;tc->next=s;tc=s;}pa=pa->next;pb=pb->next;}}if(pb!=NULL)pa=pb;//复制余下的结点while(pa!=NULL){ s=(PolyNode *)malloc(sizeof(PolyNode)); //复制结点s->exp=pa->exp;s->coef=pa->coef;tc->next=s;tc=s;pa=pa->next;}tc->next=NULL;}void main(){PolyNode *ha,*hb,*hc;PolyArray a={{1.5,0},{2.5,1},{3.3,3},{-2.5,5}};PolyArray b={{-1.5,0},{2.5,1},{3.7,3},{-2.5,5},{5.6,7}};CreateListR(ha,a,4);CreateListR(hb,b,5);printf("原多项式A为：");DispPoly(ha);printf("原多项式B为：");DispPoly(hb);Sort(ha);Sort(hb);printf("有序多项式A：");DispPoly(ha);printf("有序多项式B：");DispPoly(hb);Add(ha,ha,hc);printf("多项式相加结果：");DispPoly(hc); printf("\n");}</n;i++)<>。

数据结构多项式求和

数据结构多项式求和

数据结构-多项式相加

数据结构（C语言）用单链表存储一元多项式,并实现两个多项式的相加运算

数据结构多项式相加代码

数据结构多项式求和实验报告

多项式相加数据结构

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

数据结构-单链表-多项式相加

数据结构 多项式求和

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

数据结构一元多项式求和实验报告

数据结构实验报告完成多项式的运算

数据结构 多项式求和

数据结构多项式相加

数据结构—多项式求和

数据结构实验-多项式的相加减

数据结构-实验2-多项式求和

数据结构多项式求和

多项式相加的函数（数据结构_C语言版）

数据结构多项式求和

数据结构多项式求和