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

合集下载

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

数据结构.第2章.线性表.2.一元多项式的表示及相加

Pc
Pa Pb
Pc 10 6
1 0 /\
§2.4 一元多项式的表示及相加 ❖例2：设两个一元多项式为
A(x)= 4 + 6x4 + 5x8 + 4x12 B(x)= 2x3 - 5x8 + 3x12 + 7x15
求此两一元多项式之和: C(x)=A(x)+B(x)
§2.4 一元多项式的表示及相加
} ADT Polynomial
§2.4 一元多项式的表示及相加
❖实现思路
▪ 依次比较Pa和Pb所指结点中的指数项，依
Pa―>expn =、<、> Pb―>expn等情况，再决定
是将两系数域的数值相加(并判其和是否为0)，还是将较高指数项的结点插入到新表C中。
§2.4 一元多项式的表示及相加 ❖例1：设两个一元多项式为
习题与练习
2. 在一个单链表HL中，若要在指针q指向的结点的后面插入一个由指针P指向的结点，则执行（）。 A） q -> next = p -> next ； p = q； B） p -> next = q -> next ； q = p； C） q -> next = p -> next ； p -> next = q ； D） p -> next = q -> next ； q -> next = p ；
ha=GetHead(pa); hb=GetHead(pb) ; // ha和hb分别指向Pa和Pb的头结点
int cmp (term a，term b) ；
qa=NextPos(pa, ha); qb=NextPos(pb, hb) ; //qa和qb分别指向Pa和Pb中当前结点

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

一元多项式相加问题实验报告一元多项式相加问题一、问题描述通过键盘输入两个形如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 为头指针的一个新链表中。

数据结构——一元多项式的建立与相加

#include<iostream>
#include <cmath>
using namespace std;
typedef struct PolyNode
{
int coef; //系数
int expn; //指数
struct PolyNode *next;
} *PNode; //多项式结点的指针
void InitPoly(PNode &head,PNode &p)
{
int n;
PNode s,p;
pa=pa->next;
pb=pb->next;
p=pc;
while (pa!=NULL && pb!=NULL)
{
if (pa->expn>pb->expn)
{
s=(PNode)malloc(sizeof(struct PolyNode));
s->coef=pa->coef;
{
if(i) //显示第一对的时候是不需要显示加号的
{
if (p->expn==1) cout<<p->coef<<"x";
else if (p->expn==0) cout<<p->coef<<endl;
else cout<<p->coef<<"x^"<<p->expn;
i=0;
}
else
{
if (p->expn==1) cout<<p->coef<<"+x";

数据结构线性结一元多项式的加法乘法实现

5x20-4x4-5x2+9x-2
求解思路
1.多项式表示 2. 程序框架 3. 读多项式 4. 加法实现 5. 乘法实现 6. 多项式输出
多项式的表示
仅表示非零项
数组：编程简单、调试容易
需要事先确定数组大小
一种比较好的实现方法是: 动态数组
链表：
动态性强编程略为复杂、调试比较困难
while (t1 && t2) {
if (t1->expon == t2->expon) {
…..
}
else if (t1->expon > t2->expon) {
……
}
else {
……
}
}
while (t1) {
return 0; }
如何读入多项式
Polynomial ReadPoly() {
…… scanf("%d", &N); …… while ( N-- ) {
scanf("%d %d", &c, &e); Attach(c, e, &Rear); } ….. return P; }
4 3 4 -5 2 6 1 -2 0
两种处理方法： 1. Rear初值为NULL
在Attach函数中根据Rear是否为NULL做不同处理
Attach
ce
Rear (当前结果表达式尾项指针)
Rear
如何读入多项式
Polynomial ReadPoly() {
…… scanf("%d", &N); …… while ( N-- ) {
多项式的乘积: (a+b)(c+d) = ac+ad+bc+bd

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

一元多项式的加法数据结构一元多项式是数学中常见的一种表达形式，它可以表示为各个项的和，每个项由一个系数和一个幂次组成。

在实际应用中，一元多项式的加法操作非常常见，因此设计一个高效的数据结构来表示和计算一元多项式的加法是非常重要的。

在一元多项式的加法操作中，我们需要考虑的主要问题有两个：一是如何存储一元多项式的各个项，二是如何进行多项式的加法运算。

对于第一个问题，我们可以使用链表来存储一元多项式的各个项。

链表的每个节点可以表示一个多项式的项，其中包含两个数据成员：一个表示系数的值，一个表示幂次的值。

通过链表的链接关系，可以按照幂次的从小到大的顺序存储一元多项式的各个项，从而方便后续的加法运算。

对于第二个问题，我们可以设计一个函数来实现一元多项式的加法运算。

该函数接受两个参数，分别是待相加的两个一元多项式。

在函数内部，我们需要遍历两个链表，按照幂次的大小比较来确定相应的操作。

具体的步骤如下：1. 创建一个新的链表，用于存储相加后的结果。

2. 初始化两个指针，分别指向两个待相加的链表的头节点。

3. 进行循环遍历，直到两个链表均为空。

4. 比较两个链表当前节点的幂次大小。

- 若幂次相等，则将两个节点的系数相加，并将结果插入到新链表中。

- 若幂次不等，则将系数较小的节点插入到新链表中，并将指针指向下一个节点。

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：ox^%d,p->cof,p->exp); p=p->next; while (p){ if(p->cof>0) printf(+);//系数正负号if (fabs(p->cof)<=0.000001); break;//不输出系数为零的项printf(ox^%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语言有些生疏和遗忘，在编程过程中出现很多错误。

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

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

数据结构——链表实现一元多项式的表示和加法

数据结构——链表实现⼀元多项式的表⽰和加法⼀元多项式的链式结构：Typedef struct Lnode{float coef;///系数int expn;///指数struct Lnode *next;} PLnode, *PLinkList;基本思想：（1）若pa->expn⼩于pb->expn,则pa继续向前扫描；(2）若pa->expn等于pb->expn,将其系数相加，若相加结果不为0，将结果放⼊pa->coef中，并删除pb所指的结点，否则同时删除pa和pb所指的结点，然后pa和pb继续向前扫描；（3）若pa->expn⼤于pb->expn,则将pb所指的结点插⼊pa所指的结点之前，然后pb继续向前扫描；（4）重复上述过程直到pa或pb有⼀个为空为⽌，最后将剩余结点的链表接在结果链表上。

PLinklist Add(PLinklist pa,PLinklist pb){PLinklist p,q,r,s; /*两个多项式相加*/int cmp,x;p=pa->next; /*指向pa的第⼀个元素*/q=pb->next; /*指向pb的第⼀个元素*/s=pa; /*s作为P的跟踪指针*/r=pb;/*r作为q的跟踪指针*/while(p!=NULL&&q!=NULL){if(p->exp<q->exp){cmp=-1;}else if(p->exp>q->exp){cmp=1;}else///指数相等{cmp=0;}switch(cmp){/*根据指数的⽐较情况进⾏不同的处理*/case -1:{s=p;p=p->next;///pa表指针后移，没有插⼊break;}case0:{x=p->coef+q->coef;///指数相等，系数相加if(x!=0) /*系数不为0*/{p->coef=x;s=p;p=p->next;}/*if*/else///系数为0,在pa表中删除该结点{s->next=p->next;free(p);p=s->next;}/*else*/r->next=q->next;///在pb表中删除该结点free(q);q=r->next;break;} /*case0*/case1:{q->next=s->next;s->next=q;///将pb表中的q插⼊到pa表中的s的后⾯r->next=q->next;s=q;q=r->next;break;} /*case1*/}/*switch*/}/*while*/if(q!=NULL)///当pb连表还有剩余时接⼊到pa连表的尾部 {s->next=q;}free(pb);return pa;}/* Add*/。

一元多项式相加

⼀元多项式相加描述：对于两个⼀元多项式，如果需要对他们进⾏多项式相加操作，常见的两种思路如下：(1)对于⼀个多项式，保存其最⾼项次数HighPowder，以及⼀个该多项式对应次数分别为0-HighPowder的各项的系数的数组()。

(2)多项式中系数不为零的每⼀项，保存其系数与该项的次数。

下⾯分别⽤这两种思路实现⼀元多项式加法操作。

思路⼀（数组实现）：数据结构定义：1 typedef struct Poly2 {3int CoeffArray[11];4int HighPower;5 } *Polynomial;实现：1 #include <stdio.h>2 #include <stdlib.h>34 typedef struct Poly5 {6int CoeffArray[11];7int HighPower;8 } *Polynomial;910void ZeroPolynomial(Polynomial Poly)11 {12int i;13for(i = 0; i < 11; i++)14 {15 Poly->CoeffArray[i] = 0;16 }17 Poly->HighPower = 0;18 }1920void AddPolynomial(Polynomial Poly1,Polynomial Poly2, Polynomial PolySum)21 {22int i;23 ZeroPolynomial(PolySum);24 PolySum->HighPower = Poly1->HighPower > Poly2->HighPower?25 Poly1->HighPower:Poly2->HighPower;26for(i = PolySum->HighPower; i >= 0 ; i--)27 {28 PolySum->CoeffArray[i] = Poly1->CoeffArray[i] + Poly2->CoeffArray[i];29 }30 }3132int main(void)33 {34int i,j,k;35 Polynomial P1,P2,Sum;36 P1 = malloc(sizeof(struct Poly));37 P2 = malloc(sizeof(struct Poly));38 Sum = malloc(sizeof(struct Poly));39//初始化40 ZeroPolynomial(P1);41 ZeroPolynomial(P2);42 P1->HighPower = 10;43for(i = 10; i >= 0; i--)44 {45 P1->CoeffArray[i] = i;46 }4748 P2->HighPower = 8;49for(j = 8; j >=0; j--)50 {51 P2->CoeffArray[j] = j;52 }53 P2->CoeffArray[8] = 8;54 AddPolynomial(P1,P2,Sum);5556 printf("The high power of the Polynomial is %d\n",Sum->HighPower); 57for(k = 0; k <= 10; k++)58 {59 printf("The Coeff of power %d is %d\n",k,Sum->CoeffArray[k]);60 }6162return0;63 }它适合⼤部分项都有的稠密多项式。

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

实验报告课程名称：数据结构实验名称：一元多项式的相加班级： 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;//完成运算符和其他项的输//出,然后类似于上面，对第二个多项式进行相应的操作。

【数据结构】一元多项式相加

【数据结构】一元多项式相加#include<stdio.h>//建立存储多元式的结点结构的单链表typedef struct PloyNode{float xishu; /*多项式的系数*/int zhishu; /*指数*/struct PloyNode *next; /*next是struct PloyNode类型中的一个成员，它又指向struct PloyNode类型的数据，以此建立链表*/}PloyNode;/*指针函数，返回指针类型；用尾插法建立一元多项式的链表的函数*/PloyNode *create(){PloyNode *h,*r,*s;float xishu;int zhishu;/*建立多项式的头结点，为头结点分配存储空间*/h=(PloyNode *)malloc(sizeof(PloyNode));/*r指针始终动态指向链表的当前表尾，以便于做尾插入，其初值指向头结点*/ r=h;printf("请输入系数:\n");scanf("%g",&xishu); /*输入系数*//*浮点数的输入与输出，如果是%g，则可以将小数点后多余的0省略*//*如果是%f则不能省略后面多余的0*/printf("请输入指数:\n");scanf("%d",&zhishu); /*输入指数*//*输入系数为0时，表示多项式的输入结束*/while(xishu != 0){s=(PloyNode *)malloc(sizeof(PloyNode)); /*申请新结点*/s->xishu=xishu; /*申请新结点后赋值*/s->zhishu=zhishu; /*申请新结点后赋值*/r->next=s; /*做尾插，插入新结点*/r=s; /*r始终指向单链表的表尾*/printf("请输入系数:\n");scanf("%g",&xishu); /*输入系数*/printf("请输入指数:\n");scanf("%d",&zhishu); /*输入指数*/}r->next=NULL; /*将表的最后一个结点的next置NULL，以示表结束*/return(h);}// 执行一元多项式相加（参考教材43页）/*一元多项式相加函数，用于将两个多项式相加，然后将和多项式存放在多项式pa中，并将多项式pb删除*///这里没有申请新的链表，存放新结点，而是在原有的A链表中操作void AddPolyn(PloyNode *pa, PloyNode *pb){PloyNode *p,*q,*pre,*temp;int sum;p=pa->next;/*令p和q分别指向polya和polyb多项式链表中的第一个结点*/ q=pb->next;pre=pa; /*位置指针，指向和多项式polya*//*当两个多项式均未扫描结束时，执行以下操作,同时操作两个链表*/while(p != NULL && q != NULL){/*若p指向的多项式指数小于q指的指数*/if(p->zhishu < q->zhishu){pre->next=p; /*将p结点加入到和多项式中*/pre=pre->next;p=p->next;}/*若指数相等，则相应的系数相加*/else if(p->zhishu == q->zhishu){sum = p->xishu + q->xishu;if(sum != 0){p->xishu = sum;pre->next = p;pre = pre->next;p = p->next;temp = q;q = q->next;free(temp);}/*如果系数和为零，则删除结点p与q，并将指针指向下一个结点*/else{temp=p->next;free(p);p=temp;temp=q->next;free(q);q=temp;}}else /*若p指数大于q指数*/{pre->next=q; /*p结点不动，将q结点加入到和多项式中*/pre=pre->next;q=q->next;}}if(p!=NULL) /*多项式A中还有剩余，则将剩余的结点加入到和多项式中*/ pre->next=p;else /*否则将B的结点加入到和多项式中*/pre->next=q;}void print(PloyNode * p) /*输出函数，打印出一元多项式*/{while(p->next!=NULL){p = p->next;//你们想办法在中间加一个加号！printf(" %g*x^%d ",p->xishu,p->zhishu);}//输出完毕后，换行printf("\n");}/*主函数*/main(){PloyNode *pa,*pb;printf("现在是建立单链表A：输入系数是0代表结束\n");pa=create(); /*调用建立链表函数，创建多项式A*/printf("单链表A = ");print(pa);printf("现在是建立单链表B：输入系数是0代表结束\n");pb=create(); /*同理，创建B*/printf("单链表B = ");print(pb);printf("单链表A + 单链表B = ");AddPolyn(pa,pb); /*调用一元多项式相加函数*/print(pa); /*调用输出函数，打印结果*/ }。

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

一元多项式加法一、实验目的通过实现多项式加法，对链表有更深入的了解二、实验内容问题描述：设计一个一元稀疏多项式简单的加法计算器实现要求：一元稀疏多项式简单计算器的基本功能是：（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 作为一元多项式的求和结果。

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

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

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

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

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

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

数据结构线性表2一元多项式的表示及相加

§2.4 一元多项式的表示及相加
❖抽象数据类型一元多项式的定义
ADT Polynomial { 数据对象: D＝{ ai|ai∈TermSet, i=1,2,...,m, m≥0 TermSet 中的每个元素包含一个表示系数的实数和表示指数的整数 } 数据关系: R＝{ <ai-1,ai>|ai-1 ,ai∈D, i=2,...,n 且ai-1中的指数值＜ai中的指数值 } 基本操作： CreatPolyn(&P,m) 操作结果：输入m项的系数和指数，建立一元多项式P DestroyPolyn(&P) 操作结果：销毁一元多项式P PrintPolyn(P) 操作结果：打印输出一元多项式P。 PolynLength(P) 操作结果：返回一元多项式P中的项数。 AddPolyn(&Pa,&Pb) 操作结果：完成多项式相加运算，并销毁一元多项式 SubtractPolyn(&Pa,&Pb) 操作结果：完成多项式相减运算，并销毁一元多项式Pb MultiplyPolyn(&Pa,&Pb) 操作结果：完成多项式相乘运算，并销毁一元多项式Pb
S (x) = 1 + 3x10000 – 2x20000
的多项式，上述表示方法是否合适？
§2.4 一元多项式的表示及相加
一般情况下的一元稀疏多项式可写成 Pn(x) = p1xe1 + p2xe2 + ┄ + pmxem
其中：pi 是指数为 ei 的项的非零系数， 0 ≤ e1 < e2 < … < em = n
headA head B
40 23
64 -5 8
58 3 12
4 12 ∧ 7 15 ∧

数据结构课程设计—一元多项式加法、减法、乘法运算的实现

1。

一元多项式加法、减法、乘法运算的实现1。

1设计内容及要求1)设计内容（1）使用顺序存储结构实现多项式加、减、乘运算。

例如：10321058)(2456+-+-+=x x x x x x f ,x x x x x x g +--+=23451020107)(求和结果:102220128)()(2356++-+=+x x x x x g x f(2）使用链式存储结构实现多项式加、减、乘运算，10305100)(1050100+-+=x x x x f ，x x x x x x g 320405150)(10205090+++-=求和结果：1031040150100)()(102090100++-++=+x x x x x x g x f2)设计要求（1）用C 语言编程实现上述实验内容中的结构定义和算法。

（2）要有main()函数，并且在main()函数中使用检测数据调用上述算法.（3）用switch 语句设计如下选择式菜单.***＊＊*＊＊＊＊＊*＊＊＊数据结构综合性实验＊＊*＊＊＊**＊*＊*＊＊****＊*＊**一、多项式的加法、减法、乘法运算＊＊*＊**＊**＊＊*＊＊＊*＊ 1。

多项式创建 **＊*＊＊＊*＊＊＊**＊＊＊＊ 2。

多项式相加 *＊＊＊＊＊*＊＊＊＊＊*＊*＊* 3.多项式相减＊*＊＊＊*＊＊*＊*＊＊＊*** 4。

多项式相乘 *＊******＊**＊＊*＊** 5。

清空多项式 **＊＊*＊＊**＊＊*＊＊＊＊* 0.退出系统 ***＊＊＊＊*＊**＊＊＊*＊* 请选择（0—5）＊＊＊*＊**＊*****＊＊＊*＊＊＊**＊*＊＊＊****＊**＊*＊＊＊****＊*＊＊*＊*******＊**＊请选择（0—5）：1.2数据结构设计根据下面给出的存储结构定义:＃define MAXSIZE 20 //定义线性表最大容量//定义多项式项数据类型typedef struct｛float coef; //系数int expn； //指数｝term，elemType;typedef struct{term terms[MAXSIZE］； //线性表中数组元素int last； //指向线性表中最后一个元素位置}SeqList；typedef SeqList polynomial；1。

数据结构课程设计报告一元多项式相加

数据结构课程设计报告题目：一元多项式相加学号：姓名：指导老师：时间： 2011年10月18日星期二程序建立的过程及步骤：1首先建立一个定义多项式的结构体duoxiangshi，其中包括一个指数（int型），一个系数（float型），还有一个指向下一项的指针，具体编译代码如下：typedef struct duoxiangshi//定义一个多项式{float coef;//多项式系数int exp;//多项式指数struct duoxiangshi *next;};2在定义一个函数（1），用来指导用户输入程序运行时所需要的必须得数据，两个一元多项式的项数、系数、指数。

具体的代码如下：void creatDuoX(Polynomial &Px,int n)//定义一个多项式函数{initDuoX(Px);duoxiangshi *p,*q;p=Px;for(int i=1;i<=n;i++){q=new duoxiangshi;cout<<"第"<<i<<"项的系数：";cin>>q->coef;//输入系数cout<<"第"<<i<<"项的指数：";cin>>q->exp;//输入指数q->next=NULL;p->next=q;p=q;}}3定义一个计算合并后的多项式的项数的函数（2），此函数的主要作用是用来最后输出合并后的多项式的时候起到作用。

具体代码如下：int lengthDuoX(Polynomial &Px)//计算多项式项数的函数，返回值是这个合并后的多项式的项数{duoxiangshi *p;int count;//定义一个变量，用来计算多项式的长度p=Px->next;count=0;while(p!=NULL){p=p->next;count++;//自加最后得出总项数并返回}return count;}4定义一个输出合并后的多项式的函数（3），主要作用为主函数调用后可以输出一元多项式，具体代码如下：void outputDuoX(Polynomial &Px)//输出合并后的多项式{ duoxiangshi *p;p=Px->next;int i;for(i=0;i<lengthDuoX(Px);i++)//调用上一个计算项数的函数，逐项的输出合并后的项{cout<<p->coef<<"*X^ "<<p->exp<<" +";p=p->next;}cout<<"0"<<endl;}5, 最重要的核心部分，程序的逻辑中心，让两个多项式相加，其中要考虑的情况如下一：两个多项式A、B 都为0二：其中一个多项式A 为0，B不为0三：其中一个多项式B为0，A不为0四：A与B 都不为0而在程序中我将二与三这两种情况，通过IF语句将其嵌到四的情况中，这样可以节省代码的复杂度。