数据结构-多项式

合集下载

多项式运算(数据结构C++描述)

#include using namespace std;struct node //定义节点类型{ float coef; int expn; node * next; }; class list{public: list();void start(); //用户选择界面 void insert(node *head, node *inpt); //查找位置插入新链节程序node *creat(char ch); //输入多项式 node *addnode(node *head,node *pre); //多项式相加 node *minusnode(node *head,node *pre); //多项式相减node *bynode(node *head1,node *head2); //多项式相乘 node *diffnode(node *head); //多项式微分node *intnode(node *head); //多项式积分 void print(node *fun); //输出多项式 private:node *head;};list::list(){head = new node;head -> next = NULL;}void list::start()//用户选择界面 { cout<<"************************************\n"; cout<<" 两个一元多项式的相加，相减，相乘，微分，积分:\n"; cout<<"************************************\n"; cout<<"请选择操作:\n"; cout<<"0.退出\n"; cout<<"1.两个一元多项式相加\n"; cout<<"2.两个一元多项式相减\n";cout<<"3.两个一元多项式相乘\n"; cout<<"4.一个一元多项式微分\n";cout<<"5.一个一元多项式积分\n";} void list::insert(node *head, node *inpt)//查找位置插入新链节程序 { node *pre,*now; int signal = 0; pre = head;//pre定义为现在的前一个链节 if(pre->next == NULL) {pre->next = inpt;} else {now = pre->next; while(signal == 0) { if(inpt->expn < now->expn)//当新链节小于现在的连接时向后移一个链节 { if(now->next == NULL) { now->next = inpt; signal = 1; } else { pre = now; now = pre->next; } } else if(inpt->expn > now->expn)//如果发现比现在的链节大了就插入到这个连接的前面 { inpt->next = now; pre->next = inpt; signal = 1;} else { now->coef = now->coef + inpt->coef; signal = 1; if(now->coef == 0) { pre->next = now->next; } } } } } node *list::creat(char ch)//输入多项式 { node *head,*inpt; float x; int y; head = new node;//创建链表头 head->next = NULL; cout<<"请输入一元多项式">x>>y; while(x!=0 || y!=0) { inpt = new node;//创建新链节 inpt->coef = x; inpt->expn = y; inpt->next = NULL; insert(head,inpt);//不然就查找位置并且插入新链节 cout<<"请输入一元多项式">x>>y; } return head; } node *list::addnode(node *head,node *pre)//多项式相加 { node *inpt; int flag = 0; while(flag == 0) { if(pre->next == NULL) flag = 1;//当现在指向空时跳出循环

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

一元多项式是数学中常见的一种代数表达式形式，由多个单项式按照一定的规则相加而成。在计算机科学中，为了方便对一元多项式进行处理，需要定义一种合适的数据结构来表示和操作一元多项式的加法运算。

一元多项式的加法数据结构可以使用链表来实现。每个节点表示一个单项式，包含两个成员变量：系数和指数。系数表示单项式的系数，指数表示单项式的指数。通过将多个单项式的系数和指数组织成一个链表，即可表示一个一元多项式。

在链表中，每个节点按照指数从小到大的顺序排列。这样可以方便进行多项式的加法运算。当两个一元多项式相加时，只需按照指数的大小依次比较两个链表中的节点，并根据指数的大小关系进行相应的操作。

具体的加法算法如下：

1. 创建一个新的链表作为结果链表。

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

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

4. 比较当前节点的指数大小关系：

- 如果两个节点的指数相等，将它们的系数相加，并将结果添加到结果链表中。

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

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

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

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

通过上述算法，可以实现对一元多项式的加法运算。这种链表结构的一元多项式加法数据结构具有以下优点：

- 灵活性：可以表示任意长度的一元多项式，不受固定数组长度的限制。

数据结构-多项式相加

数据结构课程设计

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

（（p1,e1）,(p2,e2),……,(pm,em)）便可惟一确定多项式pn(x)。

②用两个带表头结点的单链表分别存储两个多项式

③根据一元多项式相加的运算规则：对于两个一元多项式中所有指数相同的项，对应系数相加，若其和不为零，则构成“和多项式”中的一项；

④只需要将第二个多项式的系数改为其相反数，然后根据一元多项式相加的运算规则便可以得到其相应的“差多项式”

【

【实现提示】

用带表头结点的单链表存储多项式。

【程序代码】

#include

typedef struct node

{

float coef;

int expn;

struct node *next;

}Lnode, *polynmial;

void create(polynmial &L); //输入并建立多项式L

void display(polynmial L); //显示，输出多项式L

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

一、问题分析.................................... 错误!未定义书签。

问题描述 ........................................................................ 错误!未定义书签。

问题的数学模型............................................................. 错误!未定义书签。

构造数据结构................................................................. 错误!未定义书签。

二、系统分析 ...................................................................... 错误!未定义书签。

可行性研究..................................................................... 错误!未定义书签。

系统结构与主要功能模块 ............................................. 错误!未定义书签。

三、系统设计 ...................................................................... 错误!未定义书签。

系统设计目的与要求 ....................................................... 错误!未定义书签。

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

一元多项式是数学中常见的一种表达形式，它可以表示为各个项的和，每个项由一个系数和一个幂次组成。在实际应用中，一元多项式的加法操作非常常见，因此设计一个高效的数据结构来表示和计算一元多项式的加法是非常重要的。

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

对于第一个问题，我们可以使用链表来存储一元多项式的各个项。链表的每个节点可以表示一个多项式的项，其中包含两个数据成员：一个表示系数的值，一个表示幂次的值。通过链表的链接关系，可以按照幂次的从小到大的顺序存储一元多项式的各个项，从而方便后续的加法运算。

对于第二个问题，我们可以设计一个函数来实现一元多项式的加法运算。该函数接受两个参数，分别是待相加的两个一元多项式。在函数内部，我们需要遍历两个链表，按照幂次的大小比较来确定相应的操作。具体的步骤如下：

1. 创建一个新的链表，用于存储相加后的结果。

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

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

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

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

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

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

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

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

数据结构_一元多项式运算器_cpp代码(visual c++)

/*一元多项式运算器的基本功能：(1)创建多项式； (2)打印显示多项式；(3)销毁多项式； (4)复制多项式；(5)求两个多项式的和； (6)求两个多项式的差；(7)求两个多项式的积； (8)求一个多项式的n次幂；(9)计算一个多项式在x=a处的值。可选做的高级功能：(1)求两个多项式的商和余式； (2)求两个多项式的最大公约式和最小公倍式；(3)求一个多项式的n阶导函数； (4)求一个多项式的不定积分；(5)求一个多项式在区间[a, b]上的定积分。*/#include #include #include //#include 做字符串读取，便于用户输入#define N 10 //定义存储多项式的个数#define STACK_INIT_SIZE 5typedef double ElemType;//结点定义typedef struct LNode {ElemType cof; //多项式系数int ind; //多项式次幂struct LNode* next;} * LinkList;//LinkList是指向LNode的指针！！！！//多项式的创建(OK)void multinomialCreat(LinkList &L){L = (LNode*)malloc(sizeof(LNode)); L->next = NULL; //创建带头结点的链表对多项式进行存储LNode *s,*rear = L; //尾插法，创建多项式printf("How many terms does the multinomial have?\n");scanf("%d",&L->ind);//用头结点的ind保存多项式项数for(int i = 0;i < L->ind;i++){s = (LNode*)malloc(sizeof(LNode));printf("Please input the multinomial in descending order, every term\'s coefficent and index in form\"a,b\".\n");scanf("%lf,%d",&s->cof,&s->ind);s -> next = NULL; rear->next = s;rear = s;}}//降幂创建多项式//打印多项式(OK)void multinomialPrint(LinkList L){LinkList p = L->next;char c = '+';if(L->next==NULL){p = L;p->cof = 0;p->ind = 0;} //当多项式为0的时候printf("f(x) = ");for(int i = 0;i < L->ind -1;i++){if(p->cof > 0)printf("%c%.3lfx^%d",c,p->cof,p->ind);elseprintf("%.3lfx^%d",p->cof,p->ind);p = p->next;}if(p->ind==0){ //当最后一项是常数项时if(p->cof > 0)printf("%c%.3lf",c,p->cof);elseprintf("%.3lf",p->cof);}else{if(p->cof > 0)printf("%c%.3lfx^%d",c,p->cof,p->ind);elseprintf("%.3lfx^%d",p->cof,p->ind);}printf("\n");}//复制多项式void multinomialCopy(LinkList La,LinkList &L){L = (LNode*)malloc(sizeof(LNode)); //设置头结点L->ind = La->ind;LinkList p = La->next,s,rear;rear = L;while(p){s = (LNode*)malloc(sizeof(LNode));s->cof = p->cof;s->ind = p->ind;rear ->next = s;rear = s;p = p->next;}rear->next = NULL;}//销毁多项式(OK)void multinomialDestroy(LinkList &L){LinkList p,q;q = L;p = q->next;L = NULL;while(p!=NULL){free (q);q = p;p = p->next;}}//多项式相加,存储在指定的数组位置void multinomialPlus(LinkList

数据结构《一元多项式》

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

本实验的目的是进一步熟练掌握应用链表处理实际问题的能力。

一、问题描述

通过键盘输入两个形如Po+P₁X¹+P₂X²+…+PX的多项式，经过程序运算后在屏幕上输出它们的相加和。

二、数据结构设计

分析任意一元多项式的描述方法可知，一个一元多项式的每一个子项都由“系数-指数”两部份组成，因此可将其抽象为包含系数coef、指数 exp、指针域next 构成的链式线性表。对多项式中系数为0的子项可以不记录它的指数值，将两个多项式分别存放在两个线性表中，然后经过相加后将所得多项式存放在一个新的线性表中，但是不用再开辟新的存储空间，只依靠结点的挪移来构成新的线性表，期间可以将某些不需要的空间回收。基于这样的分析，可以采用不带头结点的单链表来表示一个一元多项式。具体数据类型定义为：

struct node

float coef;//系数域

int exp; //指数域

struct node *next;

};

三、功能函数设计

1、输入并建立多项式的功能模块

具体函数为node *in f un()

此函数的处理较为全面，要求用户按照指数递增的顺序和一定的输入格

式输入各个系数不为0的子项，输入一个子项建立一个相关结点，当遇到输入结束标志时住手输入。关键步骤具体如下：

(1)控制用户按照指数递增的顺序输入

r=a;

while(r!=q->next)

if(y<=r->exp)

cout<<"请按照指数递增顺序输入，请重新输入";

cin>>x>>y;

多项式求和

create_list(&g);

printf("g(x)=");

show_list(g);

printf("多项式f(x)和g(x)的和 ");

add_List (f,g,&h);

printf("h(x)=");

show_list(h);

}

5．测试数据与实验结果（可以抓图粘贴）

6.结果分析与实验体会

程序成功运行，实验成功。我觉得我刚刚看到题目，第一反应是好难啊。但经过思考后，根据题目的提示，定义了顺序表数据结构类型，在三个函数中，我首先构建的是

C语言数据结构之一元多项式的求导

C语⾔数据结构之⼀元多项式的求导//⼀元多项式的求导

#include<stdio.h>

#include<malloc.h>//动态申请空间的函数的头⽂件

typedef struct node //定义节点类型

{

float coef; //多项式的系数

int expn; //多项式的指数

struct node * next; //结点指针域

}PLOYList;

void insert(PLOYList *head,PLOYList *input) //查找位置插⼊新链节的函数，且让输⼊的多项式呈降序排列{

PLOYList *pre,*now;

int signal=0;

pre=head;

if(pre->next==NULL) {pre->next=input;} //如果只有⼀个头结点，则把新结点直接连在后⾯

else

{

now=pre->next;//如果不是只有⼀个头结点，则设置now指针

while(signal==0)

{

if(input->expn < now->expn)

{

if(now->next==NULL)

{

now->next=input;

signal=1;

}

else

{

pre=now;

now=pre->next;//始终让新输⼊的数的指数与最后⼀个结点中的数的指数⽐较，⼩于则插在其后⾯

}

else if( input->expn > now->expn )

{

input->next=now;

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

实验一一元多项式的表示与相加

实验目的：

1.复习并熟练掌握数据结构所使用的程序设计语言——C语言；

2.学会单步跟踪、调试自己的程序；

3.加深对线性表特别是链表知识的理解和掌握，并能够运用相关知识来解决相关的具体问题，如一元多项式相加等；

程序流程：

1.定义一元多项式链表结构体类型；

2.输入多项式项数以分配存储空间；

3.输入多项式每项的系数和指数，将其插入当前多项式链表。同时判断是否有与当前节点指数相同的项，若存在，则将两项系数相加合并。此外，若存在系数为0的项，将其存储空间释放；

4.进行多项数加法时，新建一个存储结果的链表，分别将两多项式各项依次插入结果多项式即完成多项式相加运算；

5.进行多项数加法时，将减项多项式各项系数化为相反数后进行加法操作，即完成多项式相减运算；

6.对x赋值后，将x值代入多项式进行运算得到多项式的值；

7.输出多项式。

注意：进行完一次运算以后，应该及时销毁无用多项式以释放空间以便再次应用。

算法及注释：

1）定义一元多项式链表结构体类型

typedef struct Lnode{

float cof; //定义系数

int exp; //定义指数

struct Lnode *next; //定义指针变量指向下一个节点

}Lnode ,*Linklist; //定义新的变量类型

2）建立多项式存储线性链表头结点

void makehead(Linklist &head){

head=(Linklist)malloc(sizeof(Lnode)); //建立新的节点

head->exp=-1;

数据结构多项式相加实验报告doc

数据结构多项式相加实验报告

篇一：数据结构实验多项式加法

数据结构实验报告

实验名称：多项式加减法

学号：1XX10419

姓名：林强

实验日期：XX.5.05

一、实验目的

通过实现多项式的加减法，对链表有更深入的了解

二、实验具体内容

1、实验题目1：

（1）题目设计一个一元稀疏多项式简单的加减法计算器

实

现要求：

一元稀疏多项式简单计算器的基本功能是：

（1）输入并建立多项式：

A(x)?7?3x?9x8?5x17；

B(x)?8x?22x7?9x8

（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

数据结构（大专）第一章习题解答

第一章绪论

1．2 设计二次多项式ax2+bx+c的一种抽象数据类型，假定起名为QUAdratic，该类型的数据部分为三个系数项a、b和c，操作部分为：

1.初始化数据成员a、b和c（假定用记录类型Quadratic定义数据成员），每个

数据成员的默认值为0。

Qiadratic InitQuadratic(float aa=0, float bb=0, float cc=0);

解：

Quadratic InitQuadratic(float aa, float bb, float cc)

｛

Quadratic q;

q·a=aa;

q·b=bb;

q·c=cc;

return q;

｝

2.做两个多项式加法，即使对应的系数相加，并返回相加结果。

解：Quadratic Add(Quadratic q1,Quadratic q2);

｛

Quadratic q;

q·a=q1·a+q2·a;

q·b=q1·b+q2·b;

q·c=q1·c+q2·c;

retirn q;

｝

3.据给定x的值计算多项式的值。

float Eval(Quadratic q,float x);

解：

float Eval(Quadratic q, float x)

｛

return(q·a*x*x+q·b*x+q·c);

｝

4.计算方程ax2+bx+c=0的两个实数根，对于有实根、无实根和不是二次方程（即

a= =0）这三种情况都要返回不同的整数值，以便调用函数做不同的处理。

int Root(Quadratic q, float& r1, float& r2);

数据结构一元稀疏多项式

要求完成如下功能：

（1）输入并建立多项式——creatpolyn()

（2）输出多项式，输出形式为整数序列，序列按指数升序排列——printpolyn() （3）多项式a和b相加，建立多项式a+b，输出相加的多项式——addpolyn() （4）多项式a和b相减，建立多项式a-b，输出相减的多项式——subpolyn()

用带表头结点的单链表存储多项式。

课程设计

学生姓名：学号：

专业班级：

课程名称：数据结构

学年学期：

指导教师：

1．需求分析说明 (1)

2．概要设计说明 (3)

3．详细设计说明 (5)

4．调试分析 (10)

5．用户使用说明 (11)

6．课程设计总结 (12)

7．测试结果 (13)

8．参考书目 (16)

9. 附录 (17)

1 需求分析说明

1.程序所能达到的功能是

（1）输入并建立多项式——creatpolyn()

（2）输出多项式，输出形式为整数序列，序列按指数升序排列——printpolyn() （3）多项式a和b相加，建立多项式a+b，输出相加的多项式——addpolyn()

（4）多项式a和b相减，建立多项式a-b，输出相减的多项式——subpolyn()

用带表头结点的单链表存储多项式。

2．输入的形式和输入值的范围：本系统要输入的数据主要是有多项式中每项的系数和指数，可以把它们定义为整形数据，既可以为整数也可以为非负整数，即有符号的整形数据，由于整形数据在内存里占用两个字节，所以它的取值范围为-32768—32767。其次还有就是选择功能时，要输入的功能号，它们是字符型数据，取值范围是ASS||表中的字符。例如输入的格式如下：

数据结构多项式相加

public interface LList<E> //线性表接口

{

boolean isEmpty(); //判断线性表是否为空

int length(); //返回线性表长度

E get(int index); //返回序号为index的对象

E set(int index, E element); //设置序号为index对象为

boolean add(int index, E element);

//插入element对象，插入后对象序号为index

boolean add(E element); //插入element对象，插入位置没有约定

E remove(int index); //移去序号为index的对象，返回被移去对象

void clear(); //清空线性表

}

2.用栈实现括号的匹配

public interface SStack<E> {

boolean isEmpty(); //判断是否空栈

boolean push(E element); //入栈

E pop(); //出栈

E get(); //取栈顶元素值

}

三．实验详细设计

1.用单链表实现多项式相加

创建三个类：结点类，链表类，主类

结点类：创建结点，每个结点包括指数域，系数域，后继结点链，创建构造方法和带有参数的方法，获取，设置指数和系数，返回后继结点

链表类：创建构造函数，设置并获得表头。插入元素，多项式按照降幂排列，创建方法实现两链表相加，打印多项式链表

主类：提示输入第两个多项式的长度和数据，存贮数据在两个数组之中，创建两个链表，并分别将数组的头地址赋给该链表，使用循环将元素插入后输出连个多项式和结果。

数据结构多项式的表示和实现方法

摘要：

1.多项式的基本概念

2.多项式的表示方法

a.系数矩阵表示

b.字符串表示

c.列表表示

3.多项式的基本操作

a.加法

b.减法

c.乘法

d.除法

4.多项式的实现方法

a.递归实现

b.循环实现

c.迭代实现

5.多项式的应用场景

a.数值计算

b.符号计算

c.算法设计分析

6.多项式的优缺点分析

7.总结与展望

正文：

一、多项式的基本概念

多项式作为数学中的重要概念，广泛应用于各个领域。它是由一系列项组成的代数式，其中每个项包含一个常数系数和一个或多个变量，这些变量之间的运算符为加法或减法。多项式的项按照幂次从高到低排列，同一幂次的项按照系数从大到小排列。

二、多项式的表示方法

1.系数矩阵表示：将多项式的系数组成一个矩阵，其中行表示多项式的次数，列表示多项式的项数。例如，二次多项式f(x)=ax+bx+c可以表示为：| a b c |

| 0 1 0 |

2.字符串表示：将多项式的各项用字符串表示，如f(x)=ax+bx+c可以表示为"a*x+b*x+c"。

3.列表表示：将多项式的各项用列表表示，如[a, b, c, 0]。

三、多项式的基本操作

1.加法：将两个多项式对应的项相加，保持幂次不变，系数相加。

2.减法：将两个多项式对应的项相减，保持幂次不变，系数相减。

3.乘法：将两个多项式按照乘法法则相乘，得到一个新的多项式。

4.除法：将一个多项式除以另一个多项式，得到一个新的多项式。

四、多项式的实现方法

1.递归实现：利用多项式的定义，将多项式分解为单项式，然后通过递归

实现加法、减法、乘法和除法。

数据结构—多项式求和

实验一多项式求和实验

一、程序验证

1、源代码：

#include<iostream.h>//cout,cin

#include"process.h"//exit()

#define Max 20

typedef struct

{

float coef;

int exp;

}PolyArray[Max];

struct PolyNode

{

float coef;

int exp;

PolyNode *next;

};

class Poly

{

private:

PolyNode *head;

public:

Poly();//构造函数，建立空多项式

~Poly();//析构函数，释放多项式

void Create(PolyArray a,int n);//键盘输入，创建多项式链表

void Disp();//多项式显示

void Sort();//有序表排序

void Add (Poly LB);//多项式加

//void Substract(PolyNode * hbQ);//多项式减

//void Multiply(PolyNode * hb);//多项式乘

};

Poly::Poly()

{ //创建一空多项式

head=new PolyNode;

head->next=NULL;

}

Poly::~Poly()

{//释放多项式所占空间

PolyNode *p;

while(head!=NULL)

{//从头结点开始，依次释放结点

p=head;

head=head->next;

delete p;

}

head=NULL;//头结点指向空

数据结构-多项式

多项式运算(数据结构C++描述)

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

数据结构-多项式相加

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

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

数据结构_一元多项式运算器_cpp代码(visual c++)

数据结构《一元多项式》

多项式求和

C语言数据结构之一元多项式的求导

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

数据结构多项式相加实验报告doc

数据结构（大专）第一章习题解答

数据结构一元稀疏多项式

数据结构多项式相加

数据结构 多项式的表示和实现方法

数据结构—多项式求和

数据结构多项式的表示和实现方法