您的位置：360文档中心› 数据结构多项式求和

数据结构多项式求和

合集下载

数据结构多项式求和

数据结构多项式求和

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

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

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

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

比如，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语言）用单链表存储一元多项式,并实现两个多项式的相加运算

数据结构（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 }。

  1. 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

数据结构与算法
上机实验报告（一）
上机实验题目：一元多项式的表示及相加
专业班级：信息与计算科学1401班
姓名：邢鑫锋学号：140701211 设计室：理学院机房
上机时间： 2015-11-10 上机学时： 4学时
指导教师：杜洪波成绩：
一.实验目的：
1、进一步熟练掌握应用链表处理实际问题的能力
2、
二.实验内容：
1、一元多项式相加是通过键盘输入两个形如 P0+P1X1+P2X2+。

+PnXn 的多项式，经过程序运算后在屏幕上输出它们的相加和。

2、
3、
三、程序及注释：
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
typedef struct Node
{
int Data;
Node* next;
}SLNode;
void listInt(SLNode **T)
{if((*T=(SLNode*)malloc(sizeof(SLNode)))==NULL) exit(1);
(*T)->next=NULL;
}
void Create(SLNode *T,int n)
{
SLNode *p;
int i;
p=T;
for(i=0;i<n;i++)
{
SLNode *q=(SLNode*)malloc(sizeof(SLNode));
p->next=q;
printf("请输入链表数据\n");
scanf("%d",&q->Data);
p=q;
}
}
void Addtion(SLNode*T,SLNode*B,SLNode*C,int n) {
int i;
SLNode *p;
p=C;
for(i=0;i<n;i++)
{
SLNode *q=(SLNode*)malloc(sizeof(SLNode));
p->next=q;
T=T->next;
B=B->next;
q->Data=T->Data+B->Data;
p=q;
}
}
int main()
{
int j=0;
SLNode*T;SLNode*B;SLNode*C;
listInt(&T);
listInt(&B);
listInt(&C);
int n;
printf("请输入相加多项式的最大阶数\n");
scanf("%d",&n);
printf("请建立第一个多项式\n");
Create( T, n);
printf("请建立第二个多项式\n");
Create( B, n);
Addtion(T, B, C, n);
for(;j<n;j++)
{if(j!=n-1)
{ C=C->next;
printf("%d*x^%d+",C->Data,n-j);
}
else
{ C=C->next;
printf("%d*x^%d\n",C->Data,1);
}
}
return 0;
}
四．运行结果：
五．实验心得：
备注：页码不够可多加页码！。

相关文档
最新文档