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

合集下载

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

数据结构——一元多项式的建立与相加
#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";

数据结构C语言实现之一元多项式的表示及相加(2)

数据结构C语言实现之一元多项式的表示及相加(2)
以单链表作为存储结构并且和多项式中的结点无需另生成则可看成是将多项式b加到多项式a中由此得到下列运算规则设pq分别指向多项式ab的一项比较结点的指数项若pexpqexp则结点p所指的结点应是和多项式中的一项令指针p后移
数据结构 C 语言实现之一元多项式的表示及相加(2)
一元多项式的表示及相加 对于符号多项式的各种操作,实际上都可以利用线性表来处理。比较典型的是关于一元多项式的处理。在
} } e>next; /*将 q 结点加入到和多项式中*/ q =q->next; } }
} if(p!=NULL)/*多项式 A 中还有剩余,则将剩余的结点加入到和多项式中*/
pre->next=p;
else /*否则,将 B 中的结点加入到和多项式中*/ pre->next=q; }
算法 2.24 多项式相加 假设 A 多项式有 M 项,B 多项式有 N 项,则上述算法的时间复杂度为 O(M+N) 图 2.20 所示为图 2.19 中两个多项式的和,其中孤立的结点代表被释放的结点。
通过对多项式加法的介绍,我们可以将其推广到实现两个多项式的相乘,因为乘法可以分解为一系列的加 法运算。
“中的结点无需另生成,则可看成是将多项式 B 加到多项式 A 中,由此得到下列运算规则(设 p、q 分别 指向多项式 A,B 的一项,比较结点的指数项)
若 p->exp< q->exp,则结点 p 所指的结点应 是“和多项式”中的一项,令指针 p 后移;若 p>exp>q->exp,则结点 q 所指的结点应是“和多项式”中的一项,将结点 q 插入在结点 p 之前, 且令指针 q 在原来的链表上后移;
(1)用单链表存储多项式的结点结构如下: struct Polynode { int coef; int exp; Polynode *next; } Polynode , * Polylist;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

5. 遍历完其中一个链表后,将另一个链表剩余的节点依次插入到新链表中。

6. 返回新链表作为相加后的结果。

通过上述的设计,我们可以实现一元多项式的加法操作。

这种数据结构的好处是可以有效地存储一元多项式的各个项,并且在进行加法运算时可以按照幂次的大小进行有序操作,从而提高了计算效率。

除了加法操作,一元多项式的数据结构还可以支持其他常见的操作,例如减法、乘法、求导等。

这些操作可以通过类似的方式进行设计和实现,只需根据具体的需求进行相应的调整即可。

一元多项式的加法是数学中常见的操作,设计一个高效的数据结构来表示和计算一元多项式的加法对于数学计算和实际应用都具有重要意义。

数据结构一元多项式的运算

数据结构一元多项式的运算

数据结构一元多项式的运算正文:1. 引言本文档旨在介绍数据结构中一元多项式的运算方法。

一元多项式是指在一个变量上的多项式,其中每一项由一个系数和一个指数组成。

我们将会讨论一元多项式的表示、存储和基本运算,包括多项式的加法、减法、乘法和求导等操作。

2. 一元多项式的表示和存储2.1 一元多项式的定义一元多项式是指在一个变量x上的多项式,每一项由一个系数和一个指数组成,例如:2x^3 - 5x^2 + 3x + 1.其中,2、-5、3和1分别是系数,3、2、1和0分别是指数。

2.2 一元多项式的表示方法一元多项式可以使用数组、链表或其他数据结构来表示。

在本文中,我们选择使用数组来表示一元多项式。

数组的索引代表指数,数组的元素代表系数。

例如,多项式 2x^3 - 5x^2 + 3x + 1 可以表示为 [1, 3, -5, 2]。

2.3 一元多项式的存储结构为了表示一元多项式,我们可以使用一个数组来存储多项式的系数。

数组的长度应该比多项式的最高指数大1.数组的索引代表指数,数组的元素代表系数。

例如,数组 [1, 3, -5, 2] 表示的多项式 2x^3 - 5x^2 + 3x + 1 中,索引0对应指数为3的项,索引1对应指数为2的项,以此类推。

3. 一元多项式的基本运算3.1 一元多项式的加法一元多项式的加法是指将两个多项式相加,并合并同类项。

具体操作如下:- 将两个多项式的系数相加,并将结果存储在一个新的多项式中。

- 遍历新的多项式,将相邻的相同指数的项合并。

3.2 一元多项式的减法一元多项式的减法是指将一个多项式减去另一个多项式,并合并同类项。

具体操作如下:- 将两个多项式的系数相减,并将结果存储在一个新的多项式中。

- 遍历新的多项式,将相邻的相同指数的项合并。

3.3 一元多项式的乘法一元多项式的乘法是指将两个多项式相乘,并合并同类项。

具体操作如下:- 遍历一个多项式的每一项,与另一个多项式的每一项相乘。

数据结构一元多项式的运算

数据结构一元多项式的运算

数据结构一元多项式的运算数据结构一元多项式的运算1、引言1.1 研究背景1.2 研究目的2、一元多项式的定义2.1 一元多项式的概念2.2 一元多项式的表示方法2.3 一元多项式的次数和系数2.4 一元多项式的零多项式和常数项2.5 一元多项式的加法运算2.6 一元多项式的减法运算2.7 一元多项式的乘法运算3、一元多项式的特殊运算3.1 一元多项式的乘方运算3.2 一元多项式的取余运算3.3 一元多项式的求导运算3.4 一元多项式的积分运算3.5 一元多项式的复合运算4、一元多项式的应用4.1 一元多项式在数学中的应用4.2 一元多项式在计算机科学中的应用4.3 一元多项式在工程领域中的应用5、实例分析5.1 实例一:一元多项式的相加减5.2 实例二:一元多项式的乘法运算5.3 实例三:一元多项式的特殊运算应用6、结论附件:附件一:一元多项式的代码实现示例法律名词及注释:1.一元多项式: 指仅有一个未知数的多项式。

2.多项式的次数: 多项式中各项最高次幂的次数。

3.多项式的系数: 多项式中各项中未知数的系数。

4.零多项式: 所有系数均为0的多项式。

5.常数项: 多项式中次数为0的项,即常数项。

6.多项式的加法运算: 将两个多项式相同次项的系数相加。

7.多项式的减法运算: 将两个多项式相同次项的系数相减。

8.多项式的乘法运算: 将两个多项式的各项相乘,并根据指数相加合并同类项。

9.多项式的乘方运算: 将一个多项式自乘n次。

10.多项式的取余运算: 两个多项式相除后的余数部分。

11.多项式的求导运算: 对多项式中的每一项进行求导操作。

12.多项式的积分运算: 对多项式中的每一项进行积分操作。

13.多项式的复合运算: 将一个多项式代入另一个多项式中进行运算。

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

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

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

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

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

c语言数据结构实现——一元多项式的基本运算在C语言中,一元多项式的表示与运算是常见的数据结构操作之一。

一元多项式由一系列具有相同变量的单项式组成,每个单项式由系数和指数组成。

本文将介绍如何使用C语言实现一元多项式的基本运算,包括多项式的创建、求和、差、乘积等操作。

首先,我们需要定义一个结构体来表示单项式。

每个单项式由一个系数和一个指数组成,我们可以将其定义如下:```cstruct term{float coefficient; // 系数int exponent; // 指数};typedef struct term Term;```接下来,我们可以定义一个结构体来表示一元多项式。

一元多项式由一系列单项式组成,可以使用一个动态数组来存储这些单项式。

```cstruct polynomial{Term* terms; // 单项式数组int num_terms; // 单项式数量};typedef struct polynomial Polynomial;```现在,我们可以开始实现一元多项式的基本运算了。

1. 创建一元多项式要创建一元多项式,我们需要输入每个单项式的系数和指数。

我们可以使用动态内存分配来创建一个适应输入的单项式数组。

```cPolynomial create_polynomial(){Polynomial poly;printf("请输入多项式的项数:");scanf("%d", &poly.num_terms);poly.terms = (Term*)malloc(poly.num_terms * sizeof(Term));for(int i = 0; i < poly.num_terms; i++){printf("请输入第%d个单项式的系数和指数:", i+1);scanf("%f %d", &poly.terms[i].coefficient, &poly.terms[i].exponent);}return poly;}```2. 求两个一元多项式的和两个一元多项式的和等于对应指数相同的单项式系数相加的结果。

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

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

数据结构——链表实现⼀元多项式的表⽰和加法⼀元多项式的链式结构: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*/。

一元多项式表示与相加

一元多项式表示与相加

系数 coef 指数 exp 指针 next
结点结构体定义如下: struct Polynode { int coef; int exp; Polynode *next; } Polynode , * Polylist;
例:建立一元多项式链式存储算法 【算法思想】通过键盘输入一组多项式的系数和指数,用尾插法建立一元 多项式的链表。以输入系数 0 为结束标志,并约定建立多项式链表时,总 是按指数从小到大的顺序排列。 【算法描述】
scanf(“%d,%d”,&c,&e);/*键入多项式的系数和指数项*/
while(c!=0)
/*若 c=0,则代表多项式的输入结束*/
{
s=(Polynode*)malloc(sizeof(Polynode)); /* 申 请 新
的结点*/
s->coef=c ;
s->exp=e ;
rear->next=s ;
① 若 p->exp< q->exp,则结点 p 所指的结点应是“和多项式”中的 一项,令指针 p 后移;
② 若 p->exp=q->exp,则将两个结点中的系数相加,当和不为零时 修改结点 p 的系数域,释放 q 结点;若和为零,则和多项式中无此项,从 A 中 删去 p 结点,同时释放 p 和 q 结点。
B(x)=8x+22x7-9x8
polya
-1
polyb
-1
70 81
31
98
5 17 ∧
22 7
-9 8 ∧
(2)多项式相加的运算规则 为了保证“和多项式”中各项仍按升幂排列,在两个多项式中: ①指数相同项的对应系数相加,若和不为零,则构成“和多项式”中的一 项; ②指数不相同的项仍按升幂顺序复抄到“和多项式”中。 【算法思想】以单链表 polya 和 polyb 分别表示两个一元多项式 A 和 B, A+B 的求和运算,就等同于单链表的插入问题(将单链表 polyb 中的结点插入 到单链表 polya 中),因此 “和多项式“中的结点无需另生成。 为实现处理,设 p、q 分别指向单链表 polya 和 polyb 的当前项,比较 p、q 结点的指数项,由此得到下列运算规则:

数据结构PTA-一元多项式的乘法与加法运算数组链表

数据结构PTA-一元多项式的乘法与加法运算数组链表

数据结构PTA-⼀元多项式的乘法与加法运算数组链表⼀元多项式的乘法与加法运算输⼊格式:输⼊分2⾏,每⾏分别先给出多项式⾮零项的个数,再以指数递降⽅式输⼊⼀个多项式⾮零项系数和指数(绝对值均为不超过1000的整数)。

数字间以空格分隔。

输出格式:输出分2⾏,分别以指数递降⽅式输出乘积多项式以及和多项式⾮零项的系数和指数。

数字间以空格分隔,但结尾不能有多余空格。

零多项式应输出0 0。

输⼊样例:4 3 4 -5 26 1 -2 03 5 20 -74 3 1输出样例:15 24 -25 22 30 21 -10 20 -21 8 35 6 -33 5 14 4 -15 3 18 2 -6 15 20 -4 4 -5 2 9 1 -2 0思路⽤了太多次链表实在是⽤吐了,虽然运⾏起来很爽,但是编写太⿇烦了,换数组解决。

这⾥参考了⼀下其他⼤佬的思路问题的关键在于变量其实是两个(指数和系数),放在⼀起紧挨着或分成两个数组都不好处理,尤其是多项式相乘是⼀种交叉相乘的计算。

⽐较巧妙的处理⽅式是将取数组的位置为指数,该位置对应的值为系数。

应注意反之不可,因为可以存在n倍的x0(即常数),⽽不存在0倍的x n。

区别于其他⼲扰数可以通过初始化数组为0来实现。

参考:https:///yuxiaoba/p/8326018.htmlhttps:///Jie-Fei/p/10138885.html代码:#include<bits/stdc++.h>using namespace std;#define P 10000int main(){int a[10000]= {0},b[10000]= {0};//输⼊数组int c[10000]= {0},d[10000]= {0};//结果数组int n,m;int i,j;int flag; //⽤于判断输出空格int x,y; //系数&指数scanf("%d",&n);for(i=0; i<n; i++){scanf("%d %d",&x,&y);a[y]=x; //指数为位置,系数为数组}scanf("%d",&m); //同上输⼊for(i=0; i<m; i++){scanf("%d %d",&x,&y);b[y]=x;}for(i=P-1; i>=0; i--) //////////两数相乘{if(a[i]!=0){for(j=0; j<P; j++){if(b[j]!=0){c[i+j]+=a[i]*b[j];}}}}flag=0; //输出乘式 for(i=P-1; i>=0; i--){if(c[i]!=0){if(flag!=0)printf(" ");printf("%d %d",c[i],i);flag++;}}if(flag==0 ) //扣分点{printf("0 0");}printf("\n"); //换⾏for(i=P-1; i>=0; i--) //两式相加 {if(a[i]!=0)d[i]+=a[i];if(b[i]!=0)d[i]+=b[i];}flag=0; //输出加式 for(i=P-1; i>=0; i--){if(d[i]!=0){if(flag!=0)printf(" ");printf("%d %d",d[i],i);flag++;}}if(flag==0 ) //扣分点{printf("0 0");}}。

数据结构一元多项式的运算

数据结构一元多项式的运算

数据结构一元多项式的运算第一章引言在计算机科学中,数据结构是研究非原子数据对象的组织、存储和管理的科学和技术。

一元多项式是代数中的基本概念之一,它在计算机科学中有着广泛的应用。

本文将介绍一元多项式的运算,包括多项式的表示、加法、减法、乘法等操作。

第二章多项式的表示1.稀疏数组表示法稀疏数组表示法是一种常用的多项式表示方法。

它通过一个数组来存储多项式中非零项的指数和系数。

数组的下标表示项的指数,数组元素表示项的系数。

对于没有出现的指数,数组元素为零。

2.链表表示法链表表示法是另一种常用的多项式表示方法。

每个节点包含项的指数和系数,并通过指针串接成链表。

链表的节点可以按照指数的升序或降序排列。

第三章多项式的加法多项式的加法是指将两个多项式相加得到一个新的多项式。

具体操作如下:1.根据多项式的表示方法,分别遍历两个多项式的非零项。

2.比较当前项的指数大小,如果两个指数相等,则将系数相加得到新的系数,并将结果加入结果多项式中。

3.如果一个多项式的指数大于另一个多项式的指数,则将该项加入结果多项式中。

4.重复以上操作,直到遍历完所有的非零项。

第四章多项式的减法多项式的减法是指将两个多项式相减得到一个新的多项式。

具体操作如下:1.根据多项式的表示方法,分别遍历被减数和减数的非零项。

2.比较当前项的指数大小,如果两个指数相等,则将被减数的系数减去减数的系数得到新的系数,并将结果加入结果多项式中。

3.如果被减数的指数大于减数的指数,则将该项加入结果多项式中,并将被减数的系数变为相反数。

4.重复以上操作,直到遍历完所有的非零项。

第五章多项式的乘法多项式的乘法是指将两个多项式相乘得到一个新的多项式。

具体操作如下:1.创建一个结果多项式,将其初始化为零多项式。

2.根据多项式的表示方法,分别遍历两个多项式的非零项。

3.将两个项的系数相乘得到新的系数,并将两个项的指数相加得到新的指数。

4.将新的系数和指数合并为一个项,并将该项加入结果多项式中。

一元多项式求和数据结构

一元多项式求和数据结构

一元多项式求和数据结构
一元多项式是指只包含一个变量的多项式,例如 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一元多项式的表示及相加

§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 ∧

数据结构一元多项式的运算-无删减范文

数据结构一元多项式的运算-无删减范文

数据结构一元多项式的运算数据结构一元多项式的运算简介一元多项式是数学中常见的概念,用于表示一个变量的多项式表达式。

在计算机科学中,经常需要对一元多项式进行各种运算,如加法、减法、乘法等。

为了实现这些运算,可以使用数据结构来存储和操作一元多项式。

本文将介绍一元多项式的数据结构和常见的运算方法,并给出相应的代码示例。

数据结构一元多项式可以用链表来表示。

每个节点包含两个部分:系数(coefficient)和指数(exponent)。

系数表示该项的权重,指数表示该项的幂次。

链表的每个节点按照指数的升序排列。

以下是一个一元多项式的链表表示的示例:```markdown1.2x^2 + 3.7x^4 - 0.5x^3 -2.1x^1 + 4.0``````markdownNode 1: coefficient=1.2, exponent=2Node 2: coefficient=3.7, exponent=4Node 3: coefficient=-0.5, exponent=3Node 4: coefficient=-2.1, exponent=1Node 5: coefficient=4.0, exponent=0```运算方法加法运算两个一元多项式相加可以按照如下步骤进行:1. 遍历两个链表的节点,分别取出当前节点的系数和指数。

2. 如果两个节点的指数相等,将系数相加,并将其作为结果链表的节点。

3. 如果两个节点的指数不相等,将指数较小的节点插入结果链表,并继续遍历指数较大的节点。

4. 当其中一个链表遍历完后,直接将另一个链表的节点插入结果链表。

以下是加法运算的代码示例:```pythondef addPolynomials(p1, p2):result = Nonetl = Nonewhile p1 is not None and p2 is not None:if p1.exponent == p2.exponent:coef_sum = p1.coefficient + p2.coefficient if coef_sum != 0:node = Node(coef_sum, p1.exponent)if result is None:result = tl = nodeelse:tl.next = nodetl = nodep1 = p1.nextp2 = p2.nextelif p1.exponent > p2.exponent:node = Node(p1.coefficient, p1.exponent) if result is None:result = tl = nodeelse:tl.next = nodetl = nodep1 = p1.nextelse:node = Node(p2.coefficient, p2.exponent) if result is None:result = tl = nodeelse:tl.next = nodetl = nodep2 = p2.nextwhile p1 is not None:node = Node(p1.coefficient, p1.exponent)if result is None:result = tl = nodeelse:tl.next = nodetl = nodep1 = p1.nextwhile p2 is not None:node = Node(p2.coefficient, p2.exponent) if result is None:result = tl = nodeelse:tl.next = nodetl = nodep2 = p2.nextreturn result```减法运算减法运算可以看作加法运算的特殊情况,即将第二个多项式的系数取负数,再进行加法运算。

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

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

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

实验一一元多项式的表示与相加实验目的: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(" I nput 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(" I nput 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(" I nput 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语言有些生疏和遗忘,在编程过程中出现很多错误。

相关文档
最新文档