数据结构C语言版 抽象数据类型Polynomial一元多项式的实现文库

数据结构C语言版 抽象数据类型Polynomial一元多项式的实现文库
数据结构C语言版 抽象数据类型Polynomial一元多项式的实现文库

/*

数据结构C语言版抽象数据类型Polynomial一元多项式的实现

P42-43

编译环境:Dev-C++ 4.9.9.2

日期:2011年2月10日

*/

#include

#include

#include

// 抽象数据类型Polynomial一元多项式的实现

typedef struct // 项的表示,多项式的项作为LinkList的数据元素

{

float coef; // 系数

int expn; // 指数

}term, ElemType;

// 两个类型名:term用于本ADT,ElemType为LinkList的数据对象名

typedef struct LNode // 结点类型

{

ElemType data;

struct LNode *next;

}LNode,*Link,*Position;

typedef struct _LinkList // 链表类型

{

Link head,tail; // 分别指向线性链表中的头结点和最后一个结点

int len; // 指示当前线性链表中数据元素的个数

}LinkList;

typedef LinkList polynomial;

#define DestroyPolyn DestroyList

#define PolynLength ListLength

// 已知p指向线性链表L中的一个结点,返回p所指结点的直接前驱的位置// 若无前驱,则返回NULL

Position PriorPos(LinkList L,Link p)

{

Link q;

q=L.head->next;

if(q==p) // 无前驱

return NULL;

else

{

while(q->next!=p) // q不是p的直接前驱

q=q->next;

return q;

}

}

// 若升序链表L中存在与e满足判定函数compare()取值为0的元素,则q指示L中// 第一个值为e的结点的位置,并返回1;否则q指示第一个与e满足判定函数

// compare()取值>0的元素的前驱的位置。并返回0。(用于一元多项式)

int LocateElemP(LinkList L,ElemType e,Position *q,

int(*compare)(ElemType,ElemType))

{

Link p=L.head,pp;

do

{

pp=p;

p=p->next;

}while(p&&(compare(p->data,e)<0)); // 没到表尾且p->data.expndata,e)>0) // 到表尾或compare(p->data,e)>0

{

*q=pp;

return 0;

}

else // 找到

{

*q=p;

return 1;

}

}

// h指向L的一个结点,把h当做头结点,删除链表中的第一个结点并以q返回。// 若链表为空(h指向尾结点),q=NULL,返回0

int DelFirst(LinkList *L,Link h,Link *q)

{

*q=h->next;

if(*q) // 链表非空

{

h->next=(*q)->next;

if(!h->next) // 删除尾结点

(*L).tail=h; // 修改尾指针

(*L).len--;

return 1;

}

else

return 0; // 链表空

}

// 分配由p指向的值为e的结点,并返回1;若分配失败。则返回0

int MakeNode(Link *p,ElemType e)

{

*p = (Link)malloc(sizeof(LNode)); //动态分配一个Link空间

if(!*p)

return 0;

(*p)->data = e; // 赋值

return 1;

}

// 释放p所指结点

void FreeNode(Link *p)

{

free(*p); //老规矩,先释放存储空间,然后置空

*p=NULL;

}

// h指向L的一个结点,把h当做头结点,将s所指结点插入在第一个结点之前// 头结点没有数据域,而第一个结点是h->next

int InsFirst(LinkList *L,Link h,Link s)

{

s->next = h->next;

h->next=s;

if(h==(*L).tail) // 如果h指向尾结点

(*L).tail=h->next; // 修改尾指针

(*L).len++;

return 1;

}

// 按有序判定函数compare()的约定,将值为e的结点插入或合并到升序

// 链表L的适当位置

int OrderInsertMerge(LinkList *L,ElemType e,int(* compare)(term,term)) {

Position q,s;

if(LocateElemP(*L,e,&q,compare)) // L中存在该指数项

{

q->data.coef+=e.coef; // 改变当前结点系数的值

if(!q->data.coef) // 系数为0

{

// 删除多项式L中当前结点

s = PriorPos(*L,q); // s为当前结点的前驱

if(!s) // q无前驱

s=(*L).head;

DelFirst(L,s,&q);

FreeNode(&q);

}

return 1;

}

else // 生成该指数项并插入链表

if(MakeNode(&s,e)) // 生成结点成功

{

InsFirst(L,q,s);

return 1;

}

else // 生成结点失败

return 0;

}

// 依a的指数值<、=或>b的指数值,分别返回-1、0或+1 // CreatPolyn()的实参

int cmp(term a,term b)

{

if(a.expn==b.expn)

return 0;

else

return (a.expn-b.expn)/abs(a.expn-b.expn); }

// 构造一个空的线性链表

int InitList(LinkList *L)

{

Link p;

p=(Link)malloc(sizeof(LNode)); // 生成头结点

if(p)

{

p->next=NULL;

//将头尾结点都分配好,并将其下一结点置空

(*L).head=(*L).tail=p;

(*L).len=0; //初始为0

return 1;

}

else // 分配失败返回

return 0;

}

// 算法2.22 P42

// 输入m项的系数和指数,建立表示一元多项式的有序链表P

void CreatPolyn(polynomial *P,int m)

{

Position q,s;

term e;

int i;

InitList(P);

printf("请依次输入%d个系数,指数:(空格)\n",m);

for(i=1;i<=m;++i)

{

// 依次输入m个非零项(可按任意顺序)

scanf("%f%d",&e.coef,&e.expn);

// 当前链表中不存在该指数项,cmp是实参

if(!LocateElemP(*P,e,&q,cmp))

if(MakeNode(&s,e)) // 生成结点并插入链表

InsFirst(P,q,s);

}

}

// 返回线性链表L中头结点的位置

Position GetHead(LinkList L)

{

return L.head;

}

// 已知p指向线性链表L中的一个结点,返回p所指结点的直接后继的位置// 若无后继,则返回NULL

Position NextPos(Link p)

{

return p->next;

}

// 已知p指向线性链表中的一个结点,返回p所指结点中数据元素的值ElemType GetCurElem(Link p)

{

return p->data;

}

// 将指针s(s->data为第一个数据元素)所指(彼此以指针相链,以NULL结尾)的// 一串结点链接在线性链表L的最后一个结点之后,并改变链表L的尾指针指向新// 的尾结点

int Append(LinkList *L,Link s)

{

int i=1; //记录s为头的串结点个数

(*L).tail->next=s; //尾结点指向s

while(s->next)

{

s=s->next;

i++;

}

(*L).tail=s;

(*L).len+=i;

return 1;

}

// 若线性链表L为空表,则返回1,否则返回0

int ListEmpty(LinkList L)

{

if(L.len)

return 0;

else

return 1;

}

// 将线性链表L重置为空表(头尾结点相同为空表),并释放原链表的结

// 点空间,不释放头尾结点,只是置空而已

int ClearList(LinkList *L)

{

Link p,q;

if((*L).head!=(*L).tail)// 不是空表

{

p=q=(*L).head->next;

(*L).head->next=NULL;

while(p!=(*L).tail)

{

p=q->next;

free(q);

q=p;

}

free(q);

(*L).tail=(*L).head;

(*L).len=0;

}

return 1;

}

// 销毁线性链表L,L不再存在

int DestroyList(LinkList *L)

{

ClearList(L); // 清空链表(头尾结点并没有释放)

FreeNode(&(*L).head); //再释放头尾结点

(*L).tail=NULL;

(*L).len=0;

return 1;

}

// 算法2.23 P43

// 多项式加法:Pa=Pa+Pb,并销毁一元多项式Pb

void AddPolyn(polynomial *Pa,polynomial *Pb)

{

Position ha,hb,qa,qb;

term a,b;

ha=GetHead(*Pa);

hb=GetHead(*Pb); // ha和hb分别指向Pa和Pb的头结点

qa=NextPos(ha);

qb=NextPos(hb); // qa和qb分别指向Pa和Pb中当前结点(现为第一个结点)while(!ListEmpty(*Pa)&&!ListEmpty(*Pb)&&qa)

{ // Pa和Pb均非空且ha没指向尾结点(qa!=0)

a=GetCurElem(qa);

b=GetCurElem(qb); // a和b为两表中当前比较元素

switch(cmp(a,b))

{

case -1:

ha=qa; // 多项式Pa中当前结点的指数值小

qa=NextPos(ha); // ha和qa均向后移一个结点

break;

case 0:

qa->data.coef+=qb->data.coef;

// 两者的指数值相等,修改Pa当前结点的系数值

if(qa->data.coef==0) // 系数和为0,则删除多项式Pa中当前结点

{

DelFirst(Pa,ha,&qa);

FreeNode(&qa);

}

else

ha=qa;

DelFirst(Pb,hb,&qb);

FreeNode(&qb);

qb=NextPos(hb);

qa=NextPos(ha);

break;

case 1:

DelFirst(Pb,hb,&qb); // 多项式Pb中当前结点的指数值小

InsFirst(Pa,ha,qb);

ha=ha->next;

qb=NextPos(hb);

}

}

if(!ListEmpty(*Pb))

{

(*Pb).tail=hb;

Append(Pa,qb); // 链接Pb中剩余结点

}

DestroyPolyn(Pb); // 销毁Pb

}

// 另一种多项式加法的算法:Pa=Pa+Pb,并销毁一元多项式Pb

void AddPolyn1(polynomial *Pa,polynomial *Pb)

{

Position qb;

term b;

qb=GetHead(*Pb); // qb指向Pb的头结点

qb=qb->next; // qb指向Pb的第一个结点

while(qb)

{

b=GetCurElem(qb);

OrderInsertMerge(Pa,b,cmp);

qb=qb->next;

}

DestroyPolyn(Pb); // 销毁Pb

}

// 一元多项式系数取反

void Opposite(polynomial Pa)

{

Position p;

p=Pa.head;

while(p->next)

{

p=p->next;

p->data.coef*=-1;

}

}

// 多项式减法:Pa=Pa-Pb,并销毁一元多项式Pb

void SubtractPolyn(polynomial *Pa,polynomial *Pb) {

Opposite(*Pb);

AddPolyn(Pa,Pb);

}

// 多项式乘法:Pa=PaPb,并销毁一元多项式Pb

void MultiplyPolyn(polynomial *Pa,polynomial *Pb) {

polynomial Pc;

Position qa,qb;

term a,b,c;

InitList(&Pc);

qa=GetHead(*Pa);

qa=qa->next;

while(qa)

{

a=GetCurElem(qa);

qb=GetHead(*Pb);

qb=qb->next;

while(qb)

{

b=GetCurElem(qb);

c.coef=a.coef*b.coef;

c.expn=a.expn+b.expn;

OrderInsertMerge(&Pc,c,cmp);

qb=qb->next;

}

qa=qa->next;

}

DestroyPolyn(Pb); // 销毁Pb

ClearList(Pa); // 将Pa重置为空表

(*Pa).head=Pc.head;

(*Pa).tail=Pc.tail;

(*Pa).len=Pc.len;

}

// 打印输出一元多项式P

void PrintPolyn(polynomial P)

{

Link q;

q=P.head->next; // q指向第一个结点

printf(" 系数指数\n");

while(q)

{

printf("%f %d\n",q->data.coef,q->data.expn);

q=q->next;

}

}

int main()

{

polynomial p,q;

int m;

// 多项式相加

printf("两个一元多项式相加\n");

//构建一个多项式

printf("请输入第一个一元多项式的非零项的个数:");

scanf("%d",&m);

CreatPolyn(&p,m);

//构建另一个多项式

printf("请输入第二个一元多项式的非零项的个数:");

scanf("%d",&m);

CreatPolyn(&q,m);

//多项式相加

AddPolyn(&p,&q);

printf("两个一元多项式相加的结果:\n");

//打印多项式

PrintPolyn(p);

// 使用另一种多项式相加的方法

printf("\n两个一元多项式相加(另一种方法)\n");

printf("请输入第三个一元多项式的非零项的个数:");

scanf("%d",&m);

CreatPolyn(&p,m);

printf("请输入第四个一元多项式的非零项的个数:");

scanf("%d",&m);

CreatPolyn(&q,m);

// 多项式相加的另一种方法

AddPolyn1(&p,&q);

printf("两个一元多项式相加的结果(另一种方法):\n");

PrintPolyn(p);

// 多项式相减

printf("\n两个一元多项式相减\n");

printf("请输入第五个个一元多项式的非零项的个数:");

scanf("%d",&m);

CreatPolyn(&p,m);

printf("请输入第六个一元多项式的非零项的个数:");

scanf("%d",&m);

CreatPolyn(&q,m);

// 多项式相减

SubtractPolyn(&p,&q);

printf("两个一元多项式相减的结果:\n");

PrintPolyn(p);

//多项式相乘

printf("\n两个一元多项式相乘\n");

printf("请输入第七个个一元多项式的非零项的个数:");

scanf("%d",&m);

CreatPolyn(&p,m);

printf("请输入第八个一元多项式的非零项的个数:");

scanf("%d",&m);

CreatPolyn(&q,m);

//多项式相乘

MultiplyPolyn(&p,&q);

printf("两个一元多项式相乘的结果:\n");

PrintPolyn(p);

//销毁多项式

DestroyPolyn(&p);

DestroyPolyn(&q);

system("pause");

return 0;

}

/*

输出效果:

两个一元多项式相加

请输入第一个一元多项式的非零项的个数:2 请依次输入2个系数,指数:(空格)

1 0 1 1

请输入第二个一元多项式的非零项的个数:2 请依次输入2个系数,指数:(空格)

-1 0 -2 1

两个一元多项式相加的结果:

系数指数

-1.000000 1

两个一元多项式相加(另一种方法)

请输入第三个一元多项式的非零项的个数:2 请依次输入2个系数,指数:(空格)

1 0 1 1

请输入第四个一元多项式的非零项的个数:2 请依次输入2个系数,指数:(空格)

-1 0 -2 1

两个一元多项式相加的结果(另一种方法):系数指数

-1.000000 1

两个一元多项式相减

请输入第五个个一元多项式的非零项的个数:2 请依次输入2个系数,指数:(空格)

1 0

2 1

请输入第六个一元多项式的非零项的个数:2 请依次输入2个系数,指数:(空格)

-2 0 -1 1

两个一元多项式相减的结果:

系数指数

3.000000 0

3.000000 1

两个一元多项式相乘

请输入第七个个一元多项式的非零项的个数:2 请依次输入2个系数,指数:(空格)

1 0 1 1

请输入第八个一元多项式的非零项的个数:2 请依次输入2个系数,指数:(空格)

1 0 1 1

两个一元多项式相乘的结果:

系数指数

1.000000 0

2.000000 1

1.000000 2

请按任意键继续. . . */

数据结构实验多项式加法

数据结构实验报告 实验名称:多项式加减法 学号:1200310419 姓名:林强 实验日期:2015.5.05 一、实验目的 通过实现多项式的加减法,对链表有更深入的了解 二、实验具体内容 1、实验题目1: (1)题目设计一个一元稀疏多项式简单的加减法计算器 实现要求: 一元稀疏多项式简单计算器的基本功能是: (1)输入并建立多项式: 85 17 A+ x + x =; + 3 9 x 7 ) (x 79 8 x B- + = x 22 8 x ) (x (2)输出多项式 (3)多项式A和B相加,建立多项式C=A+B,并输出相加的结果多项式C (4)选作:多项式A和B相减,建立多项式C=A-B,并输出相加的结果多项式D (2)分析 1:本程序的任务是实现两个多项式的加法其中多项式的系数为浮点型, 指数为整数,输出的结果也为系数和指数。 (1)输入的形式和输入值的范围: 输入多项式的系数a和未知数X的指数b,当a和b都为零时,输入结束。输入值的范围:a为实数,b为整数。 (2)输出形式:输出多项式的系数和多项式未知数X的指数即(a,b)形式。 (3)程序所能达到的功能,实现两个多项式的加法,并输出最后的结果 2: 整个程序运行期间实行动态创建节点,一边输入数据, 一边创建节点当将全部数据输入到单链表中后再调用多项式加法这 个函数,并一边实现多项式的相加,一边释放节点,有效防止了 在程序反复运行过程中可能出现系统空间不够分配的现象 (3)实验代码 typedef int Status; #define OVERFLOW -1 #define null 0 typedef struct Lnode{

数据结构课程设计报告一元多项式的计算

数据结构课程设计报告题目:一元多项式计算 院(系):计算机与信息科学学院 专业:软件工程 班级:软件1202班 学号:02 05 40 姓名:陈潇潇刘敏易庆鹏 指导教师:彭代文 2013年12月

目录 一、课程设计介绍 ........................错误!未定义书签。 1.1课程设计目的 (3) 1.2课程设计内容 (3) 1.2课程设计要求 (3) 二、需求设计 ............................错误!未定义书签。 2.1课设题目粗略分析 (3) 2.2原理图介绍.......................... 错误!未定义书签。 2.2.1 功能模块图...................... 错误!未定义书签。 2.2.2 流程图分析 (4) 三、需求分析 .............................错误!未定义书签。 3.1存储结构 (5) 3.2算法描述 (6) 四、调试与分析 ...........................错误!未定义书签。(1)调试过程 .......................... 错误!未定义书签。(2)程序执行过程...................... 错误!未定义书签。参考文献.................................错误!未定义书签。总结.....................................错误!未定义书签。附录(关键部分程序清单)...............错误!未定义书签。

一、课程设计介绍 1.1课程设计目的 ⑴熟悉使用c语言编码程序,解决实际问题; ⑵了解数据结构与算法的设计方法,具备初步的独立分析和设计能力。 ⑶初步掌握软件开发过程的分析能力,系统设计,程序编码,测试等基本能力。 ⑷提高综合运用的能力,运用所学理论知识与独立分析能力。 1.2课程设计内容 一元多项式计算 任务:⑴能够按照指数降序排列建立并输出多项式 ⑵能够完成两个多项式的相加,并将结果输入 ⑶在上交资料中请写明:存储结构、多项式相加的基本过程的算法(可以使用程序流程图)、源程序、测试数据和结果、算法的时间复杂度、另外可以提出算法的改进方法 1.3课程设计要求 ⑴学生必须仔细阅读《数据结构》课程设计方案,认真主动完成课设的要求。有问题及时主动通过各种方式与教师联系沟通。 ⑵学生要发挥自主学习的能力,充分利用时间,安排好课设的时间计划,并在课设过程中不断检测自己的计划完成情况,及时的向教师汇报。 ⑶课程设计按照教学要求需要一周时间完成,一周中每天(按每周5天)至少要上3-4小时的机来调试C语言设计的程序,总共至少要上机调试程序30小时。 ⑷课程设计在期末考试之前交。最好一起上交。 ⑸同班同学之间最好不要相同。源代码可以打印,但是下面模块要求的内容必须手写。 二、需求设计 2.1 课设题目粗略分析 建立一元多项式并按照指数降序排列输出多项式,将一元多项式输入并存储在内存中,能够完成两个多项式的加减运算并输出结果

一元多项式加减乘除运算

中国计量学院实验报告 实验课程:算法与数据结构实验名称:一元二项式班级:学号: 姓名:实验日期: 2013-5-7 一.实验题目: ①创建2个一元多项式 ②实现2个多项式相加 ③实现2个多项式相减 ④实现2个多项式相乘 ⑤实现2个多项式相除 ⑥销毁一元多项式 实验成绩:指导教师:

二.算法说明 ①存储结构:一元多项式的表示在计算机内可以用链表来表示,为了节省存储 空间,只存储多项式中系数非零的项。链表中的每一个结点存放多项式的一个系数非零项,它包含三个域,分别存放该项的系数、指数以及指向下一个多项式项结点的指针。创建一元多项式链表,对一元多项式的运算中会出现的各种可能情况进行分析,实现一元多项式的相加、相减操作。 ②加法算法

三.测试结果 四.分析与探讨 实验数据正确,部分代码过于赘余,可以精简。 五.附录:源代码#include<> #include<> #include<> typedef struct Polynomial { float coef; int expn; struct Polynomial *next; }*Polyn,Polynomial; 出多项式a和b\n\t2.多项式相加a+b\n\t3.多项式相减a-b\n"); printf("\t4.多项式相除a*b\n\t5.多项式相除a/b\n\t6.销毁多项式\n"); printf("\t7.退出

\n*********************************** ***********\n"); printf("执行:"); scanf("%d",&flag); switch(flag) { case(1): printf("多项式a:");PrintPolyn(pa); printf("多项式b:");PrintPolyn(pb);break; case(2): pc=AddPolyn(pa,pb); printf("多项式a+b:");PrintPolyn(pc); DestroyPolyn(pc);break; case(3): pd=SubtractPolyn(pa,pb); printf("多项式a-b:");PrintPolyn(pd); DestroyPolyn(pd);break; case(4): pf=MultiplyPolyn(pa,pb); printf("多项式a*b:");PrintPolyn(pf); DestroyPolyn(pf);break; case(5): DevicePolyn(pa,pb); break; case(6): DestroyPolyn(pa); DestroyPolyn(pb); printf("成功销毁2个一元二项式\n"); printf("\n接下来要执行的操作:\n1 重新创建2个一元二项式 \n2 退出程序\n"); printf("执行:"); scanf("%d",&i); if(i==1) { // Polyn pa=0,pb=0,pc,pd,pf;//定义各式的头指针,pa与pb在使用前付初值NULL printf("请输入a的项数:"); scanf("%d",&m); pa=CreatePolyn(pa,m);// 建立多项式a printf("请输入b的项

数据结构课程设计多项式运算

#include #include #include"malloc.h" #define OK 1 #define ERROR 0 #define OVERFLOW -1 #define NULL 0 typedef int Status; typedef struct ElemType{ float coef; //多项式系数 int exp; //多项式指数 }ElemType;//数据类型 typedef struct Polynomial{ ElemType data; struct Polynomial *next; }*Polyn,Polynomial;//多项式结构体 void Insert(Polyn p,Polyn head) { /*将新的结点插入链表,如果系数为零,则释放该结点; 如果指数为新时将结点直接插入;否则查找插入位置, 方法:比较该结点指数与首元结点及其他结点的指数, 直到该结点指数大于等于链表内某结点的指数,相等则合并这两项;大于则插入到其前驱*/ if(p->data.coef==0) {free(p);p=NULL;} //如果插入项的系数为零时,释放其结点将其删除

else { Polyn q1,q2; q1=head; q2=head->next; while(q2&& p->data.exp < q2->data.exp) { //查找多项式某项的插入位置,使多项式按指数降幂排列 q1=q2; q2=q2->next; } if(q2&& p->data.exp == q2->data.exp) { //将多项式指数相同相进行合并 q2->data.coef += p->data.coef; free(p); if(!q2->data.coef) { //如果多项式的系数为零的话,将其删除即释放期结点 q1->next=q2->next; free(q2); } } else { //如果是新建的多项式,指数为新时将结点插入 p->next=q2; q1->next=p; } } }

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

数据结构中实现一元多项式简单计算: 设计一个一元多项式简单的计算器。 基本要求: 一元多项式简单计算器的基本功能为: (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

数据结构-多项式

一.实验目的: 理解线性表的基本逻辑结构,完成链表及循环链表的实现 通过实验进一步理解线性表的逻辑结构和存储结构,提高使用理论知识指导解决实际问题的能力,熟练掌握链表的实际应用。 二.实验内容: 题目:一元多项式运算 问题描述: 设计算法实现一元多项式的简单运算。 基本要求: (1)输入并建立多项式; (2)输出多项式; (3)多项式加法 (4)多项式减法。 测试数据: (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 三. 实验方案(程序设计说明)

(一)算法设计思路: 1.将两个多项式的系数和指数分别存放在新建的两个链表中; 2.其中一个链表A的指针不动,遍历另一个链表B,指数相等 时系数相加,删除该数,链表B从头开始,链表A移向下个 数据域; 3.直到链表B为空或者链表A遍历完成结束。 (二)算法流程图:

(三)界面设计说明: 请输入多项式的长度: 开始 输入多项式长 度N 以及系数 m,指数n A →n= B →n? Y N j++ 系数相加存放在A 表 i++ 结束 创建链表A ,B ,链表A 从i=0 开始循环,链表B 从j=0开始 i>N? N Y i>N? N Y

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

数据结构实验报告实验一:一元多项式相加 姓名:周成 学号: 专业:软件工程 任课教师:马慧珠 2013年12 月01 日

1.实验名称: 一元多项式相加 2.实验目的: 如何使用C语言实现链表的说明、创建以及结点的插入和删除等操作。 3.实验要求: 对一元多项式能实现输入、输出,以及两个一元多项式相加及结果显示。 4.实验内容: 一元多项式的表示在计算机内用链表来实现,同时为了节省存储空间,只存储其中非零的项,链表中的每个节点存放多项式的系数非零项。它包含三个域,分别存放多项式的系数,指数,以及指向下一个项的指针。根据一元多项式相加的运算规则:对于两个一元多项式中所有指数相同的项,对应系数相加,若其和不为零,则构成“和多项式”中的一项,对于两个一元多项式中所有指数不相同的项,则分别复抄到“和多项式”中去。 核心算法PolyAdd是把分别由pa和pb所指的两个多项式相加,结果为pa所指的多项式。运算规则如下:相加时,首先设两个指针变量qa和qb分别从多项式的首项开始扫描,比较qa和qb所指结点指数域的值,可能出现下列三种情况之一:

(1)qa->exp大于qb->exp,则qa继续向后扫描。 (2)qa->exp等于qb->exp,则将其系数相加。若相加结果不为零,将结果放入qa->coef中,并删除qb所指结点,否则同时删除qa和qb所指结点。 然后qa、qb继续向后扫描。 (3)qa->exp小于qb->exp,则将qb所指结点插入qa所指结点之前,然后qa、qb继续向后扫描。 扫描过程一直进行到qa或qb有一个为空为止,然后将有剩余结点的链表接在结果表上。所得pa指向的链表即为两个多项式之和。 5.实验程序代码及运行结果: #include"" #include<> #include<> #include<> #include<> #define NULL 0 typedef struct NODE {

数据结构一元多项式的加减乘

#ifndef _POL YNOMIAL_H #define _POL YNOMIAL_H #include using namespace std; #include //#define ElemType char typedef struct // 项的表示,多项式的项作为LinkList的数据元素 { float coef; // 系数 int expn; // 指数 }term, ElemType; typedef struct LNode // 结点类型 { ElemType data; struct LNode *next; }LNode,*Link,*Position; typedef struct LinkList // 链表类型 { Link head,tail; // 分别指向线性链表中的头结点和最后一个结点 int len; // 指示当前线性链表中数据元素的个数 }LinkList; typedef LinkList polynomial; void InitList(LinkList &P); void CreatPolyn(polynomial &P,int m); void DestroyPolyn(polynomial &P); void CreatePolyn(polynomial &P,int m);//建立表示一元多项式的有序链表P void DestroyPolyn(polynomial &P);//销毁一元多项式P void PrintPolyn(polynomial P);//打印 int PolyLength(polynomial P);//项数 void AddPolyn(polynomial &Pa,polynomial &Pb);//相加运算 void SubtractPolyn(polynomial &Pa,polynomial &Pb);//相减运算 void MultiplyPolyn(polynomial &P,polynomial &Pa,polynomial &Pb);//相乘运算 int cmp(term a,term b);//依a的指数值<(或=)(或>)b的指数值,分别返回-1,0,+1 int LocateElemP(LinkList L,ElemType e,Position *q, int(*compare)(ElemType,ElemType)); int MakeNode(Link *p,ElemType e); int InsFirst(LinkList *L,Link h,Link s);

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

课程设计成果 学院: 计算机工程学院班级: 13计科一班 学生姓名: 学号: 设计地点(单位): 设计题目:一元多项式的计算 完成日期:年月日 成绩(五级记分制): _________________ 教师签名:_________________________ 目录 1 需求分析 ......................................................................... 错误!未定义书签。 2 概要设计 ......................................................................... 错误!未定义书签。 2.1一元多项式的建立 ............................................................... 错误!未定义书签。 2.2显示一元多项式 ................................................................... 错误!未定义书签。 2.3一元多项式减法运算 ........................................................... 错误!未定义书签。 2.4一元多项式加法运算 ........................................................... 错误!未定义书签。 2.5 设计优缺点.......................................................................... 错误!未定义书签。3详细设计 .......................................................................... 错误!未定义书签。 3.1一元多项式的输入输出流程图........................................... 错误!未定义书签。 3.2一元多项式的加法流程图................................................... 错误!未定义书签。 3.3一元多项式的减法流程图.................................................. 错误!未定义书签。 3.4用户操作函数....................................................................... 错误!未定义书签。4编码 .................................................................................. 错误!未定义书签。5调试分析 .......................................................................... 错误!未定义书签。4测试结果及运行效果...................................................... 错误!未定义书签。5系统开发所用到的技术.................................................. 错误!未定义书签。参考文献 ............................................................................. 错误!未定义书签。附录全部代码................................................................... 错误!未定义书签。

数据结构-多项式相加

数据结构课程设计 2012年12月 班级:XXX 学号:XXX 姓名: XXX 指导教师:XXX

一元稀疏多项式计算器 【问题描述】 设计一个一元稀疏多项式简单计算器 【基本要求】 一元多项式简单计算器的基本功能是: 1,输入并建立多项式; 2,输出多项式,输出形式为整数序列:n,c1,e1,c2,c2,...,cn,en,其中n是多项式的项数,ci和ei分别是第i项的系数和指数,序列按指数降序排列; 3,多项式a和b相加,建立多项式a+b; 4,多项式a和b相减,建立多项式a-b. 【算法设计思想】 ①一般情况下的一元n次多项式可写成pn(x)=p1xe1+p2xe2+……+pmxem 其中,p1是指数为ei的项的非零系数,且满足0≦e1

【实现提示】 用带表头结点的单链表存储多项式。 【程序代码】 #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; } } void display(polynmial L)//显示,输出多项式L { struct node *p, *q; int flag = 0; int k = 0; q = L->next; while(q)

C语言一元多项式计算

C语言一元多项式计算集团标准化工作小组 #Q8QGGQT-GX8G08Q8-GNQGJ8-MHHGN#

#include <> #include <> #include <> #define LEN sizeof(node) //结点构造 typedef struct polynode { int coef; //系数 int exp; //指数 struct polynode *next; }node; node * create(void) { node *h,*r,*s; int c,e; h=(node *)malloc(LEN); r=h; printf("系数:"); scanf("%d",&c); printf("指数:"); scanf("%d",&e); while(c!=0) { s=(node *)malloc(LEN); s->coef=c; s->exp=e; r->next=s; r=s; printf("系数:"); scanf("%d",&c); printf("指数:"); scanf("%d",&e); } r->next=NULL; return(h);

} void polyadd(node *polya, node *polyb) { node *p,*q,*pre,*temp; int sum; p=polya->next; q=polyb->next; pre=polya; while(p!=NULL&&q!=NULL) { if(p->exp>q->exp) { pre->next=p; pre=pre->next; p=p->next; } else if(p->exp==q->exp) { sum=p->coef+q->coef; if(sum!=0) { p->coef=sum; pre->next=p;pre=pre->next;p=p->next; temp=q;q=q->next;free(temp); } else { temp=p->next;free(p);p=temp; temp=q->next;free(q);q=temp; } } else { pre->next=q; pre=pre->next; q=q->next; } } if(p!=NULL) pre->next=p; else pre->next=q; } void print(node * p) {

数据结构 多项式 实验报告

数据结构实验报告 实验名称:实验一——多项式的实现 学生姓名: 班级: 班内序号: 学号: 日期:2011年10月29日 1.实验要求 实验目的: 1.熟悉C++语言的基本编程方法,掌握集成编译环境的调试方法 2.学习指针、模板类、异常处理的使用 3.掌握线性表的操作的实现方法 4.学习使用线性表解决实际问题的能力 实验内容: 利用线性表实现一个一元多项式Polynomial f(x) = a0 + a1x + a2x2 + a3x3+ … + a n x n 要求: 1.能够实现一元多项式的输入和输出 2.能够进行一元多项式相加 3.能够进行一元多项式相减 4.能够计算一元多项式在x处的值 5.能够计算一元多项式的导数(选作) 6.能够进行一元多项式相乘(选作) 7.编写测试main()函数测试线性表的正确性 2. 程序分析 由于多项式是线性结构,故选择线性表来实现,在这个程序中我采用的是单链表结构,每个结点代表一个项,多项式的每一项可以用其系数和指数唯一的表示。如果采用顺序存储,那么对于结点的插入和删除的操作会比较麻烦,而且顺序表的结点个数固定,对于可能发生的情况无法很好的处理,而采用链表就会简单许多,还能自由控制链表的长度。 两个多项式要进行多次的计算,为了保护原始的数据,方便进行以后的计算,故选择把结果存储在一个新建的链表里。 本程序完成的主要功能: 1.输入和输出:需要输入的信息有多项式的项数,用来向系统动态申请内存;多项式

各项的系数和指数,用来构造每个结点,形成链表。输出即是将多项式的内容 向屏幕输出。 2.多项式相加与相减:多项式的加减要指数相同即是同类项才能实现,所以在运算时 要注意判断指数出现的各种不同的情况,分别写出计算方法。将每项运算得到 的结果都插入到新的链表中,形成结果多项式。 3.多项式的求导运算:多项式的求导根据数学知识,就是将每项的系数乘以指数,将 指数减1即可,将每项得到的结果插入到结果多项式的链表中。 4.多项式在某点的值:由用户输入x的值,然后求出每项的值相加即可。 2.1 存储结构 本程序采用的存储结构是单链表结构,其定义的结点包括三部分:系数、指数以及下一个结点的地址。示意图如下: 1.输入多项式 ·自然语言描述: 1.设置多项式的项数n; 2.按照多项式的项数申请动态数组coef[]和expn[]存储多项式的系数和指数; 3.按照指数递增的次序输入各项的系数以及指数,分别存入coef和expn; 4.再将输入的系数以及指数赋给每一个结点的coef和expn域; 5.利用头插法将每个结点加入链表。 ·伪代码: 1.输入项数n; 2.float* coef1=new float[n1]; int* expn1=new int[n1]; 3.运用for循环,循环n次 3.1 term* s=new term; 3.2 s->coef=coef[i]; 3.3 s->expn=expn[i]; 3.4 r->next=s; 3.5 r=s; 4. 运用头插法将结点插入链表。 时间复杂度: 空间复杂度: 2.输出多项式 ·自然语言描述: 1.获取头结点; 2.循环n-1次(n为多项式的项数) 2.1将指针的指向后移; 2.2依照多项式的各种情况,设置输出方式 2.2.1 系数为1且指数不为1和0,输出x^expn+; 2.2.2 系数不为0且指数为0,输出(coef)+; 2.2.3 系数不为0且指数为1,输出(coef)x+;

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

一元多项式的计算—加,减 摘要(题目)一元多项式计算 任务:能够按照指数降序排列建立并输出多项式; 能够完成两个多项式的相加、相减,并将结果输入; 目录 1.引言 2.需求分析 3.概要设计 4.详细设计 5.测试结果 6.调试分析 7.设计体会 8.结束语 一:引言: 通过C语言使用链式存储结构实现一元多项式加法、减法和乘法的运算。按指数

降序排列。 二:需求分析 建立一元多项式并按照指数降序排列输出多项式,将一元多项式输入并存储在内存中,能够完成两个多项式的加减运算并输出结果 三:概要设计 存储结构:一元多项式的表示在计算机内可以用链表来表示,为了节省存储空间,只存储多项式中系数非零的项。链表中的每一个结点存放多项式的一个系数非零项,它包含三个域,分别存放该项的系数、指数以及指向下一个多项式项结点的指针。创建一元多项式链表,对一元多项式的运算中会出现的各种可能情况进行分析,实现一元多项式的相加、相减操作。 1.单连表的抽象数据类型定义: ADT List{ 数据对象:D={ai|ai∈ElemSet,i=1,2,…,n,n≥0} 数据关系:R1={| ai-1, ai∈D,i=2,…,n} 基本操作: InitList(&L) //操作结果:构造一个空的线性表 CreatPolyn(&L) //操作结果:构造一个以单连表存储的多项试 DispPolyn(L) //操作结果:显示多项试 Polyn(&pa,&pb) //操作结果:显示两个多项试相加,相减的结果 } ADT List 2.本程序包含模块: typedef struct LNode //定义单链表 { }LNode,*LinkList; void InitList(LinkList &L) //定义一个空表 { } void CreatPolyn(LinkList &L) //用单链表定义一个多项式 { } void DispPolyn(LinkList L) //显示输入的多项式

数据结构一元多项式报告

一元多项式计算: 程序要求: 1)、能够按照指数降序排列建立并输出多项式; 2)、能够完成两个多项式的相加、相减,并将结果输入。 概要设计: 1.功能:将要进行运算的多项式输入输出。 2.数据流入:要输入的多项式的系数与指数。 3.数据流出:合并同类项后的多项式。 4.程序流程图:多项式输入流程图如图3.2.1所示。 5.测试要点:输入的多项式是否正确,若输入错误则重新输入 2、多项式的加法 (1)功能:将两多项式相加。 (2)数据流入:输入函数。 (3)数据流出:多项式相加后的结果。 (4)程序流程图:多项式的加法流程图如图3.2.2所示。 (5)测试要点:两多项式是否为空,为空则提示重新输入,否则,进行运算。

3、多项式的减法 (1)功能:将两多项式相减。 (2)数据流入:调用输入函数。 (3)数据流出:多项式相减后的结果。 (4)程序流程图:多项式的减法流程图如图3.2.3所示。 (5)测试要点:两多项式是否为空,为空则提示重新输入,否则,进行运算。

详细代码: #include #include #include using namespace std; struct Node { float coef;//结点类型 int exp; }; typedef Node polynomial;

struct LNode { polynomial data;//链表类型 LNode *next; }; typedef LNode* Link; void CreateLink(Link &L,int n); void PrintList(Link L); void PolyAdd(Link &pc,Link pa,Link pb); void PolySubstract(Link &pc,Link pa,Link pb); void CopyLink(Link &pc,Link pa); void PolyMultiply(Link &pc,Link pa,Link pb); int JudgeIfExpSame(Link pa,Link e); void DestroyLink(Link &L); int CompareIfNum(int i); void DestroyLink(Link &L) { Link p; p=L->next; while(p) { L->next=p->next; delete p; p=L->next; } delete L; L=NULL; } //创建含有n个链表类型结点的项,即创建一个n项多项式void CreateLink(Link &L,int n) { if(L!=NULL) { DestroyLink(L); } Link p,newp; L=new LNode; L->next=NULL; (L->data).exp=-1;//创建头结点 p=L; for(int i=1;i<=n;i++) { newp=new LNode; cout<<"请输入第"<

一元多项式计算器

一元多项式计算器 目录 摘要 (1) 1绪论 (1) 2系统分析 (1) 2.1功能需求 (1) 2.2数据需求 (1) 2.3性能需求 (1) 3总体设计 (2) 3.1系统设计方案 (2) 3.2功能模块设计 (2) 4详细设计 (3) 4.1建立多项式 (4) 4.2多项式相加 (4) 4.3多项式相减 (5) 4.4多项式相乘 (5) 4.5计算器主函数 (6) 5调试与测试 (7) 5.1调试 (7) 5.2测试 (8) 6结论 (9) 结束语 (9) 参考文献 (9) 附录1-用户手册 (10) 附录2-源程序 (12)

摘要 随着生活水平的提高,现代科技也日益发达。日常生活中多位计算再所难免,因此设计一个简单计算器可解决许多不必要的麻烦。 开发这样一个程序主要运用了C的结点,链表等方面知识。系统主要实现了多项式的建立,多项式的输入输出,以及多项式加减乘等运算。 报告主要从计算器的程序段,对输入输出数据的要求,计算器的性能,以及总体的设计来介绍此计算器程序的实现过程。 关键词:多项式;链表;结点 1绪论 随着日益发达的科技,计算器已应用于各行各业。设计一个计算器需要运用C中多方面知识,更是以多项式的建立,输入输出,以及结点,链表为主。(扩充) 任务书。。。。。 2系统分析 2.1 功能需求 多项式的建立多项式输入输出多项式加减乘等运算 2.2数据需求 在输入过程中,首先要确定输入的数据,数据不能是字母,只能是数字。不能连续输入数据,必须按要求配以空格输入要计算的数据。 (1) 链节节点数字 (2) 数字 2.3 性能需求 系统必须安全可靠,不会出现无故死机状态,速度不宜过慢。

一元多项式计算(数据结构课程设计)

一元多项式计算(数据结构课程设计)

一、系统设计 1、算法思想 根据一元多项式相加的运算规则:对于两个一元多项式中所有指数相同的项,对应指数相加(减),若其和(差)不为零,则构成“和(差)多项式”中的一项;对于两个一元多项式中所有指数不相同的项,则分别写到“和(差)多项式”中去。 因为多项式指数最高项以及项数是不确定的,因此采用线性链表的存储结构便于实现一元多项式的运算。为了节省空间,我采用两个链表分别存放多项式a 和多项式b,对于最后计算所得的多项式则利用多项式a进行存储。主要用到了单链表的插入和删除操作。

(1)一元多项式加法运算 它从两个多项式的头部开始,两个多项式的某一项都不为空时,如果指数相等的话,系数就应该相加;相加的和不为零的话,用头插法建立一个新的节点。P 的指数小于q的指数的话就应该复制q的节点到多项式中。P的指数大于q的指数的话,就应该复制p节点到多项式中。当第二个多项式空,第一个多项式不为空时,将第一个多项式用新节点产生。当第一个多项式空,第二个多项式不为空时,将第二个多项式用新节点产生。 (2)一元多项式的减法运算 它从两个多项式的头部开始,两个多项式的某一项都不为空时,如果指数相等的话,系数就相减;相加的和不为零的话,用头插法建立一个新的节点。p的指数小于q的指数的话,就应该复制q的节点到多项式中。P的指数大于q的指数的话就应该复制p的节点到多项式中,并且建立的节点的系数为原来的相反数;当第二个多项式空,第一个多项式不为空时,将第一个多项式用新节点产生。当第一个多项式空,第二个多项式不为空时,将第二个多项式用新节点产生,并且建立的节点的系数为原来的相反数。 2、概要设计 (1)主函数流程图: (注:a代表第一个一元二次方程,b代表第二个一元二次方程)

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

#include #include using namespace std; typedef struct PolyNode { int coef; //系数 int expn; //指数 struct PolyNode *next; } *PNode; //多项式结点的指针 void InitPoly(PNode &head,PNode &p) { head=(PNode)malloc(sizeof(struct PolyNode)); head->next=NULL; head->coef=0; head->expn=-1; p=head; } void CreatePoly(PNode &head,int a,int n) { PNode s; s=(PNode)malloc(sizeof(struct PolyNode)); //建立新的结点s->coef=a; s->expn=n; s->next=NULL; head->next=s; head=s; } void PrintPoly(PNode head) { int i=1;//控制第一对系数指数的显示 head=head->next;//指向表头结点的下一个 PNode p; p=head; while ((p->next)!=NULL) { if(i) //显示第一对的时候是不需要显示加号的 { if (p->expn==1) cout<coef<<"x"; else if (p->expn==0) cout<coef<

else cout<coef<<"x^"<expn; i=0; } else { if (p->expn==1) cout<coef<<"+x"; else if (p->expn==0) cout<<"+"<coef<coef<<"x^"<expn; } p=p->next; } cout<next; pb=pb->next; p=pc; while (pa!=NULL && pb!=NULL) { if (pa->expn>pb->expn) { s=(PNode)malloc(sizeof(struct PolyNode)); s->coef=pa->coef; s->expn=pa->expn; s->next=NULL; p->next=s; p=s; pa=pa->next; } else if (pa->expnexpn) { s=(PNode)malloc(sizeof(struct PolyNode)); s->coef=pb->coef; s->expn=pb->expn; s->next=NULL; p->next=s; p=s; pb=pb->next; }

相关文档
最新文档