实习报告
题目：设计一个一元稀疏多项式计算器
班级: 姓名学号__________完成日期：__
一、课程题目
一元稀疏多项式计算器
二、需求分析
1、一元稀疏多项式简单计算器的功能是：
1.1 输入并建立多项式；
1.2 输出多项式，输出形式为整数序列：n，c1,e1,c2,e2,………cn,en,
其中n是多项式的项数，ci和ei分别是第i项的系数和指数，序列按指数降序排列；
1.3 求多项式a、b的导函数；
1.4 计算多项式在x处的值；
1.5多项式a和b相加，建立多项式a+b；
1.6 多项式a和b相减，建立多项式a-b。
2、设计思路:
2.1 定义线性表的动态分配顺序存储结构；
2.2 建立多项式存储结构，定义指针*next
2.3利用链表实现队列的构造。每次输入一项的系数和指数，可以输出构
造的一元多项式
3、测试数据：
（1）、(2x+5x^8-3.1x^11)+(7-5x^8+11x^9)=(-3.1x^11+11x^9+2x+7);
（2）、(6x^-3-x+4.4x^2-1.2x^9+1.2x^9)-(-6x^-3+5.4x^2-x^2+7.8x^15 )=(-7.8x^15-1.2x^9+12x^-3-x);
（3）、(1+x+x^2+x^3+x^4+x^5)+(-x^3-x^4)=(1+x+x^2+x^5);
（4）、(x+x^3)+(-x-x^3)=0;
（5）、(x+x^100)+(x^100+x^200)=(x+2x^100+x^200);
（6）、(x+x^2+x^3)+0=x+x^2+x^3.
三、概要设计
1.有序表的抽象数据类型定义为：
ADT List{
数据对象：D={a i| a i∈R,i=1,2,…,n,n≧0}
数据关系：R1={< a i-1, a i>| a i-1,a i∈D, a i-1,基本操作：InitList()操作结果：构造一个空的有序表L。DestroyList(L)初始条件：有序表L已存在。操作结果：销毁有序表L。ListLength(L)初始条件：有序表L已存在。操作结果：返回有序表L的长度。ClearList( L )初始条件：有序表L已存在。操作结果：清空链表内容。Ins_before ( N,N )初始条件：有序表L已存在。操作结果：插入节点到链表。} ADT OrderedList2.多项式的抽象数据类型定义为：ADT Poly {数据对象：D={a i |a i为实数，i=1，2，…，n}数据关系：R1={}基本操作：CreatePoly( L,N )初始条件：N为节点，L为有序表。操作结果：将N 插入多项式的适当位置。GetPoly( L )操作结果：将用户输入转换为节点。PrintPoly( L )初始条件：多项式L已存在。操作结果：显示多项式。AddPoly( L_1,L_2,L_add )初始条件：多项式L_1,L_2,L_add已存在。操作结果：生成L_1,L_2之和的多项式L_addDiffPoly( L ,L_diff)初始条件：多项式L ,L_diff已存在。操作结果：生成L的导数多项式L_add。AlterPoly( L )初始条件：多项式L已存在。操作结果：将L多项式取相反数。}ADT Poly、三、详细设计1、Constant.h#ifndef __constant__#define __constant__#include#include#define TURE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2typedef int Status;#endif2、Polynt.h#include"constant.h"typedef struct elemType{float coef;//系数int expn;//指数}ElemType;typedef struct node{ElemType data; //指向结点元素的值struct node *next; //后继}Node,*Polyn; //结点类型，指针类型typedef struct{Node *head;Node *tail;}List;Status MakeNode(Polyn &p,ElemType e); //分配由p指向的数据元素为e、后继为“空”的结点Status InitList(List &L); //构造链表Status DestroyList(List &L); //销毁线性表void Insert(List &L,Polyn s); //将s指向的结点插入L的最后一个结点void Insbefore(Polyn p,Polyn q);Status CreatPolyn(List &polynomial,int m); //创建一个一元多项式polynomial，并输入m项的指数和系数void PrintPolyn(List L); //打印输出一元多项式void AlterPoly(List L); //减法void AddPolyn(List L1,List L2,List &L3); //多项式加法3、Polyn.cpp#include"Polynt.h"Status MakeNode(Polyn &p,ElemType e){//分配由p指向的数据元素为e、后继为“空”的结点p=(Polyn)malloc(sizeof(Node));p->data.coef=e.coef;p->data.expn=e.expn;p->next=NULL;return OK;}Status InitList(List &L){//初始化链表ElemType e;Polyn p;e.coef = ' ';e.expn = ' ';MakeNode(p,e);L.head = p;L.tail=p;return OK;}Status DestroyList(List &L){//销毁链表Polyn p,q;if(L.head==L.tail) {free(L.head);L.head=L.tail=NULL;return OK;} p=L.head->next;while(!p){q=p->next;free(p);p=q;}L.head=L.tail=NULL;return OK;}void Insert(List &L,Polyn s){if(L.head->next ==NULL){L.head->next =s;s->next =NULL;L.tail = s;}else{if(L.head->next!=NULL && s->data.expn>L.head->next->data.expn){s->next=L.head->next;L.head->next=s; return;}if(L.tail->data.expn>s->data.expn){L.tail->next=s; L.tail=s;return;}for (Polyn p = L.head->next; p!=NULL;p = p->next ){if (s->data.expn== p->data.expn){p->data.coef+=s->data.coef;free(s);return;}else if ( p->data.expn>s->data.expn && p->next->data.expndata.expn){s->next=p->next;p->next=s;return;}}}}Status CreatPolyn(List &polynomial,int m){//创建一个一元多项式polynomial，并输入m项的指数和系数ElemType e;Polyn p;for(int i=0;i{scanf("%g,%d",&e.coef,&e.expn);MakeNode(p,e);Insert(polynomial,p);}polynomial.tail=p;return OK;}void PrintPolyn(List L){Polyn p;if(L.head==L.tail)printf("0");else{p=L.head->next;while(p!=NULL){if(p==L.head->next){if(p->data.coef>0){if(p->data.expn!=0){printf("%gx^%d",p->data.coef,p->data.expn);}else{printf("%g",p->data.coef);}}else if(p->data.coef<0){if(p->data.expn!=0){printf("%gx^%d",p->data.coef,p->data.expn);}else{printf("%g",p->data.coef);}}else{printf(" ");}p=p->next;}else if(p!=L.head->next && p!=NULL){if(p->data.coef>0){if(p->data.expn!=0){printf("+%gx^%d",p->data.coef,p->data.expn);}else{printf("+%g",p->data.coef);}}else if(p->data.coef<0){if(p->data.expn!=0){printf("%gx^%d",p->data.coef,p->data.expn);}else{printf("%g",p->data.coef);}}else{printf(" ");}p=p->next;}elsereturn;}}}void AlterPoly(List L){for(Polyn p=L.head->next;p!=NULL;p=p->next)p->data.coef*=-1;}void AddPolyn(List L1,List L2,List &L3){Polyn p1,p2,p3;p1=L1.head->next;p2=L2.head->next;while(p1!=NULL && p2!=NULL){if(p1->data.expn>p2->data.expn){MakeNode(p3,p1->data);Insert(L3,p3);p1=p1->next;}else if(p1->data.expndata.expn){MakeNode(p3,p2->data);Insert(L3,p3);p2=p2->next;}else if(p1->data.expn==p2->data.expn){MakeNode(p3,p2->data);p3->data.coef=p1->data.coef+p2->data.coef;p3->data.expn=p1->data.expn;Insert(L3,p3);p1=p1->next;p2=p2->next;}}if(p1==NULL && p2!=NULL){while(p2!=NULL){MakeNode(p3,p2->data);Insert(L3,p3);p2=p2->next;}}else if(p2==NULL && p1!=NULL){while(p1!=NULL){MakeNode(p3,p1->data);Insert(L3,p3);p1=p1->next;}}}4、main.cpp#include"Polynt.h"#include#includevoid main(){system("cls");printf("********************************************************* ***\n");printf(" 欢迎使用一元稀疏多项式计算\n");printf("********************************************************* ***\n");printf("1、创建多项式A 2、创建多项式B 3、相加 4、相减 5、退出\n");List polynomialA,polynomialB,polynomialC;InitList(polynomialA); InitList(polynomialB); InitList(polynomialC);char poly;int m;int n=1;for(;;){printf("请输入指令:");poly=getchar();switch(poly){case'1': //创建多项式A printf("请输入多项式A的项数：");scanf("%d",&m);printf("\n请输入多项式 A：");CreatPolyn(polynomialA,m);printf("\n多项式A是：");PrintPolyn(polynomialA);printf("\n");break;case'2': //创建多项式B printf("请输入多项式B的项数：");scanf("%d",&m);printf("\n请输入多项式 B：");CreatPolyn(polynomialB,m);printf("\n多项式B是：");PrintPolyn(polynomialB);printf("\n");break;case'3': //加法printf("结果是:");AddPolyn(polynomialA,polynomialB,polynomialC);PrintPolyn(polynomialC);printf("\n");break;case'4': //减法printf("结果是:");AlterPoly(polynomialB);DestroyList(polynomialC);InitList(polynomialC);AddPolyn(polynomialA,polynomialB,polynomialC);PrintPolyn(polynomialC);printf("\n");break;case'5': DestroyList(polynomialA); //退出DestroyList(polynomialB);DestroyList(polynomialC);return;}poly=getchar();if(poly==5)break;}}一元稀疏多项式计算器实验(报告+程序)一元稀疏多项式计数器预习报告 ：刘茂学号0062 一、实验要求 (1)输入并建立多项式； (2)输出多项式，输出形式为整数序列：n，c1，e1，c2，e2……cn，en，其中n是多项式的项数，ci，ei分别为第i项的系数和指数。序列按指数降序排列； (3)多项式a和b相加，建立多项式a+b； (4)多项式a和b相减，建立多项式a-b。 （5）多项式求值； （6）多项式求导； （7）求多项式的乘积。 二、测试数据： 1、(2x+5x^8-3.1x^11)+(7-5x^8+11x^9)=(-3.1x^11+11x^9+2x+7); 2、(6x^-3-x+4.4x^2-1.2x^9+1.2x^9)-(-6x^-3+5.4x^2-x^2+7.8x^15 )=(-7.8x^15-1.2x^9+12x^-3-x); 3、(1+x+x^2+x^3+x^4+x^5)+(-x^3-x^4)=(1+x+x^2+x^5); 4、(x+x^3)+(-x-x^3)=0; 5、(x+x^100)+(x^100+x^200)=(x+2x^100+x^200); 6、(x+x^2+x^3)+0=x+x^2+x^3. 7、互换上述测试数据中的前后两个多项式。三、思路分析 用带表头结点的单链表存储多项式。 本程序要求输入并建立多项式，能够降幂显示出多项式，实现多项式相加相减的计算问题，输出结果。 采用链表的方式存储链表，定义结点结构体。运用尾差法建立两条单链表，以单链表polyn p和polyn h分别表示两个一元多项式a和b。 为实现处理，设p、q分别指向单链表polya和polyb的当前项，比较p、q 结点的指数项。 ①若p->expnexpn，则结点p所指的结点应是“和多项式”中的一项，令指针p后移。 ②若p->expn=q->expn，则将两个结点中的系数相加，当和不为0时修改结点p的系数。 ③若p->expn>q->expn，则结点q所指的结点应是“和多项式”中的一项，将结点q插入在结点p之前，且令指针q在原来的链表上后移。 四、实验程序 //头文件 #include #include #include //定义多项式的项 typedef struct Polynomial{ float coef; int expn; struct Polynomial *next; }*Polyn,Polynomial;数据结构实验报告,一元多项式资料数据结构课程设计报告目录 一、任务目标,,,,,,,,,,,, 3 二、概要设计,,,,,,,,,,,, 4 三、详细设计,,,,,,,,,,,, 6 四、调试分析,,,,,,,,,,,, 8 五、源程序代码,,,,,,,,,, 8 六、程序运行效果图与说明,,,,, 15 七、本次实验小结,,,,,,,,, 16 八、参考文献,,,,,,,,,,, 16任务目标 分析（1） a. 能够按照指数降序排列建立并输出多项式 b.能够完成两个多项式的相加，相减，并将结果输入要求：程序所能达到的功能： a.实现一元多项式的输入； b.实现一元多项式的输出； c.计算两个一元多项式的和并输出结果； d.计算两个一元多项式的差并输出结果；除任务要求外新增乘法： 计算两个一元多项式的乘积并输出结果 （2）输入的形式和输入值的范围：输入要求：分行输入，每行输入一项，先输入多项式的指数，再输入多项式的系数，以0 0 为结束标志，结束一个多项式的输入。 输入形式： 2 3 -1 2 3 0 1 2 0 0 输入值的范围：系数为int 型，指数为float 型 3）输出的形式： 第一行输出多项式1； 第二行输出多项式2； 第三行输出多项式 1 与多项式 2 相加的结果多项式； 第四行输出多项式 1 与多项式 2 相减的结果多项式；第五行输出多项式 1 与多项式 2 相乘的结果多项式 二、概要设计 程序实现 a. 功能：将要进行运算的二项式输入输出；b. 数据流入：要输入的二项式的系数与指数； c.数据流出：合并同类项后的二项式； d.程序流程图：二项式输入流程图； e.测试要点：输入的二项式是否正确，若输入错误则重新输入实验报告——2 一元稀疏多项式计算器华北水利水电学院一元稀疏多项式计算器实验报告 2010～2011学年第一学期 09 级计算机科学与技术专业班级： 2009119 学号： 200911902 姓名：万婷婷 一、实验目的 设计一个医院稀疏多项式简单计算器 熟练掌握线性表的基本操作在两种存储结构上的实现，其中以各种链表的操作和应用 二、实验要求 a)输入并建立多项式 b)输出多项式，输出形式为整数序列：n，c 1，e 1 ，c 2 ，e 2 ……c n ，e n ，其中n是多 项式的项数，c i ，e i 分别为第i项的系数和指数。序列按指数降序排列。 c)多项式a和b相加，建立多项式a+b，输出相加的多项式。 d)多项式a和b相减，建立多项式a-b，输出相减的多项式。 用带表头结点的单链表存储多项式。 测试数据： (1) (2x+5x8-3.1x11)+(7-5x8+11x9) (2) (6x-3-x+4.4x2-1.2x9)-(-6x-3+5.4x2+7.8x15) (3)（1+x+x2 +x3 +x4 +x5）+( -x3- x4) (4)(x+x2+x3)+0 (5)(x+x3)-(-x-x-3) (6) (x+x2 +x3 )+0 三、实验内容 主要算法设计 typedef struct Node { float coef; int index; struct Node *next; }LinkList; 本程序涉及到多项式的建立、多项式的输出、两个多项式的相加减。用带头结点的单链表存储多项式； 程序中共定义了5个函数：void Insert(LinkList *p,LinkList *h)//把节点p插入到链表h中LinkList *Creat_L(LinkList *head,int m)//创建一个链表，项数为m void Printf(LinkList *L) LinkList *ADDlist(LinkList *head,LinkList *pb) LinkList *MinusList(LinkList *head,LinkList *pb) 四、程序源代码 #include #include #include #include typedef struct Node { float coef; int index; struct Node *next; }LinkList; void Insert(LinkList *p,LinkList *h)//把节点p插入到链表h中 { LinkList *q1,*q2; int flag=0; q1=h; if(p->coef==0) free(p); else { if(q1->next==NULL) { q1->next=p; }(整理)一元稀疏多项式计算器云南大学软件学院数据结构实验报告 （本实验项目方案受“教育部人才培养模式创新实验区（X3108005）”项目资助）实验难度： A □ B □ C □ 学期：2012秋季学期 任课教师: 实验题目: 一元稀疏多项式计算器 小组长: 联系电话: 电子邮件: 完成提交时间：2012 年 11 月 10 日 云南大学软件学院2012学年秋季学期《数据结构实验》成绩考核表 学号： 20111120 姓名：本人承担角色：算法设计整体流程控制 综合得分：（满分100分） 指导教师： 年月日云南大学软件学院2010学年秋季学期 《数据结构实验》成绩考核表 学号： 20111120 姓名：本人承担角色：函数实现整体流程控制 综合得分：（满分100分） 指导教师： 年月日（下面的内容由学生填写，格式统一为，字体: 楷体, 行距: 固定行距18，字号: 小四，个人报告按下面每一项的百分比打分。难度A满分70分，难度B满分90分）一、【实验构思（Conceive）】(10%) 多项式计算器的呈现方式是用控制台程序呈现，；多项式的加减乘以及求导的函数中利用链表保存头结点以及循环结构保存和输出数据；还有利用一个简单的降序排列的函数，在输出时更加明了。 二、【实验设计(Design)】(20%) 在头文件中申明变量，源文件中创建指数和系数的指针的头结点，并为此申请空间。首先考虑指数为0,1和系数为0,1时的特殊情况的表示；然后利用SORT函数对输出时进行降序排列；其次就是加减乘以及求导函数的实现；最后是一个输出界面的设计。 三、【实现描述（Implement）】(30%) //--------函数原型说明-------- typedef struct Node { double xishu; int zhishu;//数据域 //int data; struct Node* pnext;//指针域 }Node,*pNode; pNode phead=(pNode)malloc(sizeof(Node));//创建头节点 pNode creat_list(void);创建链表 void traverse_list(pNode phead);//遍历链表 pNode sort(pNode phead);//对链表进行降序排列 pNode add(pNode phead1,pNode phead2)；//两个多项式相加 pNode hebing(pNode phead)//合并同类项 pNode multi(pNode phead1,pNode phead2)；//多项式相乘 pNode sub(pNode phead1,pNode phead2)；//多项式相减 //多项式求导没有声明和定义函数，而是直接卸载程序里了多项式的运算(c语言实现)#include"stdio.h" #include"stdlib.h" #include"conio.h" typedef struct Item{ double coef;//系数 int expn;//指数 struct Item *next; }Item,*Polyn; #define CreateItem(p) p=(Item *)malloc(sizeof(Item)); #define DeleteItem(p) free((void *)p); /************************************************************/ /* 判断选择函数 */ /************************************************************/ int Select(char *str) { char ch; printf("%s\n",str); printf("Input Y or N:"); do{ ch=getch(); }while(ch!='Y'&&ch!='y'&&ch!='N'&&ch!='n'); printf("\n"); if(ch=='Y'||ch=='y') return(1); else return(0); } /************************************************************/ /* 插入位置定位函数 */ /**************************************************************/ int InsertLocate(Polyn h,int expn,Item **p) { Item *pre,*q; pre=h; q=h->next; while(q&&q->expnnext; } if(!q) { *p=pre; return(1); } else if(q->expn==expn) { *p=q; return(0); } else { *p=pre; return(-1); } } /************************************************************/ /* 插入结点函数 */ /************************************************************/ void insert(Item *pre,Item *p) {C++一元多项式合并实验报告实验二一元多项式相加问题本实验的目的是进一步熟练掌握应用链表处理实际问题的能力。 一、问题描述 一元多项式相加是通过键盘输入两个形如P 0+P 1 X1+P 2 X2+···+PnX n的多项式，经过程序运算后在屏幕上输出它 们的相加和。 二、数据结构设计 分析任意一元多项式的描述方法可知，一个一元多项式的每一个子项都由“系数—指数”两部分组成，所以可将它抽象成一个由“系数—指数对”构成线性表，由于对多项式中系数为0的子项可以不记录他的数值，对于这样的情况就不再付出存储空间来存放它了。基于这样的分析，可以采取一个带有头结点的单链表来表示一个一元多项式。具体数据结构定义为： typedef struct node { float ce; //系数域 float ex; //指数域 struct node *next; //指针域 }lnode,*linklist; 三功能（函数）设计 1、输入并建立多项式的功能模块 此模块要求按照指数递增的顺序和一定的输入格式输入各个系数不为0的子项的“系数—指数对”，输入一个子项建立一个相关的节点，当遇到输入结束标志时结束输入，而转去执行程序下面的部分。 屏幕提示： input ce & ex and end with 0： ce=1 ex=2 ce=0 ex=0 //输入结束标志 input ce & ex and end with 0： ce=2 ex=2 ce=0 ex=0 //输入结束标志 输入后程序将分别建立两个链表来描述两个一元多项式： A=X^2 B=2X^2 这两个多项式的相加的结果应该为： C=3X^2 2、多项式相加的功能模块 此模块根据在1中建立的两个多项式进行相加运算，并存放在以C为头指针的一个新建表中。可以采用以下方法进行设计： 开始时a，b分别指向A,B的开头，如果ab不为空，进行判断：如果a所指的结点的指数和b所指的结点的指数相同，将它们的系数相加做成C式中的一项，如果不一样则将小的一项加到C中。 if(a->ex==b->ex) //判断指数是否相等 {s->ce=a->ce+b->ce; if(s->ce!=0) s->ex=a->ex; else delete s; a=a->next; b=b->next; }一元稀疏多项式计算器C语言课程设计2014-2015学年第二学期学号1308210115 《软件工程》 课程设计报告 题目：一元稀疏多项式计算器 专业：计算机科学与技术 班级：计算机科学与技术（2）班 姓名： 指导教师： 成绩：一、问题描述 (3) 二、需求分析 (3) 三、概要设计 (4) 四、详细设计 (5) 五、源代码 (6) 六、程序测试 (18) 七、使用说明 (24) 八、课设总结 (25)一、问题描述 1.1基本要求 （1）输入并建立多项式； （2）输出多项式，输出形式为整数序列：n,c1,e1, c2,e2,,,,,,, cn,en,其中n是多项式的项数，ci,ei,分别是第i项的系数和指数，序列按指数降序排序； （3）多项式a和b相加，建立多项式a+b； （4）多项式a和b相减，建立多项式a-b； （5）计算多项式在x处的值。 （6）计算器的仿真界面。 1.2设计目的 数据结构是实践性很强的课程。课程设计是加强学生实践能力的一个强有力手段。课程设计要求学生在完成程序设计的同时能够写出比较规范的设计报告。严格实施课程设计这一环节，对于学生基本程序设计素养的培养和软件工作者工作作风的训练，将起到显著的促进作用 二、需求分析 2.1 设计开发环境： 软件方面：系统windows 7 编程软件：VC++ 6.0 2.2思路分析： ①一般情况下的一元n次多项式可写成 pn(x)=p1xe1+p2xe2+……+pmxem 其中，p1是指数为ei的项的非零系数，且满足0≦e1一元稀疏多项式计算器(数据结构)【问题描述】 设计一个一元稀疏多项式简单计算器 【基本要求】 一元多项式简单计算器的基本功能是： 1，输入并建立多项式; 2，输出多项式，输出形式为整数序列:n,c1,e1,c2,c2,...,cn,en,其中n是多项式的项数，ci和ei分别是第i项的系数和指数，序列按指数降序排列; 3,多项式a和b相加，建立多项式a+b; 4,多项式a和b相减，建立多项式a-b. 【测试数据】 1，(2x+5x^8-3.1x^11)+(7-5x^8+11x^9)=(-3.1x^11+11x^9+2x+7) 【实现提示】 用带表头结点的单链表存储多项式。 #include #include typedef struct node { float coef; int expn; struct node *next; }Lnode, *polynmial; void create(polynmial &L); //输入并建立多项式L void display(polynmial L); //显示，输出多项式L void 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，结果给Ld void 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; } }一元多项式相加完整实验报告一元多项式相加实验报告 一元多项式的相加一实验内容 根据所学的数据结构中线性结构（线性表）的逻辑特性和物理特性及相关算法，应用于求解一个具体的实际问题----------两个多项式相加 二需求分析 1掌握线性结构的逻辑特性和物理特性。 2建立一元多项式。 3将一元多项式输入，并存储在内存中，并按照指数降序排列输出多项式。 4能够完成两个多项式的加减运算，并输出结果。 三概要设计 1 本程序所用到的抽象数据类型： typedef OrderedLinkList polynomial; // 用带表头结点的有序链表表示多项式 结点的数据元素类型定义为: typedef struct { // 项的表示 float coef; // 系数 int expn; // 指数 term, ElemType; V oid AddPolyn(polynomail&Pa,polynomail&Pb) Position GetHead() Position NextPos(LinkList L,Link p) Elem GetCurElem(Link p) int cmp(term a term b) Status SetCurElem(Link&p, ElemType e) Status DelFirst(Link h, Link &q) Status ListEmpty(LinkList L) Status Append(LinkList&L, Link S) FreeNode() 2 存储结构一元多项式的表示在计算机内用链表来实现，同时为了节省存储空间，只存储其中非零的项，链表中的每个节点存放多项式的系数非零项。它包含三个域，分别存放多项式的系数，指数，以及指向下一个项的指针。 创建一元多项式链表，对运算中可能出现的各种情况进行分析，实现一元多项式的相加相减操作。 3 模块划分 a) 主程序；2）初始化单链表；3）建立单链表； 4）相加多项式 4 主程序流程图 四详细设计 根据一元多项式相加的运算规则：对于两个一元多项式中所有指数相同的项，对应系数相加，若其和不为零，则构成“和多项式”中的一项，对一元稀疏多项式计算器实验一元稀疏多项式计数器预习报告 姓名：刘茂学号2220 一、实验要求 (1)输入并建立多项式； (2)输出多项式，输出形式为整数序列：n，c1，e1，c2，e2……cn，en，其中n是多项式的项数，ci，ei分别为第i项的系数和指数。序列按指数降序排列； (3)多项式a和b相加，建立多项式a+b； (4)多项式a和b相减，建立多项式a-b。 （5）多项式求值； （6）多项式求导； （7）求多项式的乘积。 二、测试数据： 1、(2x+5x^^11)+(7-5x^8+11x^9)=^11+11x^9+2x+7); 2、(6x^-3-x+^^9+^9)-(-6x^-3+^2-x^2+^15 )=^^9+12x^-3-x); 3、(1+x+x^2+x^3+x^4+x^5)+(-x^3-x^4)=(1+x+x^2+x^5); 4、(x+x^3)+(-x-x^3)=0; 5、(x+x^100)+(x^100+x^200)=(x+2x^100+x^200); 6、(x+x^2+x^3)+0=x+x^2+x^3. 7、互换上述测试数据中的前后两个多项式。 三、思路分析 用带表头结点的单链表存储多项式。 本程序要求输入并建立多项式，能够降幂显示出多项式，实现多项式相加相减的计算问题，输出结果。采用链表的方式存储链表，定义结点结构体。运用尾差法建立两条单链表，以单链表polyn p和polyn h分别表示两个一元多项式a和b。 为实现处理，设p、q分别指向单链表polya和polyb的当前项，比较p、q 结点的指数项。 ① 若p->expnexpn，则结点p所指的结点应是“和多项式”中的一项，令指针p后移。 ② 若p->expn=q->expn，则将两个结点中的系数相加，当和不为0时修改结点p的系数。 ③ 若p->expn>q->expn，则结点q所指的结点应是“和多项式”中的一项，将结点q插入在结点p之前，且令指针q在原来的链表上后移。 四、实验程序 //头文件 #include<> #include<> #include<> //定义多项式的项 typedef struct Polynomial{ float coef; int expn; struct Polynomial *next; }*Polyn,Polynomial; void Insert(Polyn p,Polyn h){ if(p->coef==0) free(p);//系数为0的话释放结点 else一元稀疏多项式计算器(数据结构)院系：计算机科学学院 专业：软件工程 年级： 2013级 课程名称：数据结构 姓名：韦宜（201321092034）指导教师：宋中山 2015年 12 月 15日题目：设计一个一元稀疏多项式简单计算器 班级：软件工程1301 姓名：韦宜学号：201321092034 完成日期：12月15日 一、需求分析 问题描述：设计一个一元多项式加法器 基本要求： 输入并建立多项式； (2)两个多项式相加； (3)输出多项式：n, c1, e1, c2, e2, …cn , en, 其中，n是多项式项数，ci和ei分别是第i 项的系数和指数，序列按指数降序排列。 (4)计算多项式在x处的值； (5)求多项式的导函数。 软件环境：Windows，UNIX，Linux等不同平台下的Visual C++ 6.0 硬件环境: 512MB内存,80Gb硬盘,Pentium4 CPU,CRT显示器。二、概要分析 本程序有五个函数： PolyNode *Input()(输入函数)； PolyNode *Deri(PolyNode *head)（求导函数）； PolyNode * Plus(PolyNode *A,PolyNode *B)（求和函数）； void Output(PolyNode*head)（输出函数）； int main()（主函数） 本程序可使用带有附加头结点的单链表来实现多项式的链表表示，每个链表结点表示多项式的一项，命名为node，它包括两个数据成员：系数coef和指数exp，他们都是公共数据成员，*next为指针域，用链表来表示多项式。适用于不定的多项式，特别是对于项数再运算过程中动态增长的多项式，不存在存储溢出的问题。其次，对于某些零系数项，在执行加法运算后不再是零系数项，这就需要在结果多项式中增添新的项；对于某些非零系数项，在执行加法运算后可能是零系数项，这就需要在结果多项式中删去这些项，利用链表操作，可以简单的修改结点的指针以完成这种插入和删除运算（不像在顺序方式中那样，可能移动大量数据项）运行效率高。一元多项式的运算数据结构课程设计实验报告 专业班级： 学号： 姓名： 2011年1月1日题目：一元多项式的运算 1、题目描述 一元多项式的运算在此题中实现加、减法的运算，而多项式的减法可以通过加法来实现（只需在减法运算时系数前加负号）。 在数学上，一个一元n次多项式P n(X)可按降序写成： P n(X)= P n X^n+ P(n-1)X^(n-1)+......+ P1X+P0 它由n+1个系数惟一确定，因此，在计算机里它可以用一个线性表P来表示： P=(P n，P(n-1)，......，P1，P0) 每一项的指数i隐含在其系数P i的序号里。 假设Q m(X)是一元m次多项式，同样可以用一个线性表Q来表示： Q=(q m,q(m-1)，.....，q1，q0) 不是一般性，假设吗吗m一元稀疏多项式的加法运算(数据结构实习)实习一线性表、栈和队列及其应用 ——一元稀疏多项式的加法运算 【问题描述】 设计一个实现一元稀疏多项式相加运算的演示程序。 【基本要求】 （1）输入并建立两个多项式； （2）多项式a与b相加，建立和多项式c； （3）输出多项式a,b,c。输出格式：比如多项式a为：A(x)=c1xe1+ c2xe2+…+ cmxem，其中，ci和ei分别为第i项的系数和指数，且各项按 指数的升幂排列，即0≤e1＜e2＜…＜em。多项式b,c类似输出。 【测试数据】 （1）(1+x+x2+x3+x4+x5)+(-x3-x4)=(1+x+x2+x5) （2）(x+x100)+(x100+x200)=(x+2x100+x200) （3）(2x+5x8-3x11)+(7-5x8+11x9)=(7+2x+11x9-3x11) 一．需求分析 1.输入的形式和输入值的范围： 输入是从键盘输入的，输入的内容为多项式的系数和指数，其中多项式的每一项分别以一个系数和指数的形式输入，不带未知数X，系数为任意的实数，指数为任意的整数。 要结束该多项式的输入时，输入的指数和系数都为0. 2. 输出的形式 从屏幕输出，显示用户输入的多项式，并显示多项式加减以后的多项式的值，并且多项式中将未知数X表示了出来. 形式为：+c1X^e1+c2X^e2+…+ciX^ei+…(ci和ei分别是第i 项的系数和指数，序列按指数升序排列。) 当多项式的某一项的系数为+1或者-1时侧该项多项式的输出形式为X^ei或-X^ei； 当该项的系数为正时输出+ciX^ei,当为负数时则输出ciX^ei 3. 程序所能达到的功能 输入并建立多项式，实现一元稀疏多项式的相加并输出。 4. 注意：所有多项式都必须以指数升密形式输入。 5. 测试数据为（1）(1+x+x2+x3+x4+x5)+(-x3-x4)=(1+x+x2+x5) （2）(x+x100)+(x100+x200)=(x+2x100+x200) （3）(2x+5x8-3x11)+(7-5x8+11x9)=(7+2x+11x9-3x11) 二．设计 1.设计思路两个一元多项式相加-c++版《数据结构》实验报告 ——两个一元多项式相加 一、实验题目：两个一元多项式相加 二、实验内容： 根据所学的数据结构中线性结构（线性表）的逻辑特性和物理特性及相关算法，应用于求解一个具体的实际问题----------两个多项式相加 三、设计思想： （1）建立两个顺序列表，分别用来表示两个一元多项式；顺序列表奇数位，存储该多项式的系数；顺序列表的偶数位，存储该相应多项式的指数。 （2）用成员函数merg(qList&l2)实现两多项式的相加。实现的大致方法为：比较第二个多项式列表与第一个多项式列表的偶数位的数值大小（指数），如果 相同，则将他们的前一位数（系数）相加；如果不同，就将他的前一位数（系 数）及它自己（指数）插入第一个多项式列表的后面。 （3）建立函数shu(double a[],int j)实现多项式的输入。 四、源程序代码 #include "stdafx.h" #include using namespace std; template class List { private: Telem * elem; int curlen; int maxlen; public: List(int maxsz=100):maxlen(maxsz) { curlen=0; elem=new Telem{maxlen}; }; List(Telem a[],int n,int maxsz=100):maxlen(maxsz) { curlen=n; elem=new Telem[maxlen]; for(int i=0;i数据结构实验,多项式计算器实验题目：多项式运算器 实验内容：1、熟悉编程环境 2、用链式存储结构实现稀疏一元多项式运算器 实验目的和要求： 1、通过本实验，掌握VC++6.0的基本使用，包括源程序的输入，编译运行及调 试。调试的目的是找程序的运行错误，通过DEBUG菜单设置断点实现。 2、用链式存储结构实现一元多项式的运算。 熟练掌握指针和链表的基本操作，利用菜单进行功能选择。 功能基本要求：创建、显示、求和、求差、求值、销毁、清空、修改 实验算法： 1、数据结构描述： 输入的稀疏每一个多项式用一个链表存储，链表的每一个节点存储多项式的一个非零项。定义为LNode型结构体，其中保存该项的系数和指数。主 函数中用一个数组存储每一个多项式的第一项的头指针以调用多项式。 2、函数和算法描述： 主函数main定义LNode*数组a[]存储每一个多项式头节点的地址，并构建菜单以选择调用函数进行多项式的操作，对多项式进行操作的函数返回新 改动的多项式头结点地址。 Createpolyn函数用以创建一个多项式，在用户输入结束指令之前，不断的申请空间，构建LNode型结点并加至构建的链表的表尾，输入结束指令之 后，表尾设NULL并返回表头指针。 Printpolyn函数用以在屏幕上打印多项式，接收需要打印的多项式链表的头结点，构造循环体在表尾之前，不断以mx^n格式打印对应结点中的数 据。 Copypolyn函数用以复制多项式，接收需要复制的多项式a和复制位置b 的指针，构造循环体，在a到表尾之前循环，在b对应的链表中构建新的结 点，结点上的数据赋值为a中对应的值，返回b的头结点地址。 Addpolyn函数用以求两个已知多项式a、b的和存入c，先构建循环体，在a、b链表都未进行到表尾时，比较两个结点中的次数值，如果相同，将 系数相加赋于c的当前结点，如果不同，将次数较小多项式y（a或b）的结 点赋值给c当前结点，在将y链表向后推。 Subtract函数用以求两多项式的差，类似求和算法。 Value函数用以求一个多项式的值，接收x的值，构建循环体，在表尾之前循环以遍历多项式链表。内置循环体，以次数n为限循环，求出x^n的 值，乘以系数并将每一项的值叠加得值。 Destroypolyn函数用以销毁已有的多项式，将此多项式链表的空间FREE 掉，返回空指针。 Clearpolyn函数用以清空多项式，构建循环体，将多项式的各项的系数、指数置零。 3、时空分析： L= sizeof(struct LNode) 一个含有N项的多项式占用的储存空间为NL+1[计算机]一元多项式相加完整实验报告[计算机]一元多项式相加完整实验报告一元多项式的相加 一实验内容 根据所学的数据结构中线性结构(线性表)的逻辑特性和物理特性及相关算法，应用于求解一个具体的实际问题----------两个多项式相加 二需求分析 1掌握线性结构的逻辑特性和物理特性。 2建立一元多项式。 3将一元多项式输入，并存储在内存中，并按照指数降序排列输出多项式。 4能够完成两个多项式的加减运算，并输出结果。 三概要设计 1 本程序所用到的抽象数据类型: typedef OrderedLinkList polynomial; // 用带表头结点的有序链表表示多项式 结点的数据元素类型定义为: typedef struct { // 项的表示 oat flcoef; // 系数 int expn; // 指数 term, ElemType; Void AddPolyn(polynomail&Pa,polynomail&Pb) Position GetHead() Position NextPos(LinkList L,Link p) Elem GetCurElem(Link p) int cmp(term a term b)Status SetCurElem(Link&p, ElemType e) Status DelFirst(Link h, Link &q) Status ListEmpty(LinkList L) Status Append(LinkList&L, Link S) FreeNode() 2 存储结构 一元多项式的表示在计算机内用链表来实现，同时为了节省存储空间，只存储其中非零的项，链表中的每个节点存放多项式的系数非零项。它包含三个域，分别存放多项式的系数，指数，以及指向下一个项的指针。 序数coef 指数exp 指针域next 创建一元多项式链表，对运算中可能出现的各种情况进行分析，实现一元多项式的相加相减操作。 3 模块划分 a) 主程序;2)初始化单链表;3)建立单链表; 4)相加多项式 4 主程序流程图 开始 申请结点空间 输入多项式各项的系数X，指数Y 输出已输出的多项式 否 是否输入正确 合并同类项 结束 四详细设计 根据一元多项式相加的运算规则:对于两个一元多项式中所有指数相用C语言实现多项式简单计算器的设计武汉理工大学华夏学院课程设计报告书 课程名称：数据结构 题目：用C语言实现多项式简单计算器的设计 系名：信息工程系 专业班级：软件工程1121班 姓名：邓燕蓉 指导教师:王绪梅 2013 年 6月 28日课程设计任务书 学生姓名：邓燕蓉专业班级：软件工程1121班 指导教师：王绪梅工作单位：华夏学院计算机教研室设计题目：用C语言实现多项式简单计算器的设计 设计目的 1.巩固和加深课堂所学知识、学会分析研究数据对象的特性及数据的组织方法； 2.选择合适的数据的逻辑结构和存储结构以及相应操作，实现简单的多项式计算； 3.提高程序设计能力、加强查阅、运用资料的能力、算法分析与程序设计素质培养； 设计任务（在规定的时间内完成下列任务） 〔问题描述〕输入并建立两个多项式并输出多项式 设计一个程序：对两个多项式进行加、减法及乘法运算,建立一个新多项式并输出. 或设计一个程序对其中一个多项式求导。 〔实现提示〕 选择带头结点的单链表或循环链表存储多项式,头结点中存放多项式的参数及单链表的数据具体要完成的任务是： A.编制完成上述问题的C语言程序、进行程序调试并能得出正确的运行结果。 B.写出规范的课程设计报告书； 时间安排：6月24日---28日 具体要求 1. 课程设计报告按统一通用格式书写，具体内容如下： ①设计任务与要求 ②总体方案与说明 ③软件主要模块的流程图 ④源程序清单与注释 ⑤问题分析与解决方案（包括调式记录、调式报告，即在调式过程中遇到的主要问题、解决方法 及改进设想）； ⑥小结与体会 附录：①源程序（必须有简单注释）②使用说明③参考资料 2.每位学生应独立完成各自的任务且每天至少在设计室工作半天； 指导教师签名：王绪梅2013 年6月22日 教研室主任（或责任教师）签名：2013年6月24日数据结构实验报告-一元多项式数据结构课程设计报告 课题: 一元多项式 姓名： XX 学号： 201417030218 专业班级： XXXX 指导教师： XXXX 设计时间： 2015年12月30日星期三目录 一、任务目标 (3) 二、概要设计 (4) 三、详细设计 (6) 四、调试分析 (8) 五、源程序代码 (8) 六、程序运行效果图与说明 (15) 七、本次实验小结 (16) 八、参考文献 (16)一丶任务目标 分析 (1) a.能够按照指数降序排列建立并输出多项式 b.能够完成两个多项式的相加，相减，并将结果输入 要求：程序所能达到的功能： a.实现一元多项式的输入； b.实现一元多项式的输出； c.计算两个一元多项式的和并输出结果； d.计算两个一元多项式的差并输出结果； 除任务要求外新增乘法： 计算两个一元多项式的乘积并输出结果 （2）输入的形式和输入值的范围： 输入要求：分行输入，每行输入一项，先输入多项式的指数，再输入多项式的系数，以0 0为结束标志，结束一个多项式的输入。 输入形式： 2 3 -1 2 3 0 1 2 0 0 输入值的范围：系数为int型，指数为float型 （3）输出的形式： 第一行输出多项式1； 第二行输出多项式2； 第三行输出多项式1与多项式2相加的结果多项式； 第四行输出多项式1与多项式2相减的结果多项式； 第五行输出多项式1与多项式2相乘的结果多项式二、概要设计 程序实现 a. 功能：将要进行运算的二项式输入输出； b. 数据流入：要输入的二项式的系数与指数； c. 数据流出：合并同类项后的二项式； d. 程序流程图：二项式输入流程图； e. 测试要点：输入的二项式是否正确，若输入错误则重新输入。一元多项式计算器设计与实现一元稀疏多项式简单计算器 一、设计课题 设计一元稀疏多项式简单计算器。 二、需求分析 2.1 输入的形式和输入值的范围： 输入是从键盘输入的，输入的内容为多项式的系数和指数，数为任意的整数，指数为大于等于0的整数 2.2 输出的形式 从屏幕输出，显示用户输入的多项式，并显示多项式加减以后的多项式的值。 2.3 程序所能达到的功能 a：输入并建立多项式； b：输出多项式，输出形式为整数序列：n,c1,e1,c2,e2,……,cn,en,其中n是多项式的项数，ci和ei 分别是第i项的系数和指数，序列按指数降序排列； c：多项式a和b相加，建立多项式a+b； d：多项式a和b相减，建立多项式a-b； 2.4 测试数据 （1）(2x+5x^8-3.1x^11)+(7-5x^8+11x^9) = (-3.1x^11+11X^9+2X+7) （2）(X+X^3)+(-X-X^3)=0 （3）(X+X^2+X^3)+0= X+X^2+X^3 三、概要设计 3.1 设计思路 A：数据结构的选用 为了实现任意多项式的加法、减法，因此选择单链表的结构体，它有一个系数，指数，下一个指针3个元属；单链表抽象结构类型定义见附录2。 B：多项式的输入 采用头节点插法的方式，输入多项式中一个项的系数和指数，就产生一个新的节点，建立起它的右指针，并用头节点指向它；为了判断一个多项式是否输入结束，定义一个结束标志，当输入非00时就继续，当输入00时，就结束一个多项式的输入； C：2个多项式的加法 它从2个多项式的头部开始，2个多项式的某一项都不为空时，如果指数相等的话，系数就应该相加；相加的和不为0的话，用头插法建立一个新的节点。p的系数小于q的系数的话，就应该复制q接点到多项式中。p的系数大于q的系数的话，就应该复制p接点到多项式中。当第2个多项式空，第1个数不为空时，将第一个数剩下的全用新节点产生。当第1个多项式空，第1个数不为空时，将第2个数剩下的全用新节点产生 D：2个多项式的减法 它从2个多项式的头部开始，2个多项式的某一项都不为空时，如果指数相等的话，系数就应该相减；相加的和不为0的话，用头插法建立一个新的节点。 p的系数小于q的系数的话，就应该复制q接点到多项式中。p的系数大于q的系数的话，就应该复制p接点到多项式中，并且建立的接点的系数为原来的相反数；当第2个多项式空，第1个数不为空时，将第一个数剩下的全用新节点产生。当第1个多项式空，第1个数不为空时，将第2个数剩下的全用新节点产生，并且建立的接点的系数为原来的相反数。
基本操作：
InitList()
操作结果：构造一个空的有序表L。
DestroyList(L)
初始条件：有序表L已存在。
操作结果：销毁有序表L。
ListLength(L)
操作结果：返回有序表L的长度。
ClearList( L )
操作结果：清空链表内容。
Ins_before ( N,N )
操作结果：插入节点到链表。
} ADT OrderedList
2.多项式的抽象数据类型定义为：
ADT Poly {
数据对象：D={a i |a i为实数，i=1，2，…，n}
数据关系：R1={}
CreatePoly( L,N )
初始条件：N为节点，L为有序表。
操作结果：将N 插入多项式的适当位置。
GetPoly( L )
操作结果：将用户输入转换为节点。
PrintPoly( L )
初始条件：多项式L已存在。
操作结果：显示多项式。
AddPoly( L_1,L_2,L_add )
初始条件：多项式L_1,L_2,L_add已存在。
操作结果：生成L_1,L_2之和的多项式L_add
DiffPoly( L ,L_diff)
初始条件：多项式L ,L_diff已存在。
操作结果：生成L的导数多项式L_add。
AlterPoly( L )
操作结果：将L多项式取相反数。
}ADT Poly、
三、详细设计
1、Constant.h
#ifndef __constant__
#define __constant__
#include
#define TURE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2
typedef int Status;
#endif
2、Polynt.h
#include"constant.h"
typedef struct elemType{
float coef;//系数
int expn;//指数
}ElemType;
typedef struct node{
ElemType data; //指向结点元素的值
struct node *next; //后继
}Node,*Polyn; //结点类型，指针类型
typedef struct{
Node *head;
Node *tail;
}List;
Status MakeNode(Polyn &p,ElemType e); //分配由p指向的数据元素为e、后继为“空”的结点
Status InitList(List &L); //构造链表
Status DestroyList(List &L); //销毁线性表
void Insert(List &L,Polyn s); //将s指向的结点插入L的最后一个结点
void Insbefore(Polyn p,Polyn q);
Status CreatPolyn(List &polynomial,int m); //创建一个一元多项式polynomial，并输入m项的指数和系数
void PrintPolyn(List L); //打印输出一元多项式
void AlterPoly(List L); //减法
void AddPolyn(List L1,List L2,List &L3); //多项式加法
3、Polyn.cpp
#include"Polynt.h"
Status MakeNode(Polyn &p,ElemType e)
{//分配由p指向的数据元素为e、后继为“空”的结点
p=(Polyn)malloc(sizeof(Node));
p->data.coef=e.coef;
p->data.expn=e.expn;
p->next=NULL;
return OK;
}
Status InitList(List &L)
{//初始化链表
ElemType e;
Polyn p;
e.coef = ' ';
e.expn = ' ';
MakeNode(p,e);
L.head = p;
L.tail=p;
Status DestroyList(List &L)
{//销毁链表
Polyn p,q;
if(L.head==L.tail) {free(L.head);L.head=L.tail=NULL;return OK;} p=L.head->next;
while(!p){
q=p->next;
free(p);
p=q;}
L.head=L.tail=NULL;
void Insert(List &L,Polyn s)
{
if(L.head->next ==NULL)
L.head->next =s;
s->next =NULL;
L.tail = s;
else{
if(L.head->next!=NULL && s->data.expn>L.head->next->data.expn)
{s->next=L.head->next;L.head->next=s; return;}
if(L.tail->data.expn>s->data.expn)
{L.tail->next=s; L.tail=s;return;}
for (Polyn p = L.head->next; p!=NULL;p = p->next )
if (s->data.expn== p->data.expn)
p->data.coef+=s->data.coef;
free(s);
return;
else if ( p->data.expn>s->data.expn && p->next->data.expndata.expn)
s->next=p->next;p->next=s;
Status CreatPolyn(List &polynomial,int m)
{//创建一个一元多项式polynomial，并输入m项的指数和系数
for(int i=0;i{scanf("%g,%d",&e.coef,&e.expn);MakeNode(p,e);Insert(polynomial,p);}polynomial.tail=p;return OK;}void PrintPolyn(List L){Polyn p;if(L.head==L.tail)printf("0");else{p=L.head->next;while(p!=NULL){if(p==L.head->next){if(p->data.coef>0){if(p->data.expn!=0){printf("%gx^%d",p->data.coef,p->data.expn);}else{printf("%g",p->data.coef);}}else if(p->data.coef<0){if(p->data.expn!=0){printf("%gx^%d",p->data.coef,p->data.expn);}else{printf("%g",p->data.coef);}}else{printf(" ");}p=p->next;}else if(p!=L.head->next && p!=NULL){if(p->data.coef>0){if(p->data.expn!=0){printf("+%gx^%d",p->data.coef,p->data.expn);}else{printf("+%g",p->data.coef);}}else if(p->data.coef<0){if(p->data.expn!=0){printf("%gx^%d",p->data.coef,p->data.expn);}else{printf("%g",p->data.coef);}}else{printf(" ");}p=p->next;}elsereturn;}}}void AlterPoly(List L){for(Polyn p=L.head->next;p!=NULL;p=p->next)p->data.coef*=-1;}void AddPolyn(List L1,List L2,List &L3){Polyn p1,p2,p3;p1=L1.head->next;p2=L2.head->next;while(p1!=NULL && p2!=NULL){if(p1->data.expn>p2->data.expn){MakeNode(p3,p1->data);Insert(L3,p3);p1=p1->next;}else if(p1->data.expndata.expn){MakeNode(p3,p2->data);Insert(L3,p3);p2=p2->next;}else if(p1->data.expn==p2->data.expn){MakeNode(p3,p2->data);p3->data.coef=p1->data.coef+p2->data.coef;p3->data.expn=p1->data.expn;Insert(L3,p3);p1=p1->next;p2=p2->next;}}if(p1==NULL && p2!=NULL){while(p2!=NULL){MakeNode(p3,p2->data);Insert(L3,p3);p2=p2->next;}}else if(p2==NULL && p1!=NULL){while(p1!=NULL){MakeNode(p3,p1->data);Insert(L3,p3);p1=p1->next;}}}4、main.cpp#include"Polynt.h"#include#includevoid main(){system("cls");printf("********************************************************* ***\n");printf(" 欢迎使用一元稀疏多项式计算\n");printf("********************************************************* ***\n");printf("1、创建多项式A 2、创建多项式B 3、相加 4、相减 5、退出\n");List polynomialA,polynomialB,polynomialC;InitList(polynomialA); InitList(polynomialB); InitList(polynomialC);char poly;int m;int n=1;for(;;){printf("请输入指令:");poly=getchar();switch(poly){case'1': //创建多项式A printf("请输入多项式A的项数：");scanf("%d",&m);printf("\n请输入多项式 A：");CreatPolyn(polynomialA,m);printf("\n多项式A是：");PrintPolyn(polynomialA);printf("\n");break;case'2': //创建多项式B printf("请输入多项式B的项数：");scanf("%d",&m);printf("\n请输入多项式 B：");CreatPolyn(polynomialB,m);printf("\n多项式B是：");PrintPolyn(polynomialB);printf("\n");break;case'3': //加法printf("结果是:");AddPolyn(polynomialA,polynomialB,polynomialC);PrintPolyn(polynomialC);printf("\n");break;case'4': //减法printf("结果是:");AlterPoly(polynomialB);DestroyList(polynomialC);InitList(polynomialC);AddPolyn(polynomialA,polynomialB,polynomialC);PrintPolyn(polynomialC);printf("\n");break;case'5': DestroyList(polynomialA); //退出DestroyList(polynomialB);DestroyList(polynomialC);return;}poly=getchar();if(poly==5)break;}}一元稀疏多项式计算器实验(报告+程序)一元稀疏多项式计数器预习报告 ：刘茂学号0062 一、实验要求 (1)输入并建立多项式； (2)输出多项式，输出形式为整数序列：n，c1，e1，c2，e2……cn，en，其中n是多项式的项数，ci，ei分别为第i项的系数和指数。序列按指数降序排列； (3)多项式a和b相加，建立多项式a+b； (4)多项式a和b相减，建立多项式a-b。 （5）多项式求值； （6）多项式求导； （7）求多项式的乘积。 二、测试数据： 1、(2x+5x^8-3.1x^11)+(7-5x^8+11x^9)=(-3.1x^11+11x^9+2x+7); 2、(6x^-3-x+4.4x^2-1.2x^9+1.2x^9)-(-6x^-3+5.4x^2-x^2+7.8x^15 )=(-7.8x^15-1.2x^9+12x^-3-x); 3、(1+x+x^2+x^3+x^4+x^5)+(-x^3-x^4)=(1+x+x^2+x^5); 4、(x+x^3)+(-x-x^3)=0; 5、(x+x^100)+(x^100+x^200)=(x+2x^100+x^200); 6、(x+x^2+x^3)+0=x+x^2+x^3. 7、互换上述测试数据中的前后两个多项式。三、思路分析 用带表头结点的单链表存储多项式。 本程序要求输入并建立多项式，能够降幂显示出多项式，实现多项式相加相减的计算问题，输出结果。 采用链表的方式存储链表，定义结点结构体。运用尾差法建立两条单链表，以单链表polyn p和polyn h分别表示两个一元多项式a和b。 为实现处理，设p、q分别指向单链表polya和polyb的当前项，比较p、q 结点的指数项。 ①若p->expnexpn，则结点p所指的结点应是“和多项式”中的一项，令指针p后移。 ②若p->expn=q->expn，则将两个结点中的系数相加，当和不为0时修改结点p的系数。 ③若p->expn>q->expn，则结点q所指的结点应是“和多项式”中的一项，将结点q插入在结点p之前，且令指针q在原来的链表上后移。 四、实验程序 //头文件 #include #include #include //定义多项式的项 typedef struct Polynomial{ float coef; int expn; struct Polynomial *next; }*Polyn,Polynomial;数据结构实验报告,一元多项式资料数据结构课程设计报告目录 一、任务目标,,,,,,,,,,,, 3 二、概要设计,,,,,,,,,,,, 4 三、详细设计,,,,,,,,,,,, 6 四、调试分析,,,,,,,,,,,, 8 五、源程序代码,,,,,,,,,, 8 六、程序运行效果图与说明,,,,, 15 七、本次实验小结,,,,,,,,, 16 八、参考文献,,,,,,,,,,, 16任务目标 分析（1） a. 能够按照指数降序排列建立并输出多项式 b.能够完成两个多项式的相加，相减，并将结果输入要求：程序所能达到的功能： a.实现一元多项式的输入； b.实现一元多项式的输出； c.计算两个一元多项式的和并输出结果； d.计算两个一元多项式的差并输出结果；除任务要求外新增乘法： 计算两个一元多项式的乘积并输出结果 （2）输入的形式和输入值的范围：输入要求：分行输入，每行输入一项，先输入多项式的指数，再输入多项式的系数，以0 0 为结束标志，结束一个多项式的输入。 输入形式： 2 3 -1 2 3 0 1 2 0 0 输入值的范围：系数为int 型，指数为float 型 3）输出的形式： 第一行输出多项式1； 第二行输出多项式2； 第三行输出多项式 1 与多项式 2 相加的结果多项式； 第四行输出多项式 1 与多项式 2 相减的结果多项式；第五行输出多项式 1 与多项式 2 相乘的结果多项式 二、概要设计 程序实现 a. 功能：将要进行运算的二项式输入输出；b. 数据流入：要输入的二项式的系数与指数； c.数据流出：合并同类项后的二项式； d.程序流程图：二项式输入流程图； e.测试要点：输入的二项式是否正确，若输入错误则重新输入实验报告——2 一元稀疏多项式计算器华北水利水电学院一元稀疏多项式计算器实验报告 2010～2011学年第一学期 09 级计算机科学与技术专业班级： 2009119 学号： 200911902 姓名：万婷婷 一、实验目的 设计一个医院稀疏多项式简单计算器 熟练掌握线性表的基本操作在两种存储结构上的实现，其中以各种链表的操作和应用 二、实验要求 a)输入并建立多项式 b)输出多项式，输出形式为整数序列：n，c 1，e 1 ，c 2 ，e 2 ……c n ，e n ，其中n是多 项式的项数，c i ，e i 分别为第i项的系数和指数。序列按指数降序排列。 c)多项式a和b相加，建立多项式a+b，输出相加的多项式。 d)多项式a和b相减，建立多项式a-b，输出相减的多项式。 用带表头结点的单链表存储多项式。 测试数据： (1) (2x+5x8-3.1x11)+(7-5x8+11x9) (2) (6x-3-x+4.4x2-1.2x9)-(-6x-3+5.4x2+7.8x15) (3)（1+x+x2 +x3 +x4 +x5）+( -x3- x4) (4)(x+x2+x3)+0 (5)(x+x3)-(-x-x-3) (6) (x+x2 +x3 )+0 三、实验内容 主要算法设计 typedef struct Node { float coef; int index; struct Node *next; }LinkList; 本程序涉及到多项式的建立、多项式的输出、两个多项式的相加减。用带头结点的单链表存储多项式； 程序中共定义了5个函数：void Insert(LinkList *p,LinkList *h)//把节点p插入到链表h中LinkList *Creat_L(LinkList *head,int m)//创建一个链表，项数为m void Printf(LinkList *L) LinkList *ADDlist(LinkList *head,LinkList *pb) LinkList *MinusList(LinkList *head,LinkList *pb) 四、程序源代码 #include #include #include #include typedef struct Node { float coef; int index; struct Node *next; }LinkList; void Insert(LinkList *p,LinkList *h)//把节点p插入到链表h中 { LinkList *q1,*q2; int flag=0; q1=h; if(p->coef==0) free(p); else { if(q1->next==NULL) { q1->next=p; }(整理)一元稀疏多项式计算器云南大学软件学院数据结构实验报告 （本实验项目方案受“教育部人才培养模式创新实验区（X3108005）”项目资助）实验难度： A □ B □ C □ 学期：2012秋季学期 任课教师: 实验题目: 一元稀疏多项式计算器 小组长: 联系电话: 电子邮件: 完成提交时间：2012 年 11 月 10 日 云南大学软件学院2012学年秋季学期《数据结构实验》成绩考核表 学号： 20111120 姓名：本人承担角色：算法设计整体流程控制 综合得分：（满分100分） 指导教师： 年月日云南大学软件学院2010学年秋季学期 《数据结构实验》成绩考核表 学号： 20111120 姓名：本人承担角色：函数实现整体流程控制 综合得分：（满分100分） 指导教师： 年月日（下面的内容由学生填写，格式统一为，字体: 楷体, 行距: 固定行距18，字号: 小四，个人报告按下面每一项的百分比打分。难度A满分70分，难度B满分90分）一、【实验构思（Conceive）】(10%) 多项式计算器的呈现方式是用控制台程序呈现，；多项式的加减乘以及求导的函数中利用链表保存头结点以及循环结构保存和输出数据；还有利用一个简单的降序排列的函数，在输出时更加明了。 二、【实验设计(Design)】(20%) 在头文件中申明变量，源文件中创建指数和系数的指针的头结点，并为此申请空间。首先考虑指数为0,1和系数为0,1时的特殊情况的表示；然后利用SORT函数对输出时进行降序排列；其次就是加减乘以及求导函数的实现；最后是一个输出界面的设计。 三、【实现描述（Implement）】(30%) //--------函数原型说明-------- typedef struct Node { double xishu; int zhishu;//数据域 //int data; struct Node* pnext;//指针域 }Node,*pNode; pNode phead=(pNode)malloc(sizeof(Node));//创建头节点 pNode creat_list(void);创建链表 void traverse_list(pNode phead);//遍历链表 pNode sort(pNode phead);//对链表进行降序排列 pNode add(pNode phead1,pNode phead2)；//两个多项式相加 pNode hebing(pNode phead)//合并同类项 pNode multi(pNode phead1,pNode phead2)；//多项式相乘 pNode sub(pNode phead1,pNode phead2)；//多项式相减 //多项式求导没有声明和定义函数，而是直接卸载程序里了多项式的运算(c语言实现)#include"stdio.h" #include"stdlib.h" #include"conio.h" typedef struct Item{ double coef;//系数 int expn;//指数 struct Item *next; }Item,*Polyn; #define CreateItem(p) p=(Item *)malloc(sizeof(Item)); #define DeleteItem(p) free((void *)p); /************************************************************/ /* 判断选择函数 */ /************************************************************/ int Select(char *str) { char ch; printf("%s\n",str); printf("Input Y or N:"); do{ ch=getch(); }while(ch!='Y'&&ch!='y'&&ch!='N'&&ch!='n'); printf("\n"); if(ch=='Y'||ch=='y') return(1); else return(0); } /************************************************************/ /* 插入位置定位函数 */ /**************************************************************/ int InsertLocate(Polyn h,int expn,Item **p) { Item *pre,*q; pre=h; q=h->next; while(q&&q->expnnext; } if(!q) { *p=pre; return(1); } else if(q->expn==expn) { *p=q; return(0); } else { *p=pre; return(-1); } } /************************************************************/ /* 插入结点函数 */ /************************************************************/ void insert(Item *pre,Item *p) {C++一元多项式合并实验报告实验二一元多项式相加问题本实验的目的是进一步熟练掌握应用链表处理实际问题的能力。 一、问题描述 一元多项式相加是通过键盘输入两个形如P 0+P 1 X1+P 2 X2+···+PnX n的多项式，经过程序运算后在屏幕上输出它 们的相加和。 二、数据结构设计 分析任意一元多项式的描述方法可知，一个一元多项式的每一个子项都由“系数—指数”两部分组成，所以可将它抽象成一个由“系数—指数对”构成线性表，由于对多项式中系数为0的子项可以不记录他的数值，对于这样的情况就不再付出存储空间来存放它了。基于这样的分析，可以采取一个带有头结点的单链表来表示一个一元多项式。具体数据结构定义为： typedef struct node { float ce; //系数域 float ex; //指数域 struct node *next; //指针域 }lnode,*linklist; 三功能（函数）设计 1、输入并建立多项式的功能模块 此模块要求按照指数递增的顺序和一定的输入格式输入各个系数不为0的子项的“系数—指数对”，输入一个子项建立一个相关的节点，当遇到输入结束标志时结束输入，而转去执行程序下面的部分。 屏幕提示： input ce & ex and end with 0： ce=1 ex=2 ce=0 ex=0 //输入结束标志 input ce & ex and end with 0： ce=2 ex=2 ce=0 ex=0 //输入结束标志 输入后程序将分别建立两个链表来描述两个一元多项式： A=X^2 B=2X^2 这两个多项式的相加的结果应该为： C=3X^2 2、多项式相加的功能模块 此模块根据在1中建立的两个多项式进行相加运算，并存放在以C为头指针的一个新建表中。可以采用以下方法进行设计： 开始时a，b分别指向A,B的开头，如果ab不为空，进行判断：如果a所指的结点的指数和b所指的结点的指数相同，将它们的系数相加做成C式中的一项，如果不一样则将小的一项加到C中。 if(a->ex==b->ex) //判断指数是否相等 {s->ce=a->ce+b->ce; if(s->ce!=0) s->ex=a->ex; else delete s; a=a->next; b=b->next; }一元稀疏多项式计算器C语言课程设计2014-2015学年第二学期学号1308210115 《软件工程》 课程设计报告 题目：一元稀疏多项式计算器 专业：计算机科学与技术 班级：计算机科学与技术（2）班 姓名： 指导教师： 成绩：一、问题描述 (3) 二、需求分析 (3) 三、概要设计 (4) 四、详细设计 (5) 五、源代码 (6) 六、程序测试 (18) 七、使用说明 (24) 八、课设总结 (25)一、问题描述 1.1基本要求 （1）输入并建立多项式； （2）输出多项式，输出形式为整数序列：n,c1,e1, c2,e2,,,,,,, cn,en,其中n是多项式的项数，ci,ei,分别是第i项的系数和指数，序列按指数降序排序； （3）多项式a和b相加，建立多项式a+b； （4）多项式a和b相减，建立多项式a-b； （5）计算多项式在x处的值。 （6）计算器的仿真界面。 1.2设计目的 数据结构是实践性很强的课程。课程设计是加强学生实践能力的一个强有力手段。课程设计要求学生在完成程序设计的同时能够写出比较规范的设计报告。严格实施课程设计这一环节，对于学生基本程序设计素养的培养和软件工作者工作作风的训练，将起到显著的促进作用 二、需求分析 2.1 设计开发环境： 软件方面：系统windows 7 编程软件：VC++ 6.0 2.2思路分析： ①一般情况下的一元n次多项式可写成 pn(x)=p1xe1+p2xe2+……+pmxem 其中，p1是指数为ei的项的非零系数，且满足0≦e1一元稀疏多项式计算器(数据结构)【问题描述】 设计一个一元稀疏多项式简单计算器 【基本要求】 一元多项式简单计算器的基本功能是： 1，输入并建立多项式; 2，输出多项式，输出形式为整数序列:n,c1,e1,c2,c2,...,cn,en,其中n是多项式的项数，ci和ei分别是第i项的系数和指数，序列按指数降序排列; 3,多项式a和b相加，建立多项式a+b; 4,多项式a和b相减，建立多项式a-b. 【测试数据】 1，(2x+5x^8-3.1x^11)+(7-5x^8+11x^9)=(-3.1x^11+11x^9+2x+7) 【实现提示】 用带表头结点的单链表存储多项式。 #include #include typedef struct node { float coef; int expn; struct node *next; }Lnode, *polynmial; void create(polynmial &L); //输入并建立多项式L void display(polynmial L); //显示，输出多项式L void 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，结果给Ld void 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; } }一元多项式相加完整实验报告一元多项式相加实验报告 一元多项式的相加一实验内容 根据所学的数据结构中线性结构（线性表）的逻辑特性和物理特性及相关算法，应用于求解一个具体的实际问题----------两个多项式相加 二需求分析 1掌握线性结构的逻辑特性和物理特性。 2建立一元多项式。 3将一元多项式输入，并存储在内存中，并按照指数降序排列输出多项式。 4能够完成两个多项式的加减运算，并输出结果。 三概要设计 1 本程序所用到的抽象数据类型： typedef OrderedLinkList polynomial; // 用带表头结点的有序链表表示多项式 结点的数据元素类型定义为: typedef struct { // 项的表示 float coef; // 系数 int expn; // 指数 term, ElemType; V oid AddPolyn(polynomail&Pa,polynomail&Pb) Position GetHead() Position NextPos(LinkList L,Link p) Elem GetCurElem(Link p) int cmp(term a term b) Status SetCurElem(Link&p, ElemType e) Status DelFirst(Link h, Link &q) Status ListEmpty(LinkList L) Status Append(LinkList&L, Link S) FreeNode() 2 存储结构一元多项式的表示在计算机内用链表来实现，同时为了节省存储空间，只存储其中非零的项，链表中的每个节点存放多项式的系数非零项。它包含三个域，分别存放多项式的系数，指数，以及指向下一个项的指针。 创建一元多项式链表，对运算中可能出现的各种情况进行分析，实现一元多项式的相加相减操作。 3 模块划分 a) 主程序；2）初始化单链表；3）建立单链表； 4）相加多项式 4 主程序流程图 四详细设计 根据一元多项式相加的运算规则：对于两个一元多项式中所有指数相同的项，对应系数相加，若其和不为零，则构成“和多项式”中的一项，对一元稀疏多项式计算器实验一元稀疏多项式计数器预习报告 姓名：刘茂学号2220 一、实验要求 (1)输入并建立多项式； (2)输出多项式，输出形式为整数序列：n，c1，e1，c2，e2……cn，en，其中n是多项式的项数，ci，ei分别为第i项的系数和指数。序列按指数降序排列； (3)多项式a和b相加，建立多项式a+b； (4)多项式a和b相减，建立多项式a-b。 （5）多项式求值； （6）多项式求导； （7）求多项式的乘积。 二、测试数据： 1、(2x+5x^^11)+(7-5x^8+11x^9)=^11+11x^9+2x+7); 2、(6x^-3-x+^^9+^9)-(-6x^-3+^2-x^2+^15 )=^^9+12x^-3-x); 3、(1+x+x^2+x^3+x^4+x^5)+(-x^3-x^4)=(1+x+x^2+x^5); 4、(x+x^3)+(-x-x^3)=0; 5、(x+x^100)+(x^100+x^200)=(x+2x^100+x^200); 6、(x+x^2+x^3)+0=x+x^2+x^3. 7、互换上述测试数据中的前后两个多项式。 三、思路分析 用带表头结点的单链表存储多项式。 本程序要求输入并建立多项式，能够降幂显示出多项式，实现多项式相加相减的计算问题，输出结果。采用链表的方式存储链表，定义结点结构体。运用尾差法建立两条单链表，以单链表polyn p和polyn h分别表示两个一元多项式a和b。 为实现处理，设p、q分别指向单链表polya和polyb的当前项，比较p、q 结点的指数项。 ① 若p->expnexpn，则结点p所指的结点应是“和多项式”中的一项，令指针p后移。 ② 若p->expn=q->expn，则将两个结点中的系数相加，当和不为0时修改结点p的系数。 ③ 若p->expn>q->expn，则结点q所指的结点应是“和多项式”中的一项，将结点q插入在结点p之前，且令指针q在原来的链表上后移。 四、实验程序 //头文件 #include<> #include<> #include<> //定义多项式的项 typedef struct Polynomial{ float coef; int expn; struct Polynomial *next; }*Polyn,Polynomial; void Insert(Polyn p,Polyn h){ if(p->coef==0) free(p);//系数为0的话释放结点 else一元稀疏多项式计算器(数据结构)院系：计算机科学学院 专业：软件工程 年级： 2013级 课程名称：数据结构 姓名：韦宜（201321092034）指导教师：宋中山 2015年 12 月 15日题目：设计一个一元稀疏多项式简单计算器 班级：软件工程1301 姓名：韦宜学号：201321092034 完成日期：12月15日 一、需求分析 问题描述：设计一个一元多项式加法器 基本要求： 输入并建立多项式； (2)两个多项式相加； (3)输出多项式：n, c1, e1, c2, e2, …cn , en, 其中，n是多项式项数，ci和ei分别是第i 项的系数和指数，序列按指数降序排列。 (4)计算多项式在x处的值； (5)求多项式的导函数。 软件环境：Windows，UNIX，Linux等不同平台下的Visual C++ 6.0 硬件环境: 512MB内存,80Gb硬盘,Pentium4 CPU,CRT显示器。二、概要分析 本程序有五个函数： PolyNode *Input()(输入函数)； PolyNode *Deri(PolyNode *head)（求导函数）； PolyNode * Plus(PolyNode *A,PolyNode *B)（求和函数）； void Output(PolyNode*head)（输出函数）； int main()（主函数） 本程序可使用带有附加头结点的单链表来实现多项式的链表表示，每个链表结点表示多项式的一项，命名为node，它包括两个数据成员：系数coef和指数exp，他们都是公共数据成员，*next为指针域，用链表来表示多项式。适用于不定的多项式，特别是对于项数再运算过程中动态增长的多项式，不存在存储溢出的问题。其次，对于某些零系数项，在执行加法运算后不再是零系数项，这就需要在结果多项式中增添新的项；对于某些非零系数项，在执行加法运算后可能是零系数项，这就需要在结果多项式中删去这些项，利用链表操作，可以简单的修改结点的指针以完成这种插入和删除运算（不像在顺序方式中那样，可能移动大量数据项）运行效率高。一元多项式的运算数据结构课程设计实验报告 专业班级： 学号： 姓名： 2011年1月1日题目：一元多项式的运算 1、题目描述 一元多项式的运算在此题中实现加、减法的运算，而多项式的减法可以通过加法来实现（只需在减法运算时系数前加负号）。 在数学上，一个一元n次多项式P n(X)可按降序写成： P n(X)= P n X^n+ P(n-1)X^(n-1)+......+ P1X+P0 它由n+1个系数惟一确定，因此，在计算机里它可以用一个线性表P来表示： P=(P n，P(n-1)，......，P1，P0) 每一项的指数i隐含在其系数P i的序号里。 假设Q m(X)是一元m次多项式，同样可以用一个线性表Q来表示： Q=(q m,q(m-1)，.....，q1，q0) 不是一般性，假设吗吗m一元稀疏多项式的加法运算(数据结构实习)实习一线性表、栈和队列及其应用 ——一元稀疏多项式的加法运算 【问题描述】 设计一个实现一元稀疏多项式相加运算的演示程序。 【基本要求】 （1）输入并建立两个多项式； （2）多项式a与b相加，建立和多项式c； （3）输出多项式a,b,c。输出格式：比如多项式a为：A(x)=c1xe1+ c2xe2+…+ cmxem，其中，ci和ei分别为第i项的系数和指数，且各项按 指数的升幂排列，即0≤e1＜e2＜…＜em。多项式b,c类似输出。 【测试数据】 （1）(1+x+x2+x3+x4+x5)+(-x3-x4)=(1+x+x2+x5) （2）(x+x100)+(x100+x200)=(x+2x100+x200) （3）(2x+5x8-3x11)+(7-5x8+11x9)=(7+2x+11x9-3x11) 一．需求分析 1.输入的形式和输入值的范围： 输入是从键盘输入的，输入的内容为多项式的系数和指数，其中多项式的每一项分别以一个系数和指数的形式输入，不带未知数X，系数为任意的实数，指数为任意的整数。 要结束该多项式的输入时，输入的指数和系数都为0. 2. 输出的形式 从屏幕输出，显示用户输入的多项式，并显示多项式加减以后的多项式的值，并且多项式中将未知数X表示了出来. 形式为：+c1X^e1+c2X^e2+…+ciX^ei+…(ci和ei分别是第i 项的系数和指数，序列按指数升序排列。) 当多项式的某一项的系数为+1或者-1时侧该项多项式的输出形式为X^ei或-X^ei； 当该项的系数为正时输出+ciX^ei,当为负数时则输出ciX^ei 3. 程序所能达到的功能 输入并建立多项式，实现一元稀疏多项式的相加并输出。 4. 注意：所有多项式都必须以指数升密形式输入。 5. 测试数据为（1）(1+x+x2+x3+x4+x5)+(-x3-x4)=(1+x+x2+x5) （2）(x+x100)+(x100+x200)=(x+2x100+x200) （3）(2x+5x8-3x11)+(7-5x8+11x9)=(7+2x+11x9-3x11) 二．设计 1.设计思路两个一元多项式相加-c++版《数据结构》实验报告 ——两个一元多项式相加 一、实验题目：两个一元多项式相加 二、实验内容： 根据所学的数据结构中线性结构（线性表）的逻辑特性和物理特性及相关算法，应用于求解一个具体的实际问题----------两个多项式相加 三、设计思想： （1）建立两个顺序列表，分别用来表示两个一元多项式；顺序列表奇数位，存储该多项式的系数；顺序列表的偶数位，存储该相应多项式的指数。 （2）用成员函数merg(qList&l2)实现两多项式的相加。实现的大致方法为：比较第二个多项式列表与第一个多项式列表的偶数位的数值大小（指数），如果 相同，则将他们的前一位数（系数）相加；如果不同，就将他的前一位数（系 数）及它自己（指数）插入第一个多项式列表的后面。 （3）建立函数shu(double a[],int j)实现多项式的输入。 四、源程序代码 #include "stdafx.h" #include using namespace std; template class List { private: Telem * elem; int curlen; int maxlen; public: List(int maxsz=100):maxlen(maxsz) { curlen=0; elem=new Telem{maxlen}; }; List(Telem a[],int n,int maxsz=100):maxlen(maxsz) { curlen=n; elem=new Telem[maxlen]; for(int i=0;i数据结构实验,多项式计算器实验题目：多项式运算器 实验内容：1、熟悉编程环境 2、用链式存储结构实现稀疏一元多项式运算器 实验目的和要求： 1、通过本实验，掌握VC++6.0的基本使用，包括源程序的输入，编译运行及调 试。调试的目的是找程序的运行错误，通过DEBUG菜单设置断点实现。 2、用链式存储结构实现一元多项式的运算。 熟练掌握指针和链表的基本操作，利用菜单进行功能选择。 功能基本要求：创建、显示、求和、求差、求值、销毁、清空、修改 实验算法： 1、数据结构描述： 输入的稀疏每一个多项式用一个链表存储，链表的每一个节点存储多项式的一个非零项。定义为LNode型结构体，其中保存该项的系数和指数。主 函数中用一个数组存储每一个多项式的第一项的头指针以调用多项式。 2、函数和算法描述： 主函数main定义LNode*数组a[]存储每一个多项式头节点的地址，并构建菜单以选择调用函数进行多项式的操作，对多项式进行操作的函数返回新 改动的多项式头结点地址。 Createpolyn函数用以创建一个多项式，在用户输入结束指令之前，不断的申请空间，构建LNode型结点并加至构建的链表的表尾，输入结束指令之 后，表尾设NULL并返回表头指针。 Printpolyn函数用以在屏幕上打印多项式，接收需要打印的多项式链表的头结点，构造循环体在表尾之前，不断以mx^n格式打印对应结点中的数 据。 Copypolyn函数用以复制多项式，接收需要复制的多项式a和复制位置b 的指针，构造循环体，在a到表尾之前循环，在b对应的链表中构建新的结 点，结点上的数据赋值为a中对应的值，返回b的头结点地址。 Addpolyn函数用以求两个已知多项式a、b的和存入c，先构建循环体，在a、b链表都未进行到表尾时，比较两个结点中的次数值，如果相同，将 系数相加赋于c的当前结点，如果不同，将次数较小多项式y（a或b）的结 点赋值给c当前结点，在将y链表向后推。 Subtract函数用以求两多项式的差，类似求和算法。 Value函数用以求一个多项式的值，接收x的值，构建循环体，在表尾之前循环以遍历多项式链表。内置循环体，以次数n为限循环，求出x^n的 值，乘以系数并将每一项的值叠加得值。 Destroypolyn函数用以销毁已有的多项式，将此多项式链表的空间FREE 掉，返回空指针。 Clearpolyn函数用以清空多项式，构建循环体，将多项式的各项的系数、指数置零。 3、时空分析： L= sizeof(struct LNode) 一个含有N项的多项式占用的储存空间为NL+1[计算机]一元多项式相加完整实验报告[计算机]一元多项式相加完整实验报告一元多项式的相加 一实验内容 根据所学的数据结构中线性结构(线性表)的逻辑特性和物理特性及相关算法，应用于求解一个具体的实际问题----------两个多项式相加 二需求分析 1掌握线性结构的逻辑特性和物理特性。 2建立一元多项式。 3将一元多项式输入，并存储在内存中，并按照指数降序排列输出多项式。 4能够完成两个多项式的加减运算，并输出结果。 三概要设计 1 本程序所用到的抽象数据类型: typedef OrderedLinkList polynomial; // 用带表头结点的有序链表表示多项式 结点的数据元素类型定义为: typedef struct { // 项的表示 oat flcoef; // 系数 int expn; // 指数 term, ElemType; Void AddPolyn(polynomail&Pa,polynomail&Pb) Position GetHead() Position NextPos(LinkList L,Link p) Elem GetCurElem(Link p) int cmp(term a term b)Status SetCurElem(Link&p, ElemType e) Status DelFirst(Link h, Link &q) Status ListEmpty(LinkList L) Status Append(LinkList&L, Link S) FreeNode() 2 存储结构 一元多项式的表示在计算机内用链表来实现，同时为了节省存储空间，只存储其中非零的项，链表中的每个节点存放多项式的系数非零项。它包含三个域，分别存放多项式的系数，指数，以及指向下一个项的指针。 序数coef 指数exp 指针域next 创建一元多项式链表，对运算中可能出现的各种情况进行分析，实现一元多项式的相加相减操作。 3 模块划分 a) 主程序;2)初始化单链表;3)建立单链表; 4)相加多项式 4 主程序流程图 开始 申请结点空间 输入多项式各项的系数X，指数Y 输出已输出的多项式 否 是否输入正确 合并同类项 结束 四详细设计 根据一元多项式相加的运算规则:对于两个一元多项式中所有指数相用C语言实现多项式简单计算器的设计武汉理工大学华夏学院课程设计报告书 课程名称：数据结构 题目：用C语言实现多项式简单计算器的设计 系名：信息工程系 专业班级：软件工程1121班 姓名：邓燕蓉 指导教师:王绪梅 2013 年 6月 28日课程设计任务书 学生姓名：邓燕蓉专业班级：软件工程1121班 指导教师：王绪梅工作单位：华夏学院计算机教研室设计题目：用C语言实现多项式简单计算器的设计 设计目的 1.巩固和加深课堂所学知识、学会分析研究数据对象的特性及数据的组织方法； 2.选择合适的数据的逻辑结构和存储结构以及相应操作，实现简单的多项式计算； 3.提高程序设计能力、加强查阅、运用资料的能力、算法分析与程序设计素质培养； 设计任务（在规定的时间内完成下列任务） 〔问题描述〕输入并建立两个多项式并输出多项式 设计一个程序：对两个多项式进行加、减法及乘法运算,建立一个新多项式并输出. 或设计一个程序对其中一个多项式求导。 〔实现提示〕 选择带头结点的单链表或循环链表存储多项式,头结点中存放多项式的参数及单链表的数据具体要完成的任务是： A.编制完成上述问题的C语言程序、进行程序调试并能得出正确的运行结果。 B.写出规范的课程设计报告书； 时间安排：6月24日---28日 具体要求 1. 课程设计报告按统一通用格式书写，具体内容如下： ①设计任务与要求 ②总体方案与说明 ③软件主要模块的流程图 ④源程序清单与注释 ⑤问题分析与解决方案（包括调式记录、调式报告，即在调式过程中遇到的主要问题、解决方法 及改进设想）； ⑥小结与体会 附录：①源程序（必须有简单注释）②使用说明③参考资料 2.每位学生应独立完成各自的任务且每天至少在设计室工作半天； 指导教师签名：王绪梅2013 年6月22日 教研室主任（或责任教师）签名：2013年6月24日数据结构实验报告-一元多项式数据结构课程设计报告 课题: 一元多项式 姓名： XX 学号： 201417030218 专业班级： XXXX 指导教师： XXXX 设计时间： 2015年12月30日星期三目录 一、任务目标 (3) 二、概要设计 (4) 三、详细设计 (6) 四、调试分析 (8) 五、源程序代码 (8) 六、程序运行效果图与说明 (15) 七、本次实验小结 (16) 八、参考文献 (16)一丶任务目标 分析 (1) a.能够按照指数降序排列建立并输出多项式 b.能够完成两个多项式的相加，相减，并将结果输入 要求：程序所能达到的功能： a.实现一元多项式的输入； b.实现一元多项式的输出； c.计算两个一元多项式的和并输出结果； d.计算两个一元多项式的差并输出结果； 除任务要求外新增乘法： 计算两个一元多项式的乘积并输出结果 （2）输入的形式和输入值的范围： 输入要求：分行输入，每行输入一项，先输入多项式的指数，再输入多项式的系数，以0 0为结束标志，结束一个多项式的输入。 输入形式： 2 3 -1 2 3 0 1 2 0 0 输入值的范围：系数为int型，指数为float型 （3）输出的形式： 第一行输出多项式1； 第二行输出多项式2； 第三行输出多项式1与多项式2相加的结果多项式； 第四行输出多项式1与多项式2相减的结果多项式； 第五行输出多项式1与多项式2相乘的结果多项式二、概要设计 程序实现 a. 功能：将要进行运算的二项式输入输出； b. 数据流入：要输入的二项式的系数与指数； c. 数据流出：合并同类项后的二项式； d. 程序流程图：二项式输入流程图； e. 测试要点：输入的二项式是否正确，若输入错误则重新输入。一元多项式计算器设计与实现一元稀疏多项式简单计算器 一、设计课题 设计一元稀疏多项式简单计算器。 二、需求分析 2.1 输入的形式和输入值的范围： 输入是从键盘输入的，输入的内容为多项式的系数和指数，数为任意的整数，指数为大于等于0的整数 2.2 输出的形式 从屏幕输出，显示用户输入的多项式，并显示多项式加减以后的多项式的值。 2.3 程序所能达到的功能 a：输入并建立多项式； b：输出多项式，输出形式为整数序列：n,c1,e1,c2,e2,……,cn,en,其中n是多项式的项数，ci和ei 分别是第i项的系数和指数，序列按指数降序排列； c：多项式a和b相加，建立多项式a+b； d：多项式a和b相减，建立多项式a-b； 2.4 测试数据 （1）(2x+5x^8-3.1x^11)+(7-5x^8+11x^9) = (-3.1x^11+11X^9+2X+7) （2）(X+X^3)+(-X-X^3)=0 （3）(X+X^2+X^3)+0= X+X^2+X^3 三、概要设计 3.1 设计思路 A：数据结构的选用 为了实现任意多项式的加法、减法，因此选择单链表的结构体，它有一个系数，指数，下一个指针3个元属；单链表抽象结构类型定义见附录2。 B：多项式的输入 采用头节点插法的方式，输入多项式中一个项的系数和指数，就产生一个新的节点，建立起它的右指针，并用头节点指向它；为了判断一个多项式是否输入结束，定义一个结束标志，当输入非00时就继续，当输入00时，就结束一个多项式的输入； C：2个多项式的加法 它从2个多项式的头部开始，2个多项式的某一项都不为空时，如果指数相等的话，系数就应该相加；相加的和不为0的话，用头插法建立一个新的节点。p的系数小于q的系数的话，就应该复制q接点到多项式中。p的系数大于q的系数的话，就应该复制p接点到多项式中。当第2个多项式空，第1个数不为空时，将第一个数剩下的全用新节点产生。当第1个多项式空，第1个数不为空时，将第2个数剩下的全用新节点产生 D：2个多项式的减法 它从2个多项式的头部开始，2个多项式的某一项都不为空时，如果指数相等的话，系数就应该相减；相加的和不为0的话，用头插法建立一个新的节点。 p的系数小于q的系数的话，就应该复制q接点到多项式中。p的系数大于q的系数的话，就应该复制p接点到多项式中，并且建立的接点的系数为原来的相反数；当第2个多项式空，第1个数不为空时，将第一个数剩下的全用新节点产生。当第1个多项式空，第1个数不为空时，将第2个数剩下的全用新节点产生，并且建立的接点的系数为原来的相反数。
scanf("%g,%d",&e.coef,&e.expn);
Insert(polynomial,p);}
polynomial.tail=p;
void PrintPolyn(List L)
if(L.head==L.tail)
printf("0");
else
p=L.head->next;
while(p!=NULL)
if(p==L.head->next)
if(p->data.coef>0)
if(p->data.expn!=0)
{printf("%gx^%d",p->data.coef,p->data.expn);}
else{printf("%g",p->data.coef);}
else if(p->data.coef<0)
{printf(" ");}
p=p->next;
else if(p!=L.head->next && p!=NULL)
{printf("+%gx^%d",p->data.coef,p->data.expn);}
else{printf("+%g",p->data.coef);}
void AlterPoly(List L)
for(Polyn p=L.head->next;p!=NULL;p=p->next)
p->data.coef*=-1;
void AddPolyn(List L1,List L2,List &L3)
Polyn p1,p2,p3;
p1=L1.head->next;
p2=L2.head->next;
while(p1!=NULL && p2!=NULL)
if(p1->data.expn>p2->data.expn)
MakeNode(p3,p1->data);
Insert(L3,p3);
p1=p1->next;
else if(p1->data.expndata.expn)
MakeNode(p3,p2->data);
p2=p2->next;
else if(p1->data.expn==p2->data.expn)
p3->data.coef=p1->data.coef+p2->data.coef;
p3->data.expn=p1->data.expn;
p1=p1->next;p2=p2->next;
if(p1==NULL && p2!=NULL)
while(p2!=NULL){
else if(p2==NULL && p1!=NULL)
while(p1!=NULL){
4、main.cpp
void main()
system("cls");
printf("********************************************************* ***\n");
printf(" 欢迎使用一元稀疏多项式计算\n");
printf("1、创建多项式A 2、创建多项式B 3、相加 4、相减 5、退出\n");
List polynomialA,polynomialB,polynomialC;
InitList(polynomialA); InitList(polynomialB); InitList(polynomialC);
char poly;
int m;int n=1;
for(;;)
printf("请输入指令:");
poly=getchar();
switch(poly)
case'1': //创建多项式A printf("请输入多项式A的项数：");
scanf("%d",&m);
printf("\n请输入多项式 A：");
CreatPolyn(polynomialA,m);
printf("\n多项式A是：");
PrintPolyn(polynomialA);
printf("\n");
break;
case'2': //创建多项式B printf("请输入多项式B的项数：");
printf("\n请输入多项式 B：");
CreatPolyn(polynomialB,m);
printf("\n多项式B是：");
PrintPolyn(polynomialB);
case'3': //加法
printf("结果是:");
AddPolyn(polynomialA,polynomialB,polynomialC);
PrintPolyn(polynomialC);
case'4': //减法
AlterPoly(polynomialB);
DestroyList(polynomialC);
InitList(polynomialC);
case'5': DestroyList(polynomialA); //退出DestroyList(polynomialB);
if(poly==5)
一元稀疏多项式计数器预习报告 ：刘茂学号0062 一、实验要求 (1)输入并建立多项式； (2)输出多项式，输出形式为整数序列：n，c1，e1，c2，e2……cn，en，其中n是多项式的项数，ci，ei分别为第i项的系数和指数。序列按指数降序排列； (3)多项式a和b相加，建立多项式a+b； (4)多项式a和b相减，建立多项式a-b。 （5）多项式求值； （6）多项式求导； （7）求多项式的乘积。 二、测试数据： 1、(2x+5x^8-3.1x^11)+(7-5x^8+11x^9)=(-3.1x^11+11x^9+2x+7); 2、(6x^-3-x+4.4x^2-1.2x^9+1.2x^9)-(-6x^-3+5.4x^2-x^2+7.8x^15 )=(-7.8x^15-1.2x^9+12x^-3-x); 3、(1+x+x^2+x^3+x^4+x^5)+(-x^3-x^4)=(1+x+x^2+x^5); 4、(x+x^3)+(-x-x^3)=0; 5、(x+x^100)+(x^100+x^200)=(x+2x^100+x^200); 6、(x+x^2+x^3)+0=x+x^2+x^3. 7、互换上述测试数据中的前后两个多项式。
三、思路分析 用带表头结点的单链表存储多项式。 本程序要求输入并建立多项式，能够降幂显示出多项式，实现多项式相加相减的计算问题，输出结果。 采用链表的方式存储链表，定义结点结构体。运用尾差法建立两条单链表，以单链表polyn p和polyn h分别表示两个一元多项式a和b。 为实现处理，设p、q分别指向单链表polya和polyb的当前项，比较p、q 结点的指数项。 ①若p->expnexpn，则结点p所指的结点应是“和多项式”中的一项，令指针p后移。 ②若p->expn=q->expn，则将两个结点中的系数相加，当和不为0时修改结点p的系数。 ③若p->expn>q->expn，则结点q所指的结点应是“和多项式”中的一项，将结点q插入在结点p之前，且令指针q在原来的链表上后移。 四、实验程序 //头文件 #include #include #include //定义多项式的项 typedef struct Polynomial{ float coef; int expn; struct Polynomial *next; }*Polyn,Polynomial;
数据结构课程设计报告
目录 一、任务目标,,,,,,,,,,,, 3 二、概要设计,,,,,,,,,,,, 4 三、详细设计,,,,,,,,,,,, 6 四、调试分析,,,,,,,,,,,, 8 五、源程序代码,,,,,,,,,, 8 六、程序运行效果图与说明,,,,, 15 七、本次实验小结,,,,,,,,, 16 八、参考文献,,,,,,,,,,, 16
任务目标 分析（1） a. 能够按照指数降序排列建立并输出多项式 b.能够完成两个多项式的相加，相减，并将结果输入要求：程序所能达到的功能： a.实现一元多项式的输入； b.实现一元多项式的输出； c.计算两个一元多项式的和并输出结果； d.计算两个一元多项式的差并输出结果；除任务要求外新增乘法： 计算两个一元多项式的乘积并输出结果 （2）输入的形式和输入值的范围：输入要求：分行输入，每行输入一项，先输入多项式的指数，再输入多项式的系数，以0 0 为结束标志，结束一个多项式的输入。 输入形式： 2 3 -1 2 3 0 1 2 0 0 输入值的范围：系数为int 型，指数为float 型 3）输出的形式： 第一行输出多项式1； 第二行输出多项式2； 第三行输出多项式 1 与多项式 2 相加的结果多项式； 第四行输出多项式 1 与多项式 2 相减的结果多项式；第五行输出多项式 1 与多项式 2 相乘的结果多项式 二、概要设计 程序实现 a. 功能：将要进行运算的二项式输入输出；
b. 数据流入：要输入的二项式的系数与指数； c.数据流出：合并同类项后的二项式； d.程序流程图：二项式输入流程图； e.测试要点：输入的二项式是否正确，若输入错误则重新输入
华北水利水电学院一元稀疏多项式计算器实验报告 2010～2011学年第一学期 09 级计算机科学与技术专业班级： 2009119 学号： 200911902 姓名：万婷婷 一、实验目的 设计一个医院稀疏多项式简单计算器 熟练掌握线性表的基本操作在两种存储结构上的实现，其中以各种链表的操作和应用 二、实验要求 a)输入并建立多项式 b)输出多项式，输出形式为整数序列：n，c 1，e 1 ，c 2 ，e 2 ……c n ，e n ，其中n是多 项式的项数，c i ，e i 分别为第i项的系数和指数。序列按指数降序排列。 c)多项式a和b相加，建立多项式a+b，输出相加的多项式。 d)多项式a和b相减，建立多项式a-b，输出相减的多项式。 用带表头结点的单链表存储多项式。 测试数据： (1) (2x+5x8-3.1x11)+(7-5x8+11x9) (2) (6x-3-x+4.4x2-1.2x9)-(-6x-3+5.4x2+7.8x15) (3)（1+x+x2 +x3 +x4 +x5）+( -x3- x4) (4)(x+x2+x3)+0 (5)(x+x3)-(-x-x-3) (6) (x+x2 +x3 )+0 三、实验内容 主要算法设计 typedef struct Node { float coef; int index; struct Node *next; }LinkList; 本程序涉及到多项式的建立、多项式的输出、两个多项式的相加减。用带头结点的单链表存储多项式； 程序中共定义了5个函数：
void Insert(LinkList *p,LinkList *h)//把节点p插入到链表h中LinkList *Creat_L(LinkList *head,int m)//创建一个链表，项数为m void Printf(LinkList *L) LinkList *ADDlist(LinkList *head,LinkList *pb) LinkList *MinusList(LinkList *head,LinkList *pb) 四、程序源代码 #include #include #include #include typedef struct Node { float coef; int index; struct Node *next; }LinkList; void Insert(LinkList *p,LinkList *h)//把节点p插入到链表h中 { LinkList *q1,*q2; int flag=0; q1=h; if(p->coef==0) free(p); else { if(q1->next==NULL) { q1->next=p; }
云南大学软件学院数据结构实验报告 （本实验项目方案受“教育部人才培养模式创新实验区（X3108005）”项目资助）实验难度： A □ B □ C □ 学期：2012秋季学期 任课教师: 实验题目: 一元稀疏多项式计算器 小组长: 联系电话: 电子邮件: 完成提交时间：2012 年 11 月 10 日 云南大学软件学院2012学年秋季学期
《数据结构实验》成绩考核表 学号： 20111120 姓名：本人承担角色：算法设计整体流程控制 综合得分：（满分100分） 指导教师： 年月日
云南大学软件学院2010学年秋季学期 《数据结构实验》成绩考核表 学号： 20111120 姓名：本人承担角色：函数实现整体流程控制 综合得分：（满分100分） 指导教师： 年月日
（下面的内容由学生填写，格式统一为，字体: 楷体, 行距: 固定行距18，字号: 小四，个人报告按下面每一项的百分比打分。难度A满分70分，难度B满分90分）一、【实验构思（Conceive）】(10%) 多项式计算器的呈现方式是用控制台程序呈现，；多项式的加减乘以及求导的函数中利用链表保存头结点以及循环结构保存和输出数据；还有利用一个简单的降序排列的函数，在输出时更加明了。 二、【实验设计(Design)】(20%) 在头文件中申明变量，源文件中创建指数和系数的指针的头结点，并为此申请空间。首先考虑指数为0,1和系数为0,1时的特殊情况的表示；然后利用SORT函数对输出时进行降序排列；其次就是加减乘以及求导函数的实现；最后是一个输出界面的设计。 三、【实现描述（Implement）】(30%) //--------函数原型说明-------- typedef struct Node { double xishu; int zhishu;//数据域 //int data; struct Node* pnext;//指针域 }Node,*pNode; pNode phead=(pNode)malloc(sizeof(Node));//创建头节点 pNode creat_list(void);创建链表 void traverse_list(pNode phead);//遍历链表 pNode sort(pNode phead);//对链表进行降序排列 pNode add(pNode phead1,pNode phead2)；//两个多项式相加 pNode hebing(pNode phead)//合并同类项 pNode multi(pNode phead1,pNode phead2)；//多项式相乘 pNode sub(pNode phead1,pNode phead2)；//多项式相减 //多项式求导没有声明和定义函数，而是直接卸载程序里了
#include"stdio.h" #include"stdlib.h" #include"conio.h" typedef struct Item{ double coef;//系数 int expn;//指数 struct Item *next; }Item,*Polyn; #define CreateItem(p) p=(Item *)malloc(sizeof(Item)); #define DeleteItem(p) free((void *)p); /************************************************************/ /* 判断选择函数 */ /************************************************************/ int Select(char *str) { char ch; printf("%s\n",str); printf("Input Y or N:"); do{ ch=getch(); }while(ch!='Y'&&ch!='y'&&ch!='N'&&ch!='n'); printf("\n"); if(ch=='Y'||ch=='y') return(1); else return(0); } /************************************************************/ /* 插入位置定位函数 */ /**************************************************************/ int InsertLocate(Polyn h,int expn,Item **p) { Item *pre,*q; pre=h; q=h->next; while(q&&q->expnnext; } if(!q) { *p=pre; return(1); } else if(q->expn==expn) { *p=q; return(0); } else { *p=pre; return(-1); } } /************************************************************/ /* 插入结点函数 */ /************************************************************/ void insert(Item *pre,Item *p) {
实验二一元多项式相加问题本实验的目的是进一步熟练掌握应用链表处理实际问题的能力。 一、问题描述 一元多项式相加是通过键盘输入两个形如P 0+P 1 X1+P 2 X2+···+PnX n的多项式，经过程序运算后在屏幕上输出它 们的相加和。 二、数据结构设计 分析任意一元多项式的描述方法可知，一个一元多项式的每一个子项都由“系数—指数”两部分组成，所以可将它抽象成一个由“系数—指数对”构成线性表，由于对多项式中系数为0的子项可以不记录他的数值，对于这样的情况就不再付出存储空间来存放它了。基于这样的分析，可以采取一个带有头结点的单链表来表示一个一元多项式。具体数据结构定义为： typedef struct node { float ce; //系数域 float ex; //指数域 struct node *next; //指针域 }lnode,*linklist; 三功能（函数）设计 1、输入并建立多项式的功能模块 此模块要求按照指数递增的顺序和一定的输入格式输入各个系数不为0的子项的“系数—指数对”，输入一个子项建立一个相关的节点，当遇到输入结束标志时结束输入，而转去执行程序下面的部分。 屏幕提示： input ce & ex and end with 0： ce=1 ex=2 ce=0 ex=0 //输入结束标志 input ce & ex and end with 0： ce=2 ex=2 ce=0 ex=0 //输入结束标志 输入后程序将分别建立两个链表来描述两个一元多项式： A=X^2 B=2X^2 这两个多项式的相加的结果应该为： C=3X^2 2、多项式相加的功能模块 此模块根据在1中建立的两个多项式进行相加运算，并存放在以C为头指针的一个新建表中。可以采用以下方法进行设计： 开始时a，b分别指向A,B的开头，如果ab不为空，进行判断：如果a所指的结点的指数和b所指的结点的指数相同，将它们的系数相加做成C式中的一项，如果不一样则将小的一项加到C中。 if(a->ex==b->ex) //判断指数是否相等 {s->ce=a->ce+b->ce; if(s->ce!=0) s->ex=a->ex; else delete s; a=a->next; b=b->next; }
2014-2015学年第二学期学号1308210115 《软件工程》 课程设计报告 题目：一元稀疏多项式计算器 专业：计算机科学与技术 班级：计算机科学与技术（2）班 姓名： 指导教师： 成绩：
一、问题描述 (3) 二、需求分析 (3) 三、概要设计 (4) 四、详细设计 (5) 五、源代码 (6) 六、程序测试 (18) 七、使用说明 (24) 八、课设总结 (25)
一、问题描述 1.1基本要求 （1）输入并建立多项式； （2）输出多项式，输出形式为整数序列：n,c1,e1, c2,e2,,,,,,, cn,en,其中n是多项式的项数，ci,ei,分别是第i项的系数和指数，序列按指数降序排序； （3）多项式a和b相加，建立多项式a+b； （4）多项式a和b相减，建立多项式a-b； （5）计算多项式在x处的值。 （6）计算器的仿真界面。 1.2设计目的 数据结构是实践性很强的课程。课程设计是加强学生实践能力的一个强有力手段。课程设计要求学生在完成程序设计的同时能够写出比较规范的设计报告。严格实施课程设计这一环节，对于学生基本程序设计素养的培养和软件工作者工作作风的训练，将起到显著的促进作用 二、需求分析 2.1 设计开发环境： 软件方面：系统windows 7 编程软件：VC++ 6.0 2.2思路分析： ①一般情况下的一元n次多项式可写成 pn(x)=p1xe1+p2xe2+……+pmxem 其中，p1是指数为ei的项的非零系数，且满足0≦e1一元稀疏多项式计算器(数据结构)【问题描述】 设计一个一元稀疏多项式简单计算器 【基本要求】 一元多项式简单计算器的基本功能是： 1，输入并建立多项式; 2，输出多项式，输出形式为整数序列:n,c1,e1,c2,c2,...,cn,en,其中n是多项式的项数，ci和ei分别是第i项的系数和指数，序列按指数降序排列; 3,多项式a和b相加，建立多项式a+b; 4,多项式a和b相减，建立多项式a-b. 【测试数据】 1，(2x+5x^8-3.1x^11)+(7-5x^8+11x^9)=(-3.1x^11+11x^9+2x+7) 【实现提示】 用带表头结点的单链表存储多项式。 #include #include typedef struct node { float coef; int expn; struct node *next; }Lnode, *polynmial; void create(polynmial &L); //输入并建立多项式L void display(polynmial L); //显示，输出多项式L void 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，结果给Ld void 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; } }一元多项式相加完整实验报告一元多项式相加实验报告 一元多项式的相加一实验内容 根据所学的数据结构中线性结构（线性表）的逻辑特性和物理特性及相关算法，应用于求解一个具体的实际问题----------两个多项式相加 二需求分析 1掌握线性结构的逻辑特性和物理特性。 2建立一元多项式。 3将一元多项式输入，并存储在内存中，并按照指数降序排列输出多项式。 4能够完成两个多项式的加减运算，并输出结果。 三概要设计 1 本程序所用到的抽象数据类型： typedef OrderedLinkList polynomial; // 用带表头结点的有序链表表示多项式 结点的数据元素类型定义为: typedef struct { // 项的表示 float coef; // 系数 int expn; // 指数 term, ElemType; V oid AddPolyn(polynomail&Pa,polynomail&Pb) Position GetHead() Position NextPos(LinkList L,Link p) Elem GetCurElem(Link p) int cmp(term a term b) Status SetCurElem(Link&p, ElemType e) Status DelFirst(Link h, Link &q) Status ListEmpty(LinkList L) Status Append(LinkList&L, Link S) FreeNode() 2 存储结构一元多项式的表示在计算机内用链表来实现，同时为了节省存储空间，只存储其中非零的项，链表中的每个节点存放多项式的系数非零项。它包含三个域，分别存放多项式的系数，指数，以及指向下一个项的指针。 创建一元多项式链表，对运算中可能出现的各种情况进行分析，实现一元多项式的相加相减操作。 3 模块划分 a) 主程序；2）初始化单链表；3）建立单链表； 4）相加多项式 4 主程序流程图 四详细设计 根据一元多项式相加的运算规则：对于两个一元多项式中所有指数相同的项，对应系数相加，若其和不为零，则构成“和多项式”中的一项，对一元稀疏多项式计算器实验一元稀疏多项式计数器预习报告 姓名：刘茂学号2220 一、实验要求 (1)输入并建立多项式； (2)输出多项式，输出形式为整数序列：n，c1，e1，c2，e2……cn，en，其中n是多项式的项数，ci，ei分别为第i项的系数和指数。序列按指数降序排列； (3)多项式a和b相加，建立多项式a+b； (4)多项式a和b相减，建立多项式a-b。 （5）多项式求值； （6）多项式求导； （7）求多项式的乘积。 二、测试数据： 1、(2x+5x^^11)+(7-5x^8+11x^9)=^11+11x^9+2x+7); 2、(6x^-3-x+^^9+^9)-(-6x^-3+^2-x^2+^15 )=^^9+12x^-3-x); 3、(1+x+x^2+x^3+x^4+x^5)+(-x^3-x^4)=(1+x+x^2+x^5); 4、(x+x^3)+(-x-x^3)=0; 5、(x+x^100)+(x^100+x^200)=(x+2x^100+x^200); 6、(x+x^2+x^3)+0=x+x^2+x^3. 7、互换上述测试数据中的前后两个多项式。 三、思路分析 用带表头结点的单链表存储多项式。 本程序要求输入并建立多项式，能够降幂显示出多项式，实现多项式相加相减的计算问题，输出结果。采用链表的方式存储链表，定义结点结构体。运用尾差法建立两条单链表，以单链表polyn p和polyn h分别表示两个一元多项式a和b。 为实现处理，设p、q分别指向单链表polya和polyb的当前项，比较p、q 结点的指数项。 ① 若p->expnexpn，则结点p所指的结点应是“和多项式”中的一项，令指针p后移。 ② 若p->expn=q->expn，则将两个结点中的系数相加，当和不为0时修改结点p的系数。 ③ 若p->expn>q->expn，则结点q所指的结点应是“和多项式”中的一项，将结点q插入在结点p之前，且令指针q在原来的链表上后移。 四、实验程序 //头文件 #include<> #include<> #include<> //定义多项式的项 typedef struct Polynomial{ float coef; int expn; struct Polynomial *next; }*Polyn,Polynomial; void Insert(Polyn p,Polyn h){ if(p->coef==0) free(p);//系数为0的话释放结点 else一元稀疏多项式计算器(数据结构)院系：计算机科学学院 专业：软件工程 年级： 2013级 课程名称：数据结构 姓名：韦宜（201321092034）指导教师：宋中山 2015年 12 月 15日题目：设计一个一元稀疏多项式简单计算器 班级：软件工程1301 姓名：韦宜学号：201321092034 完成日期：12月15日 一、需求分析 问题描述：设计一个一元多项式加法器 基本要求： 输入并建立多项式； (2)两个多项式相加； (3)输出多项式：n, c1, e1, c2, e2, …cn , en, 其中，n是多项式项数，ci和ei分别是第i 项的系数和指数，序列按指数降序排列。 (4)计算多项式在x处的值； (5)求多项式的导函数。 软件环境：Windows，UNIX，Linux等不同平台下的Visual C++ 6.0 硬件环境: 512MB内存,80Gb硬盘,Pentium4 CPU,CRT显示器。二、概要分析 本程序有五个函数： PolyNode *Input()(输入函数)； PolyNode *Deri(PolyNode *head)（求导函数）； PolyNode * Plus(PolyNode *A,PolyNode *B)（求和函数）； void Output(PolyNode*head)（输出函数）； int main()（主函数） 本程序可使用带有附加头结点的单链表来实现多项式的链表表示，每个链表结点表示多项式的一项，命名为node，它包括两个数据成员：系数coef和指数exp，他们都是公共数据成员，*next为指针域，用链表来表示多项式。适用于不定的多项式，特别是对于项数再运算过程中动态增长的多项式，不存在存储溢出的问题。其次，对于某些零系数项，在执行加法运算后不再是零系数项，这就需要在结果多项式中增添新的项；对于某些非零系数项，在执行加法运算后可能是零系数项，这就需要在结果多项式中删去这些项，利用链表操作，可以简单的修改结点的指针以完成这种插入和删除运算（不像在顺序方式中那样，可能移动大量数据项）运行效率高。一元多项式的运算数据结构课程设计实验报告 专业班级： 学号： 姓名： 2011年1月1日题目：一元多项式的运算 1、题目描述 一元多项式的运算在此题中实现加、减法的运算，而多项式的减法可以通过加法来实现（只需在减法运算时系数前加负号）。 在数学上，一个一元n次多项式P n(X)可按降序写成： P n(X)= P n X^n+ P(n-1)X^(n-1)+......+ P1X+P0 它由n+1个系数惟一确定，因此，在计算机里它可以用一个线性表P来表示： P=(P n，P(n-1)，......，P1，P0) 每一项的指数i隐含在其系数P i的序号里。 假设Q m(X)是一元m次多项式，同样可以用一个线性表Q来表示： Q=(q m,q(m-1)，.....，q1，q0) 不是一般性，假设吗吗m一元稀疏多项式的加法运算(数据结构实习)实习一线性表、栈和队列及其应用 ——一元稀疏多项式的加法运算 【问题描述】 设计一个实现一元稀疏多项式相加运算的演示程序。 【基本要求】 （1）输入并建立两个多项式； （2）多项式a与b相加，建立和多项式c； （3）输出多项式a,b,c。输出格式：比如多项式a为：A(x)=c1xe1+ c2xe2+…+ cmxem，其中，ci和ei分别为第i项的系数和指数，且各项按 指数的升幂排列，即0≤e1＜e2＜…＜em。多项式b,c类似输出。 【测试数据】 （1）(1+x+x2+x3+x4+x5)+(-x3-x4)=(1+x+x2+x5) （2）(x+x100)+(x100+x200)=(x+2x100+x200) （3）(2x+5x8-3x11)+(7-5x8+11x9)=(7+2x+11x9-3x11) 一．需求分析 1.输入的形式和输入值的范围： 输入是从键盘输入的，输入的内容为多项式的系数和指数，其中多项式的每一项分别以一个系数和指数的形式输入，不带未知数X，系数为任意的实数，指数为任意的整数。 要结束该多项式的输入时，输入的指数和系数都为0. 2. 输出的形式 从屏幕输出，显示用户输入的多项式，并显示多项式加减以后的多项式的值，并且多项式中将未知数X表示了出来. 形式为：+c1X^e1+c2X^e2+…+ciX^ei+…(ci和ei分别是第i 项的系数和指数，序列按指数升序排列。) 当多项式的某一项的系数为+1或者-1时侧该项多项式的输出形式为X^ei或-X^ei； 当该项的系数为正时输出+ciX^ei,当为负数时则输出ciX^ei 3. 程序所能达到的功能 输入并建立多项式，实现一元稀疏多项式的相加并输出。 4. 注意：所有多项式都必须以指数升密形式输入。 5. 测试数据为（1）(1+x+x2+x3+x4+x5)+(-x3-x4)=(1+x+x2+x5) （2）(x+x100)+(x100+x200)=(x+2x100+x200) （3）(2x+5x8-3x11)+(7-5x8+11x9)=(7+2x+11x9-3x11) 二．设计 1.设计思路两个一元多项式相加-c++版《数据结构》实验报告 ——两个一元多项式相加 一、实验题目：两个一元多项式相加 二、实验内容： 根据所学的数据结构中线性结构（线性表）的逻辑特性和物理特性及相关算法，应用于求解一个具体的实际问题----------两个多项式相加 三、设计思想： （1）建立两个顺序列表，分别用来表示两个一元多项式；顺序列表奇数位，存储该多项式的系数；顺序列表的偶数位，存储该相应多项式的指数。 （2）用成员函数merg(qList&l2)实现两多项式的相加。实现的大致方法为：比较第二个多项式列表与第一个多项式列表的偶数位的数值大小（指数），如果 相同，则将他们的前一位数（系数）相加；如果不同，就将他的前一位数（系 数）及它自己（指数）插入第一个多项式列表的后面。 （3）建立函数shu(double a[],int j)实现多项式的输入。 四、源程序代码 #include "stdafx.h" #include using namespace std; template class List { private: Telem * elem; int curlen; int maxlen; public: List(int maxsz=100):maxlen(maxsz) { curlen=0; elem=new Telem{maxlen}; }; List(Telem a[],int n,int maxsz=100):maxlen(maxsz) { curlen=n; elem=new Telem[maxlen]; for(int i=0;i数据结构实验,多项式计算器实验题目：多项式运算器 实验内容：1、熟悉编程环境 2、用链式存储结构实现稀疏一元多项式运算器 实验目的和要求： 1、通过本实验，掌握VC++6.0的基本使用，包括源程序的输入，编译运行及调 试。调试的目的是找程序的运行错误，通过DEBUG菜单设置断点实现。 2、用链式存储结构实现一元多项式的运算。 熟练掌握指针和链表的基本操作，利用菜单进行功能选择。 功能基本要求：创建、显示、求和、求差、求值、销毁、清空、修改 实验算法： 1、数据结构描述： 输入的稀疏每一个多项式用一个链表存储，链表的每一个节点存储多项式的一个非零项。定义为LNode型结构体，其中保存该项的系数和指数。主 函数中用一个数组存储每一个多项式的第一项的头指针以调用多项式。 2、函数和算法描述： 主函数main定义LNode*数组a[]存储每一个多项式头节点的地址，并构建菜单以选择调用函数进行多项式的操作，对多项式进行操作的函数返回新 改动的多项式头结点地址。 Createpolyn函数用以创建一个多项式，在用户输入结束指令之前，不断的申请空间，构建LNode型结点并加至构建的链表的表尾，输入结束指令之 后，表尾设NULL并返回表头指针。 Printpolyn函数用以在屏幕上打印多项式，接收需要打印的多项式链表的头结点，构造循环体在表尾之前，不断以mx^n格式打印对应结点中的数 据。 Copypolyn函数用以复制多项式，接收需要复制的多项式a和复制位置b 的指针，构造循环体，在a到表尾之前循环，在b对应的链表中构建新的结 点，结点上的数据赋值为a中对应的值，返回b的头结点地址。 Addpolyn函数用以求两个已知多项式a、b的和存入c，先构建循环体，在a、b链表都未进行到表尾时，比较两个结点中的次数值，如果相同，将 系数相加赋于c的当前结点，如果不同，将次数较小多项式y（a或b）的结 点赋值给c当前结点，在将y链表向后推。 Subtract函数用以求两多项式的差，类似求和算法。 Value函数用以求一个多项式的值，接收x的值，构建循环体，在表尾之前循环以遍历多项式链表。内置循环体，以次数n为限循环，求出x^n的 值，乘以系数并将每一项的值叠加得值。 Destroypolyn函数用以销毁已有的多项式，将此多项式链表的空间FREE 掉，返回空指针。 Clearpolyn函数用以清空多项式，构建循环体，将多项式的各项的系数、指数置零。 3、时空分析： L= sizeof(struct LNode) 一个含有N项的多项式占用的储存空间为NL+1[计算机]一元多项式相加完整实验报告[计算机]一元多项式相加完整实验报告一元多项式的相加 一实验内容 根据所学的数据结构中线性结构(线性表)的逻辑特性和物理特性及相关算法，应用于求解一个具体的实际问题----------两个多项式相加 二需求分析 1掌握线性结构的逻辑特性和物理特性。 2建立一元多项式。 3将一元多项式输入，并存储在内存中，并按照指数降序排列输出多项式。 4能够完成两个多项式的加减运算，并输出结果。 三概要设计 1 本程序所用到的抽象数据类型: typedef OrderedLinkList polynomial; // 用带表头结点的有序链表表示多项式 结点的数据元素类型定义为: typedef struct { // 项的表示 oat flcoef; // 系数 int expn; // 指数 term, ElemType; Void AddPolyn(polynomail&Pa,polynomail&Pb) Position GetHead() Position NextPos(LinkList L,Link p) Elem GetCurElem(Link p) int cmp(term a term b)Status SetCurElem(Link&p, ElemType e) Status DelFirst(Link h, Link &q) Status ListEmpty(LinkList L) Status Append(LinkList&L, Link S) FreeNode() 2 存储结构 一元多项式的表示在计算机内用链表来实现，同时为了节省存储空间，只存储其中非零的项，链表中的每个节点存放多项式的系数非零项。它包含三个域，分别存放多项式的系数，指数，以及指向下一个项的指针。 序数coef 指数exp 指针域next 创建一元多项式链表，对运算中可能出现的各种情况进行分析，实现一元多项式的相加相减操作。 3 模块划分 a) 主程序;2)初始化单链表;3)建立单链表; 4)相加多项式 4 主程序流程图 开始 申请结点空间 输入多项式各项的系数X，指数Y 输出已输出的多项式 否 是否输入正确 合并同类项 结束 四详细设计 根据一元多项式相加的运算规则:对于两个一元多项式中所有指数相用C语言实现多项式简单计算器的设计武汉理工大学华夏学院课程设计报告书 课程名称：数据结构 题目：用C语言实现多项式简单计算器的设计 系名：信息工程系 专业班级：软件工程1121班 姓名：邓燕蓉 指导教师:王绪梅 2013 年 6月 28日课程设计任务书 学生姓名：邓燕蓉专业班级：软件工程1121班 指导教师：王绪梅工作单位：华夏学院计算机教研室设计题目：用C语言实现多项式简单计算器的设计 设计目的 1.巩固和加深课堂所学知识、学会分析研究数据对象的特性及数据的组织方法； 2.选择合适的数据的逻辑结构和存储结构以及相应操作，实现简单的多项式计算； 3.提高程序设计能力、加强查阅、运用资料的能力、算法分析与程序设计素质培养； 设计任务（在规定的时间内完成下列任务） 〔问题描述〕输入并建立两个多项式并输出多项式 设计一个程序：对两个多项式进行加、减法及乘法运算,建立一个新多项式并输出. 或设计一个程序对其中一个多项式求导。 〔实现提示〕 选择带头结点的单链表或循环链表存储多项式,头结点中存放多项式的参数及单链表的数据具体要完成的任务是： A.编制完成上述问题的C语言程序、进行程序调试并能得出正确的运行结果。 B.写出规范的课程设计报告书； 时间安排：6月24日---28日 具体要求 1. 课程设计报告按统一通用格式书写，具体内容如下： ①设计任务与要求 ②总体方案与说明 ③软件主要模块的流程图 ④源程序清单与注释 ⑤问题分析与解决方案（包括调式记录、调式报告，即在调式过程中遇到的主要问题、解决方法 及改进设想）； ⑥小结与体会 附录：①源程序（必须有简单注释）②使用说明③参考资料 2.每位学生应独立完成各自的任务且每天至少在设计室工作半天； 指导教师签名：王绪梅2013 年6月22日 教研室主任（或责任教师）签名：2013年6月24日数据结构实验报告-一元多项式数据结构课程设计报告 课题: 一元多项式 姓名： XX 学号： 201417030218 专业班级： XXXX 指导教师： XXXX 设计时间： 2015年12月30日星期三目录 一、任务目标 (3) 二、概要设计 (4) 三、详细设计 (6) 四、调试分析 (8) 五、源程序代码 (8) 六、程序运行效果图与说明 (15) 七、本次实验小结 (16) 八、参考文献 (16)一丶任务目标 分析 (1) a.能够按照指数降序排列建立并输出多项式 b.能够完成两个多项式的相加，相减，并将结果输入 要求：程序所能达到的功能： a.实现一元多项式的输入； b.实现一元多项式的输出； c.计算两个一元多项式的和并输出结果； d.计算两个一元多项式的差并输出结果； 除任务要求外新增乘法： 计算两个一元多项式的乘积并输出结果 （2）输入的形式和输入值的范围： 输入要求：分行输入，每行输入一项，先输入多项式的指数，再输入多项式的系数，以0 0为结束标志，结束一个多项式的输入。 输入形式： 2 3 -1 2 3 0 1 2 0 0 输入值的范围：系数为int型，指数为float型 （3）输出的形式： 第一行输出多项式1； 第二行输出多项式2； 第三行输出多项式1与多项式2相加的结果多项式； 第四行输出多项式1与多项式2相减的结果多项式； 第五行输出多项式1与多项式2相乘的结果多项式二、概要设计 程序实现 a. 功能：将要进行运算的二项式输入输出； b. 数据流入：要输入的二项式的系数与指数； c. 数据流出：合并同类项后的二项式； d. 程序流程图：二项式输入流程图； e. 测试要点：输入的二项式是否正确，若输入错误则重新输入。一元多项式计算器设计与实现一元稀疏多项式简单计算器 一、设计课题 设计一元稀疏多项式简单计算器。 二、需求分析 2.1 输入的形式和输入值的范围： 输入是从键盘输入的，输入的内容为多项式的系数和指数，数为任意的整数，指数为大于等于0的整数 2.2 输出的形式 从屏幕输出，显示用户输入的多项式，并显示多项式加减以后的多项式的值。 2.3 程序所能达到的功能 a：输入并建立多项式； b：输出多项式，输出形式为整数序列：n,c1,e1,c2,e2,……,cn,en,其中n是多项式的项数，ci和ei 分别是第i项的系数和指数，序列按指数降序排列； c：多项式a和b相加，建立多项式a+b； d：多项式a和b相减，建立多项式a-b； 2.4 测试数据 （1）(2x+5x^8-3.1x^11)+(7-5x^8+11x^9) = (-3.1x^11+11X^9+2X+7) （2）(X+X^3)+(-X-X^3)=0 （3）(X+X^2+X^3)+0= X+X^2+X^3 三、概要设计 3.1 设计思路 A：数据结构的选用 为了实现任意多项式的加法、减法，因此选择单链表的结构体，它有一个系数，指数，下一个指针3个元属；单链表抽象结构类型定义见附录2。 B：多项式的输入 采用头节点插法的方式，输入多项式中一个项的系数和指数，就产生一个新的节点，建立起它的右指针，并用头节点指向它；为了判断一个多项式是否输入结束，定义一个结束标志，当输入非00时就继续，当输入00时，就结束一个多项式的输入； C：2个多项式的加法 它从2个多项式的头部开始，2个多项式的某一项都不为空时，如果指数相等的话，系数就应该相加；相加的和不为0的话，用头插法建立一个新的节点。p的系数小于q的系数的话，就应该复制q接点到多项式中。p的系数大于q的系数的话，就应该复制p接点到多项式中。当第2个多项式空，第1个数不为空时，将第一个数剩下的全用新节点产生。当第1个多项式空，第1个数不为空时，将第2个数剩下的全用新节点产生 D：2个多项式的减法 它从2个多项式的头部开始，2个多项式的某一项都不为空时，如果指数相等的话，系数就应该相减；相加的和不为0的话，用头插法建立一个新的节点。 p的系数小于q的系数的话，就应该复制q接点到多项式中。p的系数大于q的系数的话，就应该复制p接点到多项式中，并且建立的接点的系数为原来的相反数；当第2个多项式空，第1个数不为空时，将第一个数剩下的全用新节点产生。当第1个多项式空，第1个数不为空时，将第2个数剩下的全用新节点产生，并且建立的接点的系数为原来的相反数。
【问题描述】 设计一个一元稀疏多项式简单计算器 【基本要求】 一元多项式简单计算器的基本功能是： 1，输入并建立多项式; 2，输出多项式，输出形式为整数序列:n,c1,e1,c2,c2,...,cn,en,其中n是多项式的项数，ci和ei分别是第i项的系数和指数，序列按指数降序排列; 3,多项式a和b相加，建立多项式a+b; 4,多项式a和b相减，建立多项式a-b. 【测试数据】 1，(2x+5x^8-3.1x^11)+(7-5x^8+11x^9)=(-3.1x^11+11x^9+2x+7) 【实现提示】 用带表头结点的单链表存储多项式。 #include #include typedef struct node { float coef; int expn; struct node *next; }Lnode, *polynmial; void create(polynmial &L); //输入并建立多项式L void display(polynmial L); //显示，输出多项式L void 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，结果给Ld void 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; } }
一元多项式相加实验报告 一元多项式的相加
一实验内容 根据所学的数据结构中线性结构（线性表）的逻辑特性和物理特性及相关算法，应用于求解一个具体的实际问题----------两个多项式相加 二需求分析 1掌握线性结构的逻辑特性和物理特性。 2建立一元多项式。 3将一元多项式输入，并存储在内存中，并按照指数降序排列输出多项式。 4能够完成两个多项式的加减运算，并输出结果。 三概要设计 1 本程序所用到的抽象数据类型： typedef OrderedLinkList polynomial; // 用带表头结点的有序链表表示多项式 结点的数据元素类型定义为: typedef struct { // 项的表示 float coef; // 系数 int expn; // 指数 term, ElemType; V oid AddPolyn(polynomail&Pa,polynomail&Pb) Position GetHead() Position NextPos(LinkList L,Link p) Elem GetCurElem(Link p) int cmp(term a term b) Status SetCurElem(Link&p, ElemType e) Status DelFirst(Link h, Link &q) Status ListEmpty(LinkList L) Status Append(LinkList&L, Link S) FreeNode() 2 存储结构
一元多项式的表示在计算机内用链表来实现，同时为了节省存储空间，只存储其中非零的项，链表中的每个节点存放多项式的系数非零项。它包含三个域，分别存放多项式的系数，指数，以及指向下一个项的指针。 创建一元多项式链表，对运算中可能出现的各种情况进行分析，实现一元多项式的相加相减操作。 3 模块划分 a) 主程序；2）初始化单链表；3）建立单链表； 4）相加多项式 4 主程序流程图 四详细设计 根据一元多项式相加的运算规则：对于两个一元多项式中所有指数相同的项，对应系数相加，若其和不为零，则构成“和多项式”中的一项，对
一元稀疏多项式计数器预习报告 姓名：刘茂学号2220 一、实验要求 (1)输入并建立多项式； (2)输出多项式，输出形式为整数序列：n，c1，e1，c2，e2……cn，en，其中n是多项式的项数，ci，ei分别为第i项的系数和指数。序列按指数降序排列； (3)多项式a和b相加，建立多项式a+b； (4)多项式a和b相减，建立多项式a-b。 （5）多项式求值； （6）多项式求导； （7）求多项式的乘积。 二、测试数据： 1、(2x+5x^^11)+(7-5x^8+11x^9)=^11+11x^9+2x+7); 2、(6x^-3-x+^^9+^9)-(-6x^-3+^2-x^2+^15 )=^^9+12x^-3-x); 3、(1+x+x^2+x^3+x^4+x^5)+(-x^3-x^4)=(1+x+x^2+x^5); 4、(x+x^3)+(-x-x^3)=0; 5、(x+x^100)+(x^100+x^200)=(x+2x^100+x^200); 6、(x+x^2+x^3)+0=x+x^2+x^3. 7、互换上述测试数据中的前后两个多项式。 三、思路分析 用带表头结点的单链表存储多项式。 本程序要求输入并建立多项式，能够降幂显示出多项式，实现多项式相加相减的计算问题，输出结果。
采用链表的方式存储链表，定义结点结构体。运用尾差法建立两条单链表，以单链表polyn p和polyn h分别表示两个一元多项式a和b。 为实现处理，设p、q分别指向单链表polya和polyb的当前项，比较p、q 结点的指数项。 ① 若p->expnexpn，则结点p所指的结点应是“和多项式”中的一项，令指针p后移。 ② 若p->expn=q->expn，则将两个结点中的系数相加，当和不为0时修改结点p的系数。 ③ 若p->expn>q->expn，则结点q所指的结点应是“和多项式”中的一项，将结点q插入在结点p之前，且令指针q在原来的链表上后移。 四、实验程序 //头文件 #include<> #include<> #include<> //定义多项式的项 typedef struct Polynomial{ float coef; int expn; struct Polynomial *next; }*Polyn,Polynomial; void Insert(Polyn p,Polyn h){ if(p->coef==0) free(p);//系数为0的话释放结点 else
院系：计算机科学学院 专业：软件工程 年级： 2013级 课程名称：数据结构 姓名：韦宜（201321092034）指导教师：宋中山 2015年 12 月 15日
题目：设计一个一元稀疏多项式简单计算器 班级：软件工程1301 姓名：韦宜学号：201321092034 完成日期：12月15日 一、需求分析 问题描述：设计一个一元多项式加法器 基本要求： 输入并建立多项式； (2)两个多项式相加； (3)输出多项式：n, c1, e1, c2, e2, …cn , en, 其中，n是多项式项数，ci和ei分别是第i 项的系数和指数，序列按指数降序排列。 (4)计算多项式在x处的值； (5)求多项式的导函数。 软件环境：Windows，UNIX，Linux等不同平台下的Visual C++ 6.0 硬件环境: 512MB内存,80Gb硬盘,Pentium4 CPU,CRT显示器。
二、概要分析 本程序有五个函数： PolyNode *Input()(输入函数)； PolyNode *Deri(PolyNode *head)（求导函数）； PolyNode * Plus(PolyNode *A,PolyNode *B)（求和函数）； void Output(PolyNode*head)（输出函数）； int main()（主函数） 本程序可使用带有附加头结点的单链表来实现多项式的链表表示，每个链表结点表示多项式的一项，命名为node，它包括两个数据成员：系数coef和指数exp，他们都是公共数据成员，*next为指针域，用链表来表示多项式。适用于不定的多项式，特别是对于项数再运算过程中动态增长的多项式，不存在存储溢出的问题。其次，对于某些零系数项，在执行加法运算后不再是零系数项，这就需要在结果多项式中增添新的项；对于某些非零系数项，在执行加法运算后可能是零系数项，这就需要在结果多项式中删去这些项，利用链表操作，可以简单的修改结点的指针以完成这种插入和删除运算（不像在顺序方式中那样，可能移动大量数据项）运行效率高。
数据结构课程设计实验报告 专业班级： 学号： 姓名： 2011年1月1日
题目：一元多项式的运算 1、题目描述 一元多项式的运算在此题中实现加、减法的运算，而多项式的减法可以通过加法来实现（只需在减法运算时系数前加负号）。 在数学上，一个一元n次多项式P n(X)可按降序写成： P n(X)= P n X^n+ P(n-1)X^(n-1)+......+ P1X+P0 它由n+1个系数惟一确定，因此，在计算机里它可以用一个线性表P来表示： P=(P n，P(n-1)，......，P1，P0) 每一项的指数i隐含在其系数P i的序号里。 假设Q m(X)是一元m次多项式，同样可以用一个线性表Q来表示： Q=(q m,q(m-1)，.....，q1，q0) 不是一般性，假设吗吗m一元稀疏多项式的加法运算(数据结构实习)实习一线性表、栈和队列及其应用 ——一元稀疏多项式的加法运算 【问题描述】 设计一个实现一元稀疏多项式相加运算的演示程序。 【基本要求】 （1）输入并建立两个多项式； （2）多项式a与b相加，建立和多项式c； （3）输出多项式a,b,c。输出格式：比如多项式a为：A(x)=c1xe1+ c2xe2+…+ cmxem，其中，ci和ei分别为第i项的系数和指数，且各项按 指数的升幂排列，即0≤e1＜e2＜…＜em。多项式b,c类似输出。 【测试数据】 （1）(1+x+x2+x3+x4+x5)+(-x3-x4)=(1+x+x2+x5) （2）(x+x100)+(x100+x200)=(x+2x100+x200) （3）(2x+5x8-3x11)+(7-5x8+11x9)=(7+2x+11x9-3x11) 一．需求分析 1.输入的形式和输入值的范围： 输入是从键盘输入的，输入的内容为多项式的系数和指数，其中多项式的每一项分别以一个系数和指数的形式输入，不带未知数X，系数为任意的实数，指数为任意的整数。 要结束该多项式的输入时，输入的指数和系数都为0. 2. 输出的形式 从屏幕输出，显示用户输入的多项式，并显示多项式加减以后的多项式的值，并且多项式中将未知数X表示了出来. 形式为：+c1X^e1+c2X^e2+…+ciX^ei+…(ci和ei分别是第i 项的系数和指数，序列按指数升序排列。) 当多项式的某一项的系数为+1或者-1时侧该项多项式的输出形式为X^ei或-X^ei； 当该项的系数为正时输出+ciX^ei,当为负数时则输出ciX^ei 3. 程序所能达到的功能 输入并建立多项式，实现一元稀疏多项式的相加并输出。 4. 注意：所有多项式都必须以指数升密形式输入。 5. 测试数据为（1）(1+x+x2+x3+x4+x5)+(-x3-x4)=(1+x+x2+x5) （2）(x+x100)+(x100+x200)=(x+2x100+x200) （3）(2x+5x8-3x11)+(7-5x8+11x9)=(7+2x+11x9-3x11) 二．设计 1.设计思路两个一元多项式相加-c++版《数据结构》实验报告 ——两个一元多项式相加 一、实验题目：两个一元多项式相加 二、实验内容： 根据所学的数据结构中线性结构（线性表）的逻辑特性和物理特性及相关算法，应用于求解一个具体的实际问题----------两个多项式相加 三、设计思想： （1）建立两个顺序列表，分别用来表示两个一元多项式；顺序列表奇数位，存储该多项式的系数；顺序列表的偶数位，存储该相应多项式的指数。 （2）用成员函数merg(qList&l2)实现两多项式的相加。实现的大致方法为：比较第二个多项式列表与第一个多项式列表的偶数位的数值大小（指数），如果 相同，则将他们的前一位数（系数）相加；如果不同，就将他的前一位数（系 数）及它自己（指数）插入第一个多项式列表的后面。 （3）建立函数shu(double a[],int j)实现多项式的输入。 四、源程序代码 #include "stdafx.h" #include using namespace std; template class List { private: Telem * elem; int curlen; int maxlen; public: List(int maxsz=100):maxlen(maxsz) { curlen=0; elem=new Telem{maxlen}; }; List(Telem a[],int n,int maxsz=100):maxlen(maxsz) { curlen=n; elem=new Telem[maxlen]; for(int i=0;i数据结构实验,多项式计算器实验题目：多项式运算器 实验内容：1、熟悉编程环境 2、用链式存储结构实现稀疏一元多项式运算器 实验目的和要求： 1、通过本实验，掌握VC++6.0的基本使用，包括源程序的输入，编译运行及调 试。调试的目的是找程序的运行错误，通过DEBUG菜单设置断点实现。 2、用链式存储结构实现一元多项式的运算。 熟练掌握指针和链表的基本操作，利用菜单进行功能选择。 功能基本要求：创建、显示、求和、求差、求值、销毁、清空、修改 实验算法： 1、数据结构描述： 输入的稀疏每一个多项式用一个链表存储，链表的每一个节点存储多项式的一个非零项。定义为LNode型结构体，其中保存该项的系数和指数。主 函数中用一个数组存储每一个多项式的第一项的头指针以调用多项式。 2、函数和算法描述： 主函数main定义LNode*数组a[]存储每一个多项式头节点的地址，并构建菜单以选择调用函数进行多项式的操作，对多项式进行操作的函数返回新 改动的多项式头结点地址。 Createpolyn函数用以创建一个多项式，在用户输入结束指令之前，不断的申请空间，构建LNode型结点并加至构建的链表的表尾，输入结束指令之 后，表尾设NULL并返回表头指针。 Printpolyn函数用以在屏幕上打印多项式，接收需要打印的多项式链表的头结点，构造循环体在表尾之前，不断以mx^n格式打印对应结点中的数 据。 Copypolyn函数用以复制多项式，接收需要复制的多项式a和复制位置b 的指针，构造循环体，在a到表尾之前循环，在b对应的链表中构建新的结 点，结点上的数据赋值为a中对应的值，返回b的头结点地址。 Addpolyn函数用以求两个已知多项式a、b的和存入c，先构建循环体，在a、b链表都未进行到表尾时，比较两个结点中的次数值，如果相同，将 系数相加赋于c的当前结点，如果不同，将次数较小多项式y（a或b）的结 点赋值给c当前结点，在将y链表向后推。 Subtract函数用以求两多项式的差，类似求和算法。 Value函数用以求一个多项式的值，接收x的值，构建循环体，在表尾之前循环以遍历多项式链表。内置循环体，以次数n为限循环，求出x^n的 值，乘以系数并将每一项的值叠加得值。 Destroypolyn函数用以销毁已有的多项式，将此多项式链表的空间FREE 掉，返回空指针。 Clearpolyn函数用以清空多项式，构建循环体，将多项式的各项的系数、指数置零。 3、时空分析： L= sizeof(struct LNode) 一个含有N项的多项式占用的储存空间为NL+1[计算机]一元多项式相加完整实验报告[计算机]一元多项式相加完整实验报告一元多项式的相加 一实验内容 根据所学的数据结构中线性结构(线性表)的逻辑特性和物理特性及相关算法，应用于求解一个具体的实际问题----------两个多项式相加 二需求分析 1掌握线性结构的逻辑特性和物理特性。 2建立一元多项式。 3将一元多项式输入，并存储在内存中，并按照指数降序排列输出多项式。 4能够完成两个多项式的加减运算，并输出结果。 三概要设计 1 本程序所用到的抽象数据类型: typedef OrderedLinkList polynomial; // 用带表头结点的有序链表表示多项式 结点的数据元素类型定义为: typedef struct { // 项的表示 oat flcoef; // 系数 int expn; // 指数 term, ElemType; Void AddPolyn(polynomail&Pa,polynomail&Pb) Position GetHead() Position NextPos(LinkList L,Link p) Elem GetCurElem(Link p) int cmp(term a term b)Status SetCurElem(Link&p, ElemType e) Status DelFirst(Link h, Link &q) Status ListEmpty(LinkList L) Status Append(LinkList&L, Link S) FreeNode() 2 存储结构 一元多项式的表示在计算机内用链表来实现，同时为了节省存储空间，只存储其中非零的项，链表中的每个节点存放多项式的系数非零项。它包含三个域，分别存放多项式的系数，指数，以及指向下一个项的指针。 序数coef 指数exp 指针域next 创建一元多项式链表，对运算中可能出现的各种情况进行分析，实现一元多项式的相加相减操作。 3 模块划分 a) 主程序;2)初始化单链表;3)建立单链表; 4)相加多项式 4 主程序流程图 开始 申请结点空间 输入多项式各项的系数X，指数Y 输出已输出的多项式 否 是否输入正确 合并同类项 结束 四详细设计 根据一元多项式相加的运算规则:对于两个一元多项式中所有指数相用C语言实现多项式简单计算器的设计武汉理工大学华夏学院课程设计报告书 课程名称：数据结构 题目：用C语言实现多项式简单计算器的设计 系名：信息工程系 专业班级：软件工程1121班 姓名：邓燕蓉 指导教师:王绪梅 2013 年 6月 28日课程设计任务书 学生姓名：邓燕蓉专业班级：软件工程1121班 指导教师：王绪梅工作单位：华夏学院计算机教研室设计题目：用C语言实现多项式简单计算器的设计 设计目的 1.巩固和加深课堂所学知识、学会分析研究数据对象的特性及数据的组织方法； 2.选择合适的数据的逻辑结构和存储结构以及相应操作，实现简单的多项式计算； 3.提高程序设计能力、加强查阅、运用资料的能力、算法分析与程序设计素质培养； 设计任务（在规定的时间内完成下列任务） 〔问题描述〕输入并建立两个多项式并输出多项式 设计一个程序：对两个多项式进行加、减法及乘法运算,建立一个新多项式并输出. 或设计一个程序对其中一个多项式求导。 〔实现提示〕 选择带头结点的单链表或循环链表存储多项式,头结点中存放多项式的参数及单链表的数据具体要完成的任务是： A.编制完成上述问题的C语言程序、进行程序调试并能得出正确的运行结果。 B.写出规范的课程设计报告书； 时间安排：6月24日---28日 具体要求 1. 课程设计报告按统一通用格式书写，具体内容如下： ①设计任务与要求 ②总体方案与说明 ③软件主要模块的流程图 ④源程序清单与注释 ⑤问题分析与解决方案（包括调式记录、调式报告，即在调式过程中遇到的主要问题、解决方法 及改进设想）； ⑥小结与体会 附录：①源程序（必须有简单注释）②使用说明③参考资料 2.每位学生应独立完成各自的任务且每天至少在设计室工作半天； 指导教师签名：王绪梅2013 年6月22日 教研室主任（或责任教师）签名：2013年6月24日数据结构实验报告-一元多项式数据结构课程设计报告 课题: 一元多项式 姓名： XX 学号： 201417030218 专业班级： XXXX 指导教师： XXXX 设计时间： 2015年12月30日星期三目录 一、任务目标 (3) 二、概要设计 (4) 三、详细设计 (6) 四、调试分析 (8) 五、源程序代码 (8) 六、程序运行效果图与说明 (15) 七、本次实验小结 (16) 八、参考文献 (16)一丶任务目标 分析 (1) a.能够按照指数降序排列建立并输出多项式 b.能够完成两个多项式的相加，相减，并将结果输入 要求：程序所能达到的功能： a.实现一元多项式的输入； b.实现一元多项式的输出； c.计算两个一元多项式的和并输出结果； d.计算两个一元多项式的差并输出结果； 除任务要求外新增乘法： 计算两个一元多项式的乘积并输出结果 （2）输入的形式和输入值的范围： 输入要求：分行输入，每行输入一项，先输入多项式的指数，再输入多项式的系数，以0 0为结束标志，结束一个多项式的输入。 输入形式： 2 3 -1 2 3 0 1 2 0 0 输入值的范围：系数为int型，指数为float型 （3）输出的形式： 第一行输出多项式1； 第二行输出多项式2； 第三行输出多项式1与多项式2相加的结果多项式； 第四行输出多项式1与多项式2相减的结果多项式； 第五行输出多项式1与多项式2相乘的结果多项式二、概要设计 程序实现 a. 功能：将要进行运算的二项式输入输出； b. 数据流入：要输入的二项式的系数与指数； c. 数据流出：合并同类项后的二项式； d. 程序流程图：二项式输入流程图； e. 测试要点：输入的二项式是否正确，若输入错误则重新输入。一元多项式计算器设计与实现一元稀疏多项式简单计算器 一、设计课题 设计一元稀疏多项式简单计算器。 二、需求分析 2.1 输入的形式和输入值的范围： 输入是从键盘输入的，输入的内容为多项式的系数和指数，数为任意的整数，指数为大于等于0的整数 2.2 输出的形式 从屏幕输出，显示用户输入的多项式，并显示多项式加减以后的多项式的值。 2.3 程序所能达到的功能 a：输入并建立多项式； b：输出多项式，输出形式为整数序列：n,c1,e1,c2,e2,……,cn,en,其中n是多项式的项数，ci和ei 分别是第i项的系数和指数，序列按指数降序排列； c：多项式a和b相加，建立多项式a+b； d：多项式a和b相减，建立多项式a-b； 2.4 测试数据 （1）(2x+5x^8-3.1x^11)+(7-5x^8+11x^9) = (-3.1x^11+11X^9+2X+7) （2）(X+X^3)+(-X-X^3)=0 （3）(X+X^2+X^3)+0= X+X^2+X^3 三、概要设计 3.1 设计思路 A：数据结构的选用 为了实现任意多项式的加法、减法，因此选择单链表的结构体，它有一个系数，指数，下一个指针3个元属；单链表抽象结构类型定义见附录2。 B：多项式的输入 采用头节点插法的方式，输入多项式中一个项的系数和指数，就产生一个新的节点，建立起它的右指针，并用头节点指向它；为了判断一个多项式是否输入结束，定义一个结束标志，当输入非00时就继续，当输入00时，就结束一个多项式的输入； C：2个多项式的加法 它从2个多项式的头部开始，2个多项式的某一项都不为空时，如果指数相等的话，系数就应该相加；相加的和不为0的话，用头插法建立一个新的节点。p的系数小于q的系数的话，就应该复制q接点到多项式中。p的系数大于q的系数的话，就应该复制p接点到多项式中。当第2个多项式空，第1个数不为空时，将第一个数剩下的全用新节点产生。当第1个多项式空，第1个数不为空时，将第2个数剩下的全用新节点产生 D：2个多项式的减法 它从2个多项式的头部开始，2个多项式的某一项都不为空时，如果指数相等的话，系数就应该相减；相加的和不为0的话，用头插法建立一个新的节点。 p的系数小于q的系数的话，就应该复制q接点到多项式中。p的系数大于q的系数的话，就应该复制p接点到多项式中，并且建立的接点的系数为原来的相反数；当第2个多项式空，第1个数不为空时，将第一个数剩下的全用新节点产生。当第1个多项式空，第1个数不为空时，将第2个数剩下的全用新节点产生，并且建立的接点的系数为原来的相反数。
实习一线性表、栈和队列及其应用 ——一元稀疏多项式的加法运算 【问题描述】 设计一个实现一元稀疏多项式相加运算的演示程序。 【基本要求】 （1）输入并建立两个多项式； （2）多项式a与b相加，建立和多项式c； （3）输出多项式a,b,c。输出格式：比如多项式a为：A(x)=c1xe1+ c2xe2+…+ cmxem，其中，ci和ei分别为第i项的系数和指数，且各项按 指数的升幂排列，即0≤e1＜e2＜…＜em。多项式b,c类似输出。 【测试数据】 （1）(1+x+x2+x3+x4+x5)+(-x3-x4)=(1+x+x2+x5) （2）(x+x100)+(x100+x200)=(x+2x100+x200) （3）(2x+5x8-3x11)+(7-5x8+11x9)=(7+2x+11x9-3x11) 一．需求分析 1.输入的形式和输入值的范围： 输入是从键盘输入的，输入的内容为多项式的系数和指数，其中多项式的每一项分别以一个系数和指数的形式输入，不带未知数X，系数为任意的实数，指数为任意的整数。 要结束该多项式的输入时，输入的指数和系数都为0. 2. 输出的形式 从屏幕输出，显示用户输入的多项式，并显示多项式加减以后的多项式的值，并且多项式中将未知数X表示了出来. 形式为：+c1X^e1+c2X^e2+…+ciX^ei+…(ci和ei分别是第i 项的系数和指数，序列按指数升序排列。) 当多项式的某一项的系数为+1或者-1时侧该项多项式的输出形式为X^ei或-X^ei； 当该项的系数为正时输出+ciX^ei,当为负数时则输出ciX^ei 3. 程序所能达到的功能 输入并建立多项式，实现一元稀疏多项式的相加并输出。 4. 注意：所有多项式都必须以指数升密形式输入。 5. 测试数据为（1）(1+x+x2+x3+x4+x5)+(-x3-x4)=(1+x+x2+x5) （2）(x+x100)+(x100+x200)=(x+2x100+x200) （3）(2x+5x8-3x11)+(7-5x8+11x9)=(7+2x+11x9-3x11) 二．设计 1.设计思路
《数据结构》实验报告 ——两个一元多项式相加 一、实验题目：两个一元多项式相加 二、实验内容： 根据所学的数据结构中线性结构（线性表）的逻辑特性和物理特性及相关算法，应用于求解一个具体的实际问题----------两个多项式相加 三、设计思想： （1）建立两个顺序列表，分别用来表示两个一元多项式；顺序列表奇数位，存储该多项式的系数；顺序列表的偶数位，存储该相应多项式的指数。 （2）用成员函数merg(qList&l2)实现两多项式的相加。实现的大致方法为：比较第二个多项式列表与第一个多项式列表的偶数位的数值大小（指数），如果 相同，则将他们的前一位数（系数）相加；如果不同，就将他的前一位数（系 数）及它自己（指数）插入第一个多项式列表的后面。 （3）建立函数shu(double a[],int j)实现多项式的输入。 四、源程序代码 #include "stdafx.h" #include using namespace std; template class List { private: Telem * elem; int curlen; int maxlen; public: List(int maxsz=100):maxlen(maxsz) { curlen=0; elem=new Telem{maxlen}; }; List(Telem a[],int n,int maxsz=100):maxlen(maxsz) { curlen=n; elem=new Telem[maxlen]; for(int i=0;i数据结构实验,多项式计算器实验题目：多项式运算器 实验内容：1、熟悉编程环境 2、用链式存储结构实现稀疏一元多项式运算器 实验目的和要求： 1、通过本实验，掌握VC++6.0的基本使用，包括源程序的输入，编译运行及调 试。调试的目的是找程序的运行错误，通过DEBUG菜单设置断点实现。 2、用链式存储结构实现一元多项式的运算。 熟练掌握指针和链表的基本操作，利用菜单进行功能选择。 功能基本要求：创建、显示、求和、求差、求值、销毁、清空、修改 实验算法： 1、数据结构描述： 输入的稀疏每一个多项式用一个链表存储，链表的每一个节点存储多项式的一个非零项。定义为LNode型结构体，其中保存该项的系数和指数。主 函数中用一个数组存储每一个多项式的第一项的头指针以调用多项式。 2、函数和算法描述： 主函数main定义LNode*数组a[]存储每一个多项式头节点的地址，并构建菜单以选择调用函数进行多项式的操作，对多项式进行操作的函数返回新 改动的多项式头结点地址。 Createpolyn函数用以创建一个多项式，在用户输入结束指令之前，不断的申请空间，构建LNode型结点并加至构建的链表的表尾，输入结束指令之 后，表尾设NULL并返回表头指针。 Printpolyn函数用以在屏幕上打印多项式，接收需要打印的多项式链表的头结点，构造循环体在表尾之前，不断以mx^n格式打印对应结点中的数 据。 Copypolyn函数用以复制多项式，接收需要复制的多项式a和复制位置b 的指针，构造循环体，在a到表尾之前循环，在b对应的链表中构建新的结 点，结点上的数据赋值为a中对应的值，返回b的头结点地址。 Addpolyn函数用以求两个已知多项式a、b的和存入c，先构建循环体，在a、b链表都未进行到表尾时，比较两个结点中的次数值，如果相同，将 系数相加赋于c的当前结点，如果不同，将次数较小多项式y（a或b）的结 点赋值给c当前结点，在将y链表向后推。 Subtract函数用以求两多项式的差，类似求和算法。 Value函数用以求一个多项式的值，接收x的值，构建循环体，在表尾之前循环以遍历多项式链表。内置循环体，以次数n为限循环，求出x^n的 值，乘以系数并将每一项的值叠加得值。 Destroypolyn函数用以销毁已有的多项式，将此多项式链表的空间FREE 掉，返回空指针。 Clearpolyn函数用以清空多项式，构建循环体，将多项式的各项的系数、指数置零。 3、时空分析： L= sizeof(struct LNode) 一个含有N项的多项式占用的储存空间为NL+1[计算机]一元多项式相加完整实验报告[计算机]一元多项式相加完整实验报告一元多项式的相加 一实验内容 根据所学的数据结构中线性结构(线性表)的逻辑特性和物理特性及相关算法，应用于求解一个具体的实际问题----------两个多项式相加 二需求分析 1掌握线性结构的逻辑特性和物理特性。 2建立一元多项式。 3将一元多项式输入，并存储在内存中，并按照指数降序排列输出多项式。 4能够完成两个多项式的加减运算，并输出结果。 三概要设计 1 本程序所用到的抽象数据类型: typedef OrderedLinkList polynomial; // 用带表头结点的有序链表表示多项式 结点的数据元素类型定义为: typedef struct { // 项的表示 oat flcoef; // 系数 int expn; // 指数 term, ElemType; Void AddPolyn(polynomail&Pa,polynomail&Pb) Position GetHead() Position NextPos(LinkList L,Link p) Elem GetCurElem(Link p) int cmp(term a term b)Status SetCurElem(Link&p, ElemType e) Status DelFirst(Link h, Link &q) Status ListEmpty(LinkList L) Status Append(LinkList&L, Link S) FreeNode() 2 存储结构 一元多项式的表示在计算机内用链表来实现，同时为了节省存储空间，只存储其中非零的项，链表中的每个节点存放多项式的系数非零项。它包含三个域，分别存放多项式的系数，指数，以及指向下一个项的指针。 序数coef 指数exp 指针域next 创建一元多项式链表，对运算中可能出现的各种情况进行分析，实现一元多项式的相加相减操作。 3 模块划分 a) 主程序;2)初始化单链表;3)建立单链表; 4)相加多项式 4 主程序流程图 开始 申请结点空间 输入多项式各项的系数X，指数Y 输出已输出的多项式 否 是否输入正确 合并同类项 结束 四详细设计 根据一元多项式相加的运算规则:对于两个一元多项式中所有指数相用C语言实现多项式简单计算器的设计武汉理工大学华夏学院课程设计报告书 课程名称：数据结构 题目：用C语言实现多项式简单计算器的设计 系名：信息工程系 专业班级：软件工程1121班 姓名：邓燕蓉 指导教师:王绪梅 2013 年 6月 28日课程设计任务书 学生姓名：邓燕蓉专业班级：软件工程1121班 指导教师：王绪梅工作单位：华夏学院计算机教研室设计题目：用C语言实现多项式简单计算器的设计 设计目的 1.巩固和加深课堂所学知识、学会分析研究数据对象的特性及数据的组织方法； 2.选择合适的数据的逻辑结构和存储结构以及相应操作，实现简单的多项式计算； 3.提高程序设计能力、加强查阅、运用资料的能力、算法分析与程序设计素质培养； 设计任务（在规定的时间内完成下列任务） 〔问题描述〕输入并建立两个多项式并输出多项式 设计一个程序：对两个多项式进行加、减法及乘法运算,建立一个新多项式并输出. 或设计一个程序对其中一个多项式求导。 〔实现提示〕 选择带头结点的单链表或循环链表存储多项式,头结点中存放多项式的参数及单链表的数据具体要完成的任务是： A.编制完成上述问题的C语言程序、进行程序调试并能得出正确的运行结果。 B.写出规范的课程设计报告书； 时间安排：6月24日---28日 具体要求 1. 课程设计报告按统一通用格式书写，具体内容如下： ①设计任务与要求 ②总体方案与说明 ③软件主要模块的流程图 ④源程序清单与注释 ⑤问题分析与解决方案（包括调式记录、调式报告，即在调式过程中遇到的主要问题、解决方法 及改进设想）； ⑥小结与体会 附录：①源程序（必须有简单注释）②使用说明③参考资料 2.每位学生应独立完成各自的任务且每天至少在设计室工作半天； 指导教师签名：王绪梅2013 年6月22日 教研室主任（或责任教师）签名：2013年6月24日数据结构实验报告-一元多项式数据结构课程设计报告 课题: 一元多项式 姓名： XX 学号： 201417030218 专业班级： XXXX 指导教师： XXXX 设计时间： 2015年12月30日星期三目录 一、任务目标 (3) 二、概要设计 (4) 三、详细设计 (6) 四、调试分析 (8) 五、源程序代码 (8) 六、程序运行效果图与说明 (15) 七、本次实验小结 (16) 八、参考文献 (16)一丶任务目标 分析 (1) a.能够按照指数降序排列建立并输出多项式 b.能够完成两个多项式的相加，相减，并将结果输入 要求：程序所能达到的功能： a.实现一元多项式的输入； b.实现一元多项式的输出； c.计算两个一元多项式的和并输出结果； d.计算两个一元多项式的差并输出结果； 除任务要求外新增乘法： 计算两个一元多项式的乘积并输出结果 （2）输入的形式和输入值的范围： 输入要求：分行输入，每行输入一项，先输入多项式的指数，再输入多项式的系数，以0 0为结束标志，结束一个多项式的输入。 输入形式： 2 3 -1 2 3 0 1 2 0 0 输入值的范围：系数为int型，指数为float型 （3）输出的形式： 第一行输出多项式1； 第二行输出多项式2； 第三行输出多项式1与多项式2相加的结果多项式； 第四行输出多项式1与多项式2相减的结果多项式； 第五行输出多项式1与多项式2相乘的结果多项式二、概要设计 程序实现 a. 功能：将要进行运算的二项式输入输出； b. 数据流入：要输入的二项式的系数与指数； c. 数据流出：合并同类项后的二项式； d. 程序流程图：二项式输入流程图； e. 测试要点：输入的二项式是否正确，若输入错误则重新输入。一元多项式计算器设计与实现一元稀疏多项式简单计算器 一、设计课题 设计一元稀疏多项式简单计算器。 二、需求分析 2.1 输入的形式和输入值的范围： 输入是从键盘输入的，输入的内容为多项式的系数和指数，数为任意的整数，指数为大于等于0的整数 2.2 输出的形式 从屏幕输出，显示用户输入的多项式，并显示多项式加减以后的多项式的值。 2.3 程序所能达到的功能 a：输入并建立多项式； b：输出多项式，输出形式为整数序列：n,c1,e1,c2,e2,……,cn,en,其中n是多项式的项数，ci和ei 分别是第i项的系数和指数，序列按指数降序排列； c：多项式a和b相加，建立多项式a+b； d：多项式a和b相减，建立多项式a-b； 2.4 测试数据 （1）(2x+5x^8-3.1x^11)+(7-5x^8+11x^9) = (-3.1x^11+11X^9+2X+7) （2）(X+X^3)+(-X-X^3)=0 （3）(X+X^2+X^3)+0= X+X^2+X^3 三、概要设计 3.1 设计思路 A：数据结构的选用 为了实现任意多项式的加法、减法，因此选择单链表的结构体，它有一个系数，指数，下一个指针3个元属；单链表抽象结构类型定义见附录2。 B：多项式的输入 采用头节点插法的方式，输入多项式中一个项的系数和指数，就产生一个新的节点，建立起它的右指针，并用头节点指向它；为了判断一个多项式是否输入结束，定义一个结束标志，当输入非00时就继续，当输入00时，就结束一个多项式的输入； C：2个多项式的加法 它从2个多项式的头部开始，2个多项式的某一项都不为空时，如果指数相等的话，系数就应该相加；相加的和不为0的话，用头插法建立一个新的节点。p的系数小于q的系数的话，就应该复制q接点到多项式中。p的系数大于q的系数的话，就应该复制p接点到多项式中。当第2个多项式空，第1个数不为空时，将第一个数剩下的全用新节点产生。当第1个多项式空，第1个数不为空时，将第2个数剩下的全用新节点产生 D：2个多项式的减法 它从2个多项式的头部开始，2个多项式的某一项都不为空时，如果指数相等的话，系数就应该相减；相加的和不为0的话，用头插法建立一个新的节点。 p的系数小于q的系数的话，就应该复制q接点到多项式中。p的系数大于q的系数的话，就应该复制p接点到多项式中，并且建立的接点的系数为原来的相反数；当第2个多项式空，第1个数不为空时，将第一个数剩下的全用新节点产生。当第1个多项式空，第1个数不为空时，将第2个数剩下的全用新节点产生，并且建立的接点的系数为原来的相反数。
实验题目：多项式运算器 实验内容：1、熟悉编程环境 2、用链式存储结构实现稀疏一元多项式运算器 实验目的和要求： 1、通过本实验，掌握VC++6.0的基本使用，包括源程序的输入，编译运行及调 试。调试的目的是找程序的运行错误，通过DEBUG菜单设置断点实现。 2、用链式存储结构实现一元多项式的运算。 熟练掌握指针和链表的基本操作，利用菜单进行功能选择。 功能基本要求：创建、显示、求和、求差、求值、销毁、清空、修改 实验算法： 1、数据结构描述： 输入的稀疏每一个多项式用一个链表存储，链表的每一个节点存储多项式的一个非零项。定义为LNode型结构体，其中保存该项的系数和指数。主 函数中用一个数组存储每一个多项式的第一项的头指针以调用多项式。 2、函数和算法描述： 主函数main定义LNode*数组a[]存储每一个多项式头节点的地址，并构建菜单以选择调用函数进行多项式的操作，对多项式进行操作的函数返回新 改动的多项式头结点地址。 Createpolyn函数用以创建一个多项式，在用户输入结束指令之前，不断的申请空间，构建LNode型结点并加至构建的链表的表尾，输入结束指令之 后，表尾设NULL并返回表头指针。 Printpolyn函数用以在屏幕上打印多项式，接收需要打印的多项式链表的头结点，构造循环体在表尾之前，不断以mx^n格式打印对应结点中的数 据。 Copypolyn函数用以复制多项式，接收需要复制的多项式a和复制位置b 的指针，构造循环体，在a到表尾之前循环，在b对应的链表中构建新的结 点，结点上的数据赋值为a中对应的值，返回b的头结点地址。 Addpolyn函数用以求两个已知多项式a、b的和存入c，先构建循环体，在a、b链表都未进行到表尾时，比较两个结点中的次数值，如果相同，将 系数相加赋于c的当前结点，如果不同，将次数较小多项式y（a或b）的结 点赋值给c当前结点，在将y链表向后推。 Subtract函数用以求两多项式的差，类似求和算法。 Value函数用以求一个多项式的值，接收x的值，构建循环体，在表尾之前循环以遍历多项式链表。内置循环体，以次数n为限循环，求出x^n的 值，乘以系数并将每一项的值叠加得值。 Destroypolyn函数用以销毁已有的多项式，将此多项式链表的空间FREE 掉，返回空指针。 Clearpolyn函数用以清空多项式，构建循环体，将多项式的各项的系数、指数置零。 3、时空分析： L= sizeof(struct LNode) 一个含有N项的多项式占用的储存空间为NL+1
[计算机]一元多项式相加完整实验报告一元多项式的相加 一实验内容 根据所学的数据结构中线性结构(线性表)的逻辑特性和物理特性及相关算法，应用于求解一个具体的实际问题----------两个多项式相加 二需求分析 1掌握线性结构的逻辑特性和物理特性。 2建立一元多项式。 3将一元多项式输入，并存储在内存中，并按照指数降序排列输出多项式。 4能够完成两个多项式的加减运算，并输出结果。 三概要设计 1 本程序所用到的抽象数据类型: typedef OrderedLinkList polynomial; // 用带表头结点的有序链表表示多项式 结点的数据元素类型定义为: typedef struct { // 项的表示 oat flcoef; // 系数 int expn; // 指数 term, ElemType; Void AddPolyn(polynomail&Pa,polynomail&Pb) Position GetHead() Position NextPos(LinkList L,Link p) Elem GetCurElem(Link p) int cmp(term a term b)
Status SetCurElem(Link&p, ElemType e) Status DelFirst(Link h, Link &q) Status ListEmpty(LinkList L) Status Append(LinkList&L, Link S) FreeNode() 2 存储结构 一元多项式的表示在计算机内用链表来实现，同时为了节省存储空间，只存储其中非零的项，链表中的每个节点存放多项式的系数非零项。它包含三个域，分别存放多项式的系数，指数，以及指向下一个项的指针。 序数coef 指数exp 指针域next 创建一元多项式链表，对运算中可能出现的各种情况进行分析，实现一元多项式的相加相减操作。 3 模块划分 a) 主程序;2)初始化单链表;3)建立单链表; 4)相加多项式 4 主程序流程图 开始 申请结点空间 输入多项式各项的系数X，指数Y 输出已输出的多项式 否 是否输入正确 合并同类项 结束 四详细设计 根据一元多项式相加的运算规则:对于两个一元多项式中所有指数相
武汉理工大学华夏学院课程设计报告书 课程名称：数据结构 题目：用C语言实现多项式简单计算器的设计 系名：信息工程系 专业班级：软件工程1121班 姓名：邓燕蓉 指导教师:王绪梅 2013 年 6月 28日
课程设计任务书 学生姓名：邓燕蓉专业班级：软件工程1121班 指导教师：王绪梅工作单位：华夏学院计算机教研室设计题目：用C语言实现多项式简单计算器的设计 设计目的 1.巩固和加深课堂所学知识、学会分析研究数据对象的特性及数据的组织方法； 2.选择合适的数据的逻辑结构和存储结构以及相应操作，实现简单的多项式计算； 3.提高程序设计能力、加强查阅、运用资料的能力、算法分析与程序设计素质培养； 设计任务（在规定的时间内完成下列任务） 〔问题描述〕输入并建立两个多项式并输出多项式 设计一个程序：对两个多项式进行加、减法及乘法运算,建立一个新多项式并输出. 或设计一个程序对其中一个多项式求导。 〔实现提示〕 选择带头结点的单链表或循环链表存储多项式,头结点中存放多项式的参数及单链表的数据具体要完成的任务是： A.编制完成上述问题的C语言程序、进行程序调试并能得出正确的运行结果。 B.写出规范的课程设计报告书； 时间安排：6月24日---28日 具体要求 1. 课程设计报告按统一通用格式书写，具体内容如下： ①设计任务与要求 ②总体方案与说明 ③软件主要模块的流程图 ④源程序清单与注释 ⑤问题分析与解决方案（包括调式记录、调式报告，即在调式过程中遇到的主要问题、解决方法 及改进设想）； ⑥小结与体会 附录：①源程序（必须有简单注释）②使用说明③参考资料 2.每位学生应独立完成各自的任务且每天至少在设计室工作半天； 指导教师签名：王绪梅2013 年6月22日 教研室主任（或责任教师）签名：2013年6月24日
数据结构课程设计报告 课题: 一元多项式 姓名： XX 学号： 201417030218 专业班级： XXXX 指导教师： XXXX 设计时间： 2015年12月30日星期三
目录 一、任务目标 (3) 二、概要设计 (4) 三、详细设计 (6) 四、调试分析 (8) 五、源程序代码 (8) 六、程序运行效果图与说明 (15) 七、本次实验小结 (16) 八、参考文献 (16)
一丶任务目标 分析 (1) a.能够按照指数降序排列建立并输出多项式 b.能够完成两个多项式的相加，相减，并将结果输入 要求：程序所能达到的功能： a.实现一元多项式的输入； b.实现一元多项式的输出； c.计算两个一元多项式的和并输出结果； d.计算两个一元多项式的差并输出结果； 除任务要求外新增乘法： 计算两个一元多项式的乘积并输出结果 （2）输入的形式和输入值的范围： 输入要求：分行输入，每行输入一项，先输入多项式的指数，再输入多项式的系数，以0 0为结束标志，结束一个多项式的输入。 输入形式： 2 3 -1 2 3 0 1 2 0 0 输入值的范围：系数为int型，指数为float型 （3）输出的形式： 第一行输出多项式1； 第二行输出多项式2； 第三行输出多项式1与多项式2相加的结果多项式； 第四行输出多项式1与多项式2相减的结果多项式； 第五行输出多项式1与多项式2相乘的结果多项式
二、概要设计 程序实现 a. 功能：将要进行运算的二项式输入输出； b. 数据流入：要输入的二项式的系数与指数； c. 数据流出：合并同类项后的二项式； d. 程序流程图：二项式输入流程图； e. 测试要点：输入的二项式是否正确，若输入错误则重新输入。
一元稀疏多项式简单计算器 一、设计课题 设计一元稀疏多项式简单计算器。 二、需求分析 2.1 输入的形式和输入值的范围： 输入是从键盘输入的，输入的内容为多项式的系数和指数，数为任意的整数，指数为大于等于0的整数 2.2 输出的形式 从屏幕输出，显示用户输入的多项式，并显示多项式加减以后的多项式的值。 2.3 程序所能达到的功能 a：输入并建立多项式； b：输出多项式，输出形式为整数序列：n,c1,e1,c2,e2,……,cn,en,其中n是多项式的项数，ci和ei 分别是第i项的系数和指数，序列按指数降序排列； c：多项式a和b相加，建立多项式a+b； d：多项式a和b相减，建立多项式a-b； 2.4 测试数据 （1）(2x+5x^8-3.1x^11)+(7-5x^8+11x^9) = (-3.1x^11+11X^9+2X+7) （2）(X+X^3)+(-X-X^3)=0 （3）(X+X^2+X^3)+0= X+X^2+X^3 三、概要设计 3.1 设计思路 A：数据结构的选用 为了实现任意多项式的加法、减法，因此选择单链表的结构体，它有一个系数，指数，下一个指针3个元属；单链表抽象结构类型定义见附录2。 B：多项式的输入 采用头节点插法的方式，输入多项式中一个项的系数和指数，就产生一个新的节点，建立起它的右指针，并用头节点指向它；为了判断一个多项式是否输入结束，定义一个结束标志，当输入非00时就继续，当输入00时，就结束一个多项式的输入； C：2个多项式的加法 它从2个多项式的头部开始，2个多项式的某一项都不为空时，如果指数相等的话，系数就应该相加；相加的和不为0的话，用头插法建立一个新的节点。p的系数小于q的系数的话，就应该复制q接点到多项式中。p的系数大于q的系数的话，就应该复制p接点到多项式中。当第2个多项式空，第1个数不为空时，将第一个数剩下的全用新节点产生。当第1个多项式空，第1个数不为空时，将第2个数剩下的全用新节点产生 D：2个多项式的减法 它从2个多项式的头部开始，2个多项式的某一项都不为空时，如果指数相等的话，系数就应该相减；相加的和不为0的话，用头插法建立一个新的节点。 p的系数小于q的系数的话，就应该复制q接点到多项式中。p的系数大于q的系数的话，就应该复制p接点到多项式中，并且建立的接点的系数为原来的相反数；当第2个多项式空，第1个数不为空时，将第一个数剩下的全用新节点产生。当第1个多项式空，第1个数不为空时，将第2个数剩下的全用新节点产生，并且建立的接点的系数为原来的相反数。
