数据结构实验,多项式计算器

实验题目：多项式运算器

实验内容：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

主要函数的时间复杂度：（N项多项式）

Createpolyn：N

Printpolyn：N

Copypolyn：N

Addpolyn：N1+N2

实验结果：

控制菜单：

显示多项式：

多项式求值：

求和、求差、复制、销毁、清空也均能得到正常结果

源代码：

#include

#include

#define N 20

#define L sizeof(struct LNode)

struct LNode

{

int n;

double m;

struct LNode*next;

};

struct LNode* createpolyn (struct LNode*p)

{

double i=1;

int j,a=0;struct LNode*u;

p=(struct LNode*)malloc(L);

p->m=0;

p->n=0;

p->next=NULL;

u=p;

while(i!=0)

{

printf("从低次到高次输入X的非零项的次数及系数：'0 0'表示结束：\n");

scanf("%d %lf",&j,&i);

if(i!=0){

p->next=(struct LNode*)malloc(L);

p=p->next;

p->m=i;p->n=j;

}

};

p->next=NULL;

printf("completed!\n");

return(u);

}

void printpolyn (struct LNode*p)

{

p=p->next;

while (p!=NULL)

{

printf("+%lfX^%d\n",p->m,p->n);

p=p->next;

}

//printf("NULL");

}

struct LNode* copypolyn (struct LNode*p,struct LNode*q)

{struct LNode* u;

q=(struct LNode*)malloc(L);

u=q;

while (p->next!=NULL)

{

q->m=p->m;

q->n=p->n;

p=p->next;

q->next=(struct LNode*)malloc(L);

q=q->next;

}

q->m=p->m;

q->n=p->n;

q->next=NULL;

printf("completed!\n");return(u);

}

/*struct LNode* addpolyn (struct LNode*p,struct LNode*q,struct LNode*r) {

struct LNode*u;

r=(struct LNode*)malloc(L);

u=r;

while((q->next!=NULL)&&(p->next!=NULL))

{

if((q->n)>(p->n))

{

r->n=p->n;

r->m=p->m;

p=p->next;

}

else

{

if((q->n)==(p->n))

{

r->n=p->n;

r->m=(p->m)+(q->m);

p=p->next;

q=q->next;

}

else

{

r->n=q->n;

r->m=q->m;

q=q->next;

}

}

r->next=(struct LNode*)malloc(L);

r=r->next;

}

if((q->next)==NULL)

{

while((q->n>p->n)&&(p->next!=NULL)){ if((q->n)>(p->n))

{

r->n=p->n;

r->m=p->m;

p=p->next;

r->next=(struct LNode*)malloc(L);

r=r->next;

}}

if((q->n)<=(p->n))

{

if((q->n)==(p->n))

{

r->n=p->n;

r->m=(p->m)+(q->m);

}

else

{

r->n=q->n;

r->m=q->m;

}

}

if(p->next!=NULL){

r->next=(struct LNode*)malloc(L);

r=r->next;

p=p->next;

while(p->next!=NULL){

r->n=p->n;

r->m=p->m;

r->next=(struct LNode*)malloc(L);

r=r->next;

p=p->next;

}

r->n=p->n;

r->m=p->m;r->next=(struct LNode*)malloc(L);

r->next=NULL;

}

else{r->next=(struct LNode*)malloc(L);r->next=NULL;}

}

else

{ if((q->n)>(p->n))

{

r->n=p->n;

r->m=p->m;

}

else

{

if((q->n)==(p->n))

{

r->n=p->n;

r->m=(p->m)+(q->m);

}

while((q->nn)&&q->next!=NULL)

{

r->n=q->n;

r->m=q->m;

q=q->next;

r->next=(struct LNode*)malloc(L);

r=r->next;

}

}

if(q->next!=NULL){r->next=(struct LNode*)malloc(L);

r=r->next;q=q->next;

while(q->next!=NULL){

r->n=q->n;

r->m=q->m;

r->next=(struct LNode*)malloc(L);

r=r->next;

q=q->next;

}

r->n=q->n;

r->m=p->m;r->next=(struct LNode*)malloc(L);

r->next=NULL;}

else{r->next=(struct LNode*)malloc(L);

r->next=NULL;}

}

printf("completed!\n");

return(u);

}整理之前的ADDPOLYN函数*/

struct LNode*addpolyn(struct LNode*p,struct LNode*q,struct LNode*r)

{

struct LNode* u=NULL;

if((q==NULL)||(p==NULL)){return(u);}

r=(struct LNode*)malloc(L);

u=r;

while(((q->next)!=NULL)&&((p->next)!=NULL))

{ if(q->n>p->n){

r->n=p->n;

r->m=p->m;

p=p->next;

r->next=(struct LNode*)malloc(L);

r=r->next;

}

if(q->n==p->n){

r->n=p->n;

r->m=p->m+q->m;

q=q->next;

p=p->next;

r->next=(struct LNode*)malloc(L);

r=r->next;

}

if(q->nn){

r->n=q->n;

r->m=q->m;

q=q->next;

r->next=(struct LNode*)malloc(L);

r=r->next;

}

}

if((q->next==NULL)&&(p->next==NULL))

{ if(q->n>p->n){

r->n=p->n;

r->m=p->m;

r->next=(struct LNode*)malloc(L);

r=r->next;

r->n=q->n;

r->m=q->m;

}

if(q->n==p->n){

r->n=p->n;

r->m=p->m+q->m;

}

if(q->nn){

r->n=q->n;

r->m=q->m;

r->next=(struct LNode*)malloc(L);

r=r->next;

r->m=p->m;

r->n=p->n;

}

}

if((q->next==NULL)&&(p->next!=NULL))

{ if(q->nn){

r->n=q->n;

r->m=q->m;

r->next=(struct LNode*)malloc(L);

r=r->next;

while(p->next!=NULL){

r->n=p->n;

r->m=p->m;

p=p->next;

r->next=(struct

LNode*)malloc(L);

r=r->next;

}

r->n=p->n;

r->m=p->m;

}

if(q->n==p->n){

r->n=q->n;

r->m=q->m+p->m;

p=p->next;

r->next=(struct LNode*)malloc(L);

r=r->next;

while(p->next!=NULL){

r->n=p->n;

r->m=p->m;

p=p->next;

r->next=(struct LNode*)malloc(L);

r=r->next;

}

r->n=p->n;

r->m=p->m;

}

if(q->n>p->n){

while(p->nn){

r->n=p->n;

r->m=p->m;

p=p->next;

r->next=(struct LNode*)malloc(L);

r=r->next;

}

if(q->n==p->n){

r->n=q->n;

r->m=q->m+p->m;

p=p->next;

r->next=(struct LNode*)malloc(L);

r=r->next;

while(p->next!=NULL){

r->n=p->n;

r->m=p->m; p=p->next;

r->next=(struct LNode*)malloc(L);

r=r->next;

}

r->n=p->n;

r->m=p->m;

}

if(q->nn){

r->n=q->n;

r->m=q->m;

q=q->next;

r->next=(struct LNode*)malloc(L);

r=r->next; while(p->next!=NULL){

r->n=p->n;

r->m=p->m; p=p->next;

r->next=(struct LNode*)malloc(L);

r=r->next;

}

r->n=p->n;

r->m=p->m;

}

}

}

if((p->next==NULL)&&((q->next)!=NULL))

{ if(p->nn){

r->n=p->n;

r->m=p->m;

r->next=(struct LNode*)malloc(L);

r=r->next;

while(q->next!=NULL){

r->n=q->n;

r->m=q->m;

q=q->next;

r->next=(struct LNode*)malloc(L);

r=r->next;

}

r->n=q->n;

r->m=q->m;

}

if((p->n)==(q->n)){

r->n=p->n;

r->m=p->m+q->m;

q=q->next;

r->next=(struct LNode*)malloc(L);

r=r->next;

while((q->next)!=NULL){

r->n=q->n;

r->m=q->m;

r->next=(struct LNode*)malloc(L);

r=r->next;q=q->next;

}

r->n=q->n;

r->m=q->m;

}

if(p->n>q->n){

while(q->nn){

r->n=q->n;

r->m=q->m;

q=q->next;

r->next=(struct LNode*)malloc(L);

r=r->next;

}

if(p->n==q->n){

r->n=p->n;

r->m=p->m+q->m;

q=q->next;

r->next=(struct LNode*)malloc(L);

r=r->next;

while(q->next!=NULL){

r->n=q->n;

r->m=q->m; q=q->next;

r->next=(struct LNode*)malloc(L);

r=r->next;

}

r->n=q->n;

r->m=q->m;

}

if(q->n>p->n){

r->n=p->n;

r->m=p->m;

r->next=(struct LNode*)malloc(L);

r=r->next; while(q->next!=NULL){

r->n=q->n;

r->m=q->m; q=q->next;

r->next=(struct LNode*)malloc(L);

r=r->next;

}

r->n=q->n;

r->m=q->m;

}

}

}

r->next=NULL;printf("completed!\n");

return(u);

}

struct LNode*subtract(struct LNode*p,struct LNode*q,struct LNode*r)

{

struct LNode* u=NULL;

if((q==NULL)||(p==NULL)){return(u);}

r=(struct LNode*)malloc(L);

u=r;

while(q->next!=NULL&&p->next!=NULL)

{ if(q->n>p->n){

r->n=p->n;

r->m=p->m;

p=p->next;

r->next=(struct LNode*)malloc(L);

r=r->next;

}

if(q->n==p->n){

r->n=p->n;

r->m=p->m-q->m;

q=q->next;

p=p->next;

r->next=(struct LNode*)malloc(L);

r=r->next;

}

if(q->nn){

r->n=q->n;

r->m=-q->m;

q=q->next;

r->next=(struct LNode*)malloc(L);

r=r->next;

}

}

if((q->next==NULL)&&(p->next==NULL))

{ if(q->n>p->n){

r->n=p->n;

r->m=p->m;

r->next=(struct LNode*)malloc(L);

r=r->next;

r->n=q->n;

r->m=-q->m;

}

if(q->n==p->n){

r->n=p->n;

r->m=p->m-q->m;

}

if(q->nn){

r->n=q->n;

r->m=-q->m;

r->next=(struct LNode*)malloc(L);

r=r->next;

r->m=p->m;

r->n=p->n;

}

}

if((q->next==NULL)&&(p->next!=NULL))

{ if(q->nn){

r->n=q->n;

r->m=-q->m;

r->next=(struct LNode*)malloc(L);

r=r->next;

while(p->next!=NULL){

r->n=p->n;

r->m=p->m;

p=p->next;

r->next=(struct LNode*)malloc(L);

r=r->next;

}

r->n=p->n;

r->m=p->m;

}

if(q->n==p->n){

r->n=q->n;

r->m=-q->m+p->m;

p=p->next;

r->next=(struct LNode*)malloc(L);

r=r->next;

while(p->next!=NULL){

r->n=p->n;

r->m=p->m;

p=p->next;

r->next=(struct LNode*)malloc(L);

r=r->next;

}

r->n=p->n;

r->m=p->m;

}

if(q->n>p->n){

while(p->nn){

r->n=p->n;

r->m=p->m;

p=p->next;

r->next=(struct LNode*)malloc(L);

r=r->next;

}

if(q->n==p->n){

r->n=q->n;

r->m=-q->m+p->m;

p=p->next;

r->next=(struct LNode*)malloc(L);

r=r->next;

while(p->next!=NULL){

r->n=p->n;

r->m=p->m; p=p->next;

r->next=(struct LNode*)malloc(L);

r=r->next;

}

r->n=p->n;

r->m=p->m;

}

if(q->nn){

r->n=q->n;

r->m=-q->m;

q=q->next;

r->next=(struct LNode*)malloc(L);

r=r->next; while(p->next!=NULL){

r->n=p->n;

r->m=p->m; p=p->next;

r->next=(struct LNode*)malloc(L);

r=r->next;

}

r->n=p->n;

r->m=p->m;

}

}

}

if((p->next==NULL)&&(q->next!=NULL))

{ if(p->nn){

r->n=p->n;

r->m=p->m;

r->next=(struct LNode*)malloc(L);

r=r->next;

while(q->next!=NULL){

r->n=q->n;

r->m=-q->m;

q=q->next;

r->next=(struct LNode*)malloc(L);

r=r->next;

}

r->n=q->n;

r->m=-q->m;

}

if(p->n==q->n){

r->n=p->n;

r->m=p->m-q->m;

q=q->next;

r->next=(struct LNode*)malloc(L);

r=r->next;

while(q->next!=NULL){

r->n=q->n;

r->m=-q->m;

q=q->next;

r->next=(struct LNode*)malloc(L);

r=r->next;

}

r->n=q->n;

r->m=-q->m;

}

if(p->n>q->n){

while(q->nn){

r->n=q->n;

r->m=-q->m;

q=q->next;

r->next=(struct LNode*)malloc(L);

r=r->next;

}

if(p->n==q->n){

r->n=p->n;

r->m=p->m-q->m;

q=q->next;

r->next=(struct LNode*)malloc(L);

r=r->next;

while(q->next!=NULL){

r->n=q->n;

r->m=-q->m; q=q->next;

r->next=(struct LNode*)malloc(L);

r=r->next;

}

r->n=q->n;

r->m=-q->m;

}

if(q->n>p->n){

r->n=p->n;

r->m=p->m;

r->next=(struct LNode*)malloc(L);

r=r->next; while(q->next!=NULL){

r->n=q->n;

r->m=-q->m; q=q->next;

r->next=(struct LNode*)malloc(L);

r=r->next;

}

r->n=q->n;

r->m=-q->m;

}

}

}

r->next=(struct LNode*)malloc(L); r->next=NULL;printf("completed!\n");

return(u);

}

double value (struct LNode*p,double x)

{

double a,b; int i;

p=p->next;a=0;

while(p->next!=NULL)

{

b=1;i=0;

while(in)

{

b=b*x;

i++;

}

b=p->m*b;

a=a+b;p=p->next;

}

b=1;i=0;

while(in)

{

b=b*x;

i++;

}

b=p->m*b;

a=a+b;

return(a);

}

struct LNode* destroypolyn(struct LNode*p)

{struct LNode* u;

p=NULL;u=p;

printf("completed!\n");

return(u);

}

struct LNode* clearpolyn(struct LNode*p)

{struct LNode* u=p;

while(p!=NULL)

{

p->m=0;

p=p->next;

}

printf("completed!\n");

return(u);

}

void main()

{

struct LNode *a[N]={NULL};

double x,z;

int n,n1,n2,n31,n32,n41,n42,n43,n51,n52,n53,n6,n7,n8,n9;

top: printf("********************多项式运算器********************\n");

printf(" 1----------------创建多项式\n");

printf(" 2----------------显示多项式\n");

printf(" 3----------------复制多项式\n");

printf(" 4----------------多项式求和\n");

printf(" 5----------------多项式求差\n");

printf(" 6----------------多项式求值\n");

printf(" 7----------------销毁多项式\n");

printf(" 8----------------清空多项式\n");

printf(" 9----------------修改多项式\n");

printf(" 0----------------退出\n");

printf(" 输入您要的运算:");

scanf("%d",&n);

switch(n)

{

case 1:printf("输入您要创建的多项式存储位置\n");

scanf("%d",&n1);

a[n1-1]=createpolyn(a[n1-1]);break;

case 2:printf("输入您要显示的多项式序号\n");

scanf("%d",&n2);

if(a[n2-1]!=NULL){

printpolyn(a[n2-1]);

一元稀疏多项式计算器实验(报告+程序)

一元稀疏多项式计数器预习报告 ：刘茂学号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;

数据结构中实现一元多项式简单计算

数据结构中实现一元多项式简单计算： 设计一个一元多项式简单的计算器。 基本要求： 一元多项式简单计算器的基本功能为： （1）输入并建立多项式； （2）输出多项式； （3）两个多项式相加，建立并输出和多项式； （4）两个多项式相减，建立并输出差多项式； #include #include #define MAX 20 //多项式最多项数 typedef struct//定义存放多项式的数组类型 { float coef; //系数 int exp; //指数 } PolyArray[MAX]; typedef struct pnode//定义单链表结点类型 { float coef; //系数 int exp; //指数 struct pnode *next; } PolyNode; void DispPoly(PolyNode *L) //输出多项式 { PolyNode *p=L->next; while (p!=NULL) { printf("%gX^%d ",p->coef,p->exp); p=p->next; } printf("\n"); } void CreateListR(PolyNode *&L,PolyArray a,int n) //尾插法建表 { PolyNode *s,*r;int i; L=(PolyNode *)malloc(sizeof(PolyNode)); //创建头结点 L->next=NULL; r=L; //r始终指向终端结点,开始时指向头结点for (i=0;i

多项式的运算(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) {

数据结构实验,多项式计算器

实验题目：多项式运算器 实验内容：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，输出多项式，输出形式为整数序列: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; } }

用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日

一元稀疏多项式计算器(数据结构)

院系：计算机科学学院 专业：软件工程 年级： 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为指针域，用链表来表示多项式。适用于不定的多项式，特别是对于项数再运算过程中动态增长的多项式，不存在存储溢出的问题。其次，对于某些零系数项，在执行加法运算后不再是零系数项，这就需要在结果多项式中增添新的项；对于某些非零系数项，在执行加法运算后可能是零系数项，这就需要在结果多项式中删去这些项，利用链表操作，可以简单的修改结点的指针以完成这种插入和删除运算（不像在顺序方式中那样，可能移动大量数据项）运行效率高。

一元稀疏多项式计算器实验

一元稀疏多项式计数器预习报告 姓名：刘茂学号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

一元多项式计算器设计与实现

一元稀疏多项式简单计算器 一、设计课题 设计一元稀疏多项式简单计算器。 二、需求分析 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个数剩下的全用新节点产生，并且建立的接点的系数为原来的相反数。

一元多项式计算器程序设计实验报告

武汉工业学院 数学与计算机学院 《数据结构》 课程设计说明书 题目：一元多项式计算器 专业：计算机 班级：计算机类1305班 学号： 1305110053 姓名：杨钦 指导老师：左翠华 2014年12月25日

一、 设计题目 一元稀疏多项式计算器 【问题描述】 设计一个一元稀疏多项式简单计算器。 【基本要求】 一元稀疏多项式简单计算器的基本功能是： (1) 输入并建立多项式 ； (2) 输出多项式，输出形式为整数序列：n ，c l ，e l ，c 2，e 2，…，c n ，e n ，其中n 是多项式的项数，c i 和e i ，分别是第 i 项的系数和指数，序列按指数降序排列； (3) 多项式a 和b 相加，建立多项式a +b ； (4) 多项式a 和b 相减，建立多项式a -b 。 【测试数据】 (1)(2x+5x 8－3.1x 11) + (7－5x 8+11x 9)=(－3.lx 11+11x 9+2x+7) (2)(6x -3－x+4.4x 2－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) 互换上述测试数据中的前后两个多项式 【实现提示】 用带表头结点的单链表存储多项式。 【选作内容】 (1) 计算多项式在x 处的值。 (2) 求多项式 a 的导函数a ' 。 (3) 多项式a 和b 相乘，建立乘积多项式ab 。 (4) 多项式的输出形式为类数学表达式。例如,多项式 -3x8+6x3－18 的输出形式为183683-+-∧∧x x ，x15+(－8)x7－14的输出形式为147815--∧∧x x 。注意，数值为1的非零次项的输出形式中略去系数1，如项1x8的输出形式为x8，项 －1x3的输出形式为－x3。

一元稀疏多项式计算器实习报告

实习报告 题目：设计一个一元稀疏多项式计算器 班级: 姓名学号__________完成日期：__ 一、课程题目 一元稀疏多项式计算器 二、需求分析 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}

数据结构课程设计-一元多项式计算器

实习1、一元稀疏多项式计算器 一、需求分析 1. 问题描述 设计一个一元稀疏多项式简单计算器。 2. 基本要求 一元稀疏多项式简单计算器的基本功能是： (1)输入并建立多项式。 (2)输出多项式，输出形式为整数序列：n, c1, e1, c2, e2, ········,c n, e n，其中n是多项式的项数，c i,e i分别是第i项的系数和指数，序列按指数降序排列。 (3)多项式a和b想加，建立多项式a+b 。 (4)多项式a和b想减，建立多项式a-b 。 3. 测试数据 (1) (2x+5x8-3.1x11)+(7-5x8+11x9)=(-3.1x11+11x9+2x+7) (2) (6x-3-x+4.4x2-1.2x9)-(-6x-3+5.4x2-x2+7.8x15)=(-7.8x15-1.2x9+12x-3-x) (3) (1+x+x2+x3+x4+x5)+(-x3-x4)=(1+x+x2+x5) (4) (x+x3)+(-x-x3)=0 (5) (x+x100)+(x100+x200)=(x+2x100+x200) (6) (x+x2+x3)+0=(x+x2+x3) (7) 互换测试数据的前后两个多项式。 4. 实现提示 用带表头结点的单链表存储多项式。 二、概要设计 为实现上述程序功能，应用带头结点的单链表存储多项式。为此需要一个抽象数据类型：一元多项式。 1.抽象数据类型一元多项式定义为： ATD Ploynomial{ 数据对象：D={ai|ai∈Termset, i=1,2,3···，m,m≥0Termset中的每个元素包含一个表示系数的实数和表示指数的整数} 数据关系：R1={ai-1,ai∈D,且ai-1中的指数

一元稀疏多项式计算器 C语言编写

一元稀疏多项式计算器 C语言编写 悬赏分：120 |提问时间：2008-6-23 20:33 |提问者：骑着单车的熊 一元稀疏多项式计算器： 用C语言编写程序，实现一元稀疏多项式计算器。具体要求如下： (1) 演示程序以用户与计算机对话的形式输入输出数据； (2) 实现两个一元稀疏多项式的加、减、乘运算； (3) 求一个多项式a的导函数a’； (4) 结果以类数学表达式的形式输出。 看清题目的要求我只要C语言的不要其他语言的还有解释一下编程的思路和过程谢谢了大家 请大家传给我能够使用的程序谢谢了 推荐答案 datastruct.h typedef struct list { int c; //多项式的项数 int e; //多项式的指数 struct list *next; //下一结点 }; typedef struct list *LinkList; typedef struct list Node; 下面是线性表的操作相关函数声明，对应文件ListOper.h: //File: ListOper.h #ifndef DATASTRUCT #define DATASTRUCT #include "datastruct.h" #endif //some functions declaretioin bool CreateList(LinkList &L); Node *CreateNode(int e, int c); void FreeList(LinkList &L); void SortList(LinkList &L); void DeleteNextNode(Node *d); void SweepNextNode(Node *s);

数据结构课程设计___一元稀疏多项式计算器(报告+代码)__完整版.

数据结构课程设计 系别电子信息系 专业计算机科学与技术 班级学号4090113 姓名王健 指导教师党群 成绩 2011年7 月14 日

目录 一、课程题目 (1) 二、需求分析 (1) 三、测试数据 (2) 四、概要设计 (2) 五、调用关系图 (3) 六、程序代码 (3) 七、心得体会及总结 (12) 数据结构课程设计

一、课程题目 一元稀疏多项式计算器 二、需求分析 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利用链表实现队列的构造。每次输入一项的系数和指数，可以输出构 造的一元多项式 2.4演示程序以用户和计算机的对话方式执行，即在计算机终站上显示 “提示信息”之后，由用户在键盘上输入演示程序中规定的运行命令；最后根据相应的输入数据（滤去输入中的非法字符）建立的多项式以及多项式相加的运行结果在屏幕上显示。多项式显示的格式为：c1x^e1+c2x^e2+… +cnx^en 3、设计思路分析 要解决多项式相加，必须要有多项式，所以必须首先建立两个多项式，在这里采用链表的方式存储链表，所以我将结点结构体定义为 运用尾插法建立两条单链表，以单链表polyn p和polyn h分别表示两个一元多项式a和b，a+b的求和运算等同于单链表的插入问题（将单链表polyn p中的结点插入到单链表polyn h中），因此“和多项式”中的结点无须另生成。 为了实现处理，设p、q分别指向单链表polya和polyb的当前项，比较p、q结点的指数项，由此得到下列运算规则： ① 若p->expnexpn，则结点p所指的结点应是“和多项式”中的一项， 令指针p后移。

一元多项式计算器

实验报告 课程名称：数据结构 实验名称：一元多项式计算器 院（系）：计算机与通信工程学院 姓名： 学号： 专业班级： 指导教师： 2020 年 4 月22 日

实验报告正文 一、实验目的 1、目的：掌握顺序表和单链表的存储特点及插入、删除等算法。 2、任务：灵活运用顺序表和单链表的相关算法实现一元多项式的计算。 二、实验内容及要求 1、任务描述 实验内容：设有一元多项式Am(x)和Bn(X)，编程实现多项式Am(x)和Bn(x)的加法、减法和乘法运算。其中多项式描述为： Am(x)=A0+A1x1+A2x2+A3x3+….+Amxm； Bn(x)=B0+B1x1+B2x2+B3x3+….+Bnxn。 2、主要数据类型与变量 系数和指数采用int类型，运算结果不超出int取值范围 3、算法或程序模块 读多项式模块：Polynomial ReadPoly() 多项式乘法模块：Polynomial Mult(Polynomial p1, Polynomial p2) 多项式加法模块：Polynomial Add(Polynomial p1, Polynomial p2) 多项式减法模块：Polynomial Reduce(Polynomial p1, Polynomial p2) 输出多项式模块：void PrintPoly(Polynomial p) 三、测试 1、方案 输入两个多项式分别为： 3 4 -5 2 6 1 -2 0 5 20 -7 4 3 1 2、结果 四、总结与讨论 通过本次实验，我巩固了前面所学的知识，又将C语言的知识，C++的内容结合到

一起，因为太久没有接触计算机实验，所以一切显得熟悉又陌生，对我来说有点吃力，应该再把前面的知识复习巩固。 本实验的主要数据类型与变量类型是 struct PolyNode { int coef; int expon; PolyNode* link; }; typedef PolyNode* Polynomial; 输出的时候每种运算结果以多项式形式输出，要输出升幂和降幂两种情况。结果多项式中无重复阶项、无零系数项，输出多项式时请采用如下易读形式（一元多项式，总变元为x）：x^4 - 3 x^2 + 5，实现一个简单的交互式界面，包括系统菜单、输入提示等。多项式运算前首先判定多项式特点，根据多项式是否稀疏来选用合适的存储结构；根据多项式不同的运算要求选择合适的存储结构，庞大的编程需要不断地调试，包括相加、相减、相乘运算。算法模块包括读多项式，加减乘法模块以及输出多项式模块。 附：程序的源代码 #include #include using namespace std; struct PolyNode { int coef; int expon; PolyNode* link; }; typedef PolyNode* Polynomial; void Attach(int c, int e, Polynomial* prear) { PolyNode* node = new PolyNode(); node->coef = c; node->expon = e; (*prear)->link = node; *prear = node; } Polynomial ReadPoly() { int c, e; Polynomial p, rear, temp; p = new PolyNode(); rear = p; while(scanf("%d%d", &c, &e)){ Attach(c,e,&rear); char ch = getchar(); if(ch == '\n') break; } temp = p; p = p->link; free(temp); return p; } Polynomial Mult(Polynomial p1, Polynomial p2) { if (!p1||!p2) return NULL;

C语言课程设计报告(多项式简单的计算器)

沈阳航空航天大学 课程设计报告 课程设计名称：C语言课程设计 课程设计题目：多项式简单的计算器 院（系）：计算机学院 专业：计算机科学与技术 班级：14010106 学号：2011040101258 姓名：崔雨濛 指导教师：孙恩岩 完成日期：2012年3月16日

目录 第1章概要设计 (2) 1.1题目的内容与要求 (2) 1.2总体结构 (2) 第2章详细设计 (3) 2.1主模块 (3) 2.2多项式建立模块 (4) 2.3计算模块 (5) 2.4显示模块 (6) 第3章调试分析 (7) 3.1无法完整输出多项式 (7) 3.2多项式中出现多余的项目 (7) 3.3用户无法自行选择结束运行程序 (7) 第4章使用说明与执行结果 (8) 参考文献 (10) 附录（程序清单） (11) I

第1章概要设计 1.1题目的内容与要求 课程设计的内容是设计一个简单的单词替换程序，可以替换文本文件中指定的单词。 要求： （1）输入多项式各项并建立多项式。 （2）输出多项式。 （3）两个多项式相加减，并输出结果多项式。 （4）采用VC环境进行调试运行。 1.2总体结构 本程序主要分为四个模块（功能模块图见图1.1）：主模块，多项式建立模块，计算模块，显示模块。主模块：输入多项式各项，建立多项式，输出多项式。多项式建立模块：将输入的多项式各项以链表形式建立起来。计算模块：比较两个多项式的系数和指数，合并同类项。显示模块：显示输入的多项式及结果多项式。 图1.1 功能模块图

第2章详细设计 2.1主模块 控制整个程序的运行，控制菜单操作，通过主函数模块分别调用各个模块，实现各项功能，流程如图2.1所示。 图2.1 主模块流程图

数据结构(C语言)一元稀疏多项式计算器

实验报告一 题目：编制一个一元稀疏多项式计算器 班级：1302018 姓名：王雪学号：130******** 完成日期：2014.4.5 一、需求分析 1、一元稀疏多项式简单计算器的功能是： 1.1 输入并建立多项式； 1.2 输出多项式，输出形式为整数序列：n，c1,e1,c2,e2,………cn,en,其中n是多 项式的项数，ci和ei分别是第i项的系数和指数，序列按指数降序排列； 1.3多项式a和b相加，建立多项式a+b； 1.4 多项式a和b相减，建立多项式a-b。 2、设计思路: 2.1 定义线性表的动态分配顺序存储结构； 2.2 建立多项式存储结构，定义指针*next 2.3利用链表实现队列的构造。每次输入一项的系数和指数，可以输出构造的一元多 项式 2.4演示程序以用户和计算机的对话方式执行，即在计算机终站上显示“提示信息” 之后，由用户在键盘上输入演示程序中规定的运行命令；最后根据相应的输入数据（滤去输入中的非法字符）建立的多项式以及多项式相加的运行结果在屏幕上显示。多项式显示的格式为：c1x^e1+c2x^e2+…+cnx^en 3、设计思路分析 要解决多项式相加，必须要有多项式，所以必须首先建立两个多项式，在这里采用链表的方式存储链表，所以我将结点结构体定义为 序数coef 指数expn 指针域next 运用尾插法建立两条单链表，以单链表polyn p和polyn h分别表示两个一元多项式a 和b，a+b的求和运算等同于单链表的插入问题（将单链表polyn p中的结点插入到单链表polyn h中），因此“和多项式”中的结点无须另生成。 为了实现处理，设p、q分别指向单链表polya和polyb的当前项，比较p、q结点的指数项，由此得到下列运算规则： ① 若p->expnexpn，则结点p所指的结点应是“和多项式”中的一项，令指针p 后移。 ② 若p->expn=q->expn，则将两个结点中的系数相加，当和不为0时修改结点p的系 数。

c一元稀疏多项式计算器-课程设计实验报告

2016-2017学年第二学期学号1608220203 《网络工程》 课程设计报告 题目：一元稀疏多项式计算器 专业：网络工程 班级：网络工程（3）班 姓名：代应豪 指导教师：代美丽 成绩：

一、问题描述 (3) 二、需求分析 (3) 三、概要设计 (4) 四、详细设计 (5) 五、源代码 (6) 六、程序测试 (19) 七、使用说明 (25) 八、课设总结 (26)

一、问题描述 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

简单的一元多项式计算器程序

《简单图形处理系统》 专业名称：信息管理与信息系统 班级：12-1班 学号：2012508214 姓名：吴成强 指导教师：郑老师 2013年3月1日

简单的一元多项式计算器程序 摘要 (2) 1. 绪论 (2) 2. 系统设计 (2) 2.1功能需求 (2) 2.2数据需求 (3) 2.3性能需求 (3) 3. 总体设计 (3) 3.1功能模块设计 (3) 3.2系统设计方案.................................................................... 错误！未定义书签。 4. 详细设计 (4) 4.1输入并建立模块 (4) 4.2输出模块 (6) 4.3相加模块 (6) 4.4相减模块 (8) 5. 调试与测试 (9) 5.1调试 (9) 5.2测试 (9) 6. 结论 (9) 结束语 (9) 参考文献 (10) 附录2－源程序 (13)

摘要 计算器是人们生活中必不可少的简单程序。在我们的学习生活中经常会用到计算器来进行简单的运算。因此如何编写一个简单的一元多项式计算器程序也是我们所应该掌握的。 本系统使用的C语言作为程序开发的语言，开发设计一个一元多项式的和差计算程序实现输入并建立多项式；输出多项式；两个多项式相加，建立并输出和多项式；两个多项式相减，建立并输出差多项式。 本文从分析课题的题目背景、题目意义、题目要求等出发，分别从需求分析、总体设计、详细设计、测试等各个方面详细介绍了系统的设计与实现过程，最后对系统的完成情况进行了总结。 关键词：计算器；系数；指数；一元多项式； 1. 绪论 计算器是人们生活中必不可少的简单工具。在我们的学习生活中经常会用到计算器来进行简单的运算。因此如何编写一个简单的一元多项式计算器也是我们所应该掌握的。 本系统使用的C语言作为程序开发的语言，开发设计一个一元多项式的和差计算程序实现输入并建立多项式；输出多项式；两个多项式相加，建立并输出和多项式；两个多项式相减，建立并输出差多项式。 根据课程设计任务书要求，本系统开发主要完成以下功能。 (1)能够实现输入并建立多项式； (2)能够实现输出多项式； (3)能够实现两个多项式相加，建立并输出和多项式； (4)能够实现两个多项式相减，建立并输出差多项式。 2. 系统设计 2.1 功能需求 本系统主要是一个简单的一元多项式计算器程序系统。 本程序需要设计一个一元多项式的和，差计算程序。多项式的每一项用数组