数据结构-实验2-多项式求和

合集下载

数据结构多项式求和

数据结构多项式求和

数据结构多项式求和在计算机科学和数学领域中,数据结构的运用无处不在,而多项式求和就是一个典型的应用场景。

让我们一起来深入探讨一下这个有趣且重要的主题。

首先,我们需要明确什么是多项式。

简单来说,多项式就是由变量和系数组成的表达式。

比如,3x²+ 2x 1 就是一个多项式,其中 3 、2 、-1 是系数,x 是变量,²是指数。

那么为什么要对多项式进行求和呢?这在很多实际问题中都有应用。

比如在物理学中,描述某些运动规律时会用到多项式;在工程学中,对信号的处理和建模也可能涉及到多项式求和。

接下来,我们看看如何用数据结构来表示多项式。

常见的数据结构有数组和链表。

用数组来表示多项式时,我们可以将系数存储在数组中。

假设一个多项式的最高次幂为n ,那么我们可以创建一个长度为n +1 的数组,数组的下标对应多项式的幂次,数组元素的值就是对应的系数。

这种表示方法简单直观,但是如果多项式的次数很高,而很多项的系数为0 ,就会浪费很多存储空间。

相比之下,链表是一种更灵活的数据结构。

每个节点可以存储系数、指数和指向下一个节点的指针。

这样,只有非零项才会被存储,节省了存储空间。

有了表示多项式的数据结构,接下来就是实现求和的算法。

对于用数组表示的多项式求和,我们需要从最高次幂开始,将对应幂次的系数相加。

如果相加后的系数为 0 ,那么在最终的结果中可以省略这一项。

而对于链表表示的多项式求和,我们需要遍历两个链表,找到相同幂次的项进行系数相加。

如果一个链表遍历完了,而另一个链表还有剩余项,直接将剩余项添加到结果链表中。

在实际编程中,还需要考虑一些特殊情况。

比如,如果两个多项式的最高次幂不同,那么在求和时要注意补齐。

另外,算法的效率也是我们需要关注的重点。

在选择数据结构和算法时,要根据具体的应用场景和需求来权衡空间复杂度和时间复杂度。

例如,如果多项式的操作频繁,而对空间要求不是很严格,那么使用数组可能更合适;如果多项式的项数不固定,而且有很多零系数项,链表可能是更好的选择。

《数据结构》实验报告

《数据结构》实验报告

苏州科技学院数据结构(C语言版)实验报告专业班级测绘1011学号10201151姓名XX实习地点C1 机房指导教师史守正目录封面 (1)目录 (2)实验一线性表 (3)一、程序设计的基本思想,原理和算法描述 (3)二、源程序及注释(打包上传) (3)三、运行输出结果 (4)四、调试和运行程序过程中产生的问题及采取的措施 (6)五、对算法的程序的讨论、分析,改进设想,其它经验教训 (6)实验二栈和队列 (7)一、程序设计的基本思想,原理和算法描述 (8)二、源程序及注释(打包上传) (8)三、运行输出结果 (8)四、调试和运行程序过程中产生的问题及采取的措施 (10)五、对算法的程序的讨论、分析,改进设想,其它经验教训 (10)实验三树和二叉树 (11)一、程序设计的基本思想,原理和算法描述 (11)二、源程序及注释(打包上传) (12)三、运行输出结果 (12)四、调试和运行程序过程中产生的问题及采取的措施 (12)五、对算法的程序的讨论、分析,改进设想,其它经验教训 (12)实验四图 (13)一、程序设计的基本思想,原理和算法描述 (13)二、源程序及注释(打包上传) (14)三、运行输出结果 (14)四、调试和运行程序过程中产生的问题及采取的措施 (15)五、对算法的程序的讨论、分析,改进设想,其它经验教训 (16)实验五查找 (17)一、程序设计的基本思想,原理和算法描述 (17)二、源程序及注释(打包上传) (18)三、运行输出结果 (18)四、调试和运行程序过程中产生的问题及采取的措施 (19)五、对算法的程序的讨论、分析,改进设想,其它经验教训 (19)实验六排序 (20)一、程序设计的基本思想,原理和算法描述 (20)二、源程序及注释(打包上传) (21)三、运行输出结果 (21)四、调试和运行程序过程中产生的问题及采取的措施 (24)五、对算法的程序的讨论、分析,改进设想,其它经验教训 (24)实验一线性表一、程序设计的基本思想,原理和算法描述:程序的主要分为自定义函数、主函数。

《数据结构》线性结构实验报告

《数据结构》线性结构实验报告

《数据结构》线性结构实验报告2、源程序:#include <stdio.h>#include<stdlib.h>#define MAXSIZE 1024typedef int elemtype;typedef struct SequenStack{elemtype data[MAXSIZE];int top;}SequenStack;SequenStack * Init_SequenStack(){SequenStack * S;S = (SequenStack *)malloc(sizeof(SequenStack));if (S == NULL)return S;S->top = -1;return S;}int SequenStack_Empty(SequenStack * S)//判栈空{if (S->top == -1){return 1;}{int a;printf("请以十进制输入一个数:\n");scanf_s("%d", &a);printf("转化为二进制为:");Conversion(a);printf("\n");}运行结果:3、源程序:#include<stdio.h>#include<stdlib.h>#include<string.h>typedef struct node{char data;struct node* next;}LinkStack;//初始化LinkStack* Init_LinkStack(){LinkStack* top;top = (LinkStack*)malloc(sizeof(LinkStack));top->next = NULL;return top;}//入栈void Push_LinkStack(LinkStack* top, char x){LinkStack* node;node = (LinkStack*)malloc(sizeof(LinkStack));node->data = x;node->next = top->next;top->next = node;}运行结果:4、源程序:#include <stdio.h>#include<stdlib.h>#include<string.h>#define MAXSIZE 20typedef int elemtype;typedef struct QueueNode{elemtype data;struct QueueNode* next;}LinkedQueueNode;typedef struct LQueue{LinkedQueueNode* front;LinkedQueueNode* rear;}LQueue, *LinkedQueue;typedef struct Person{char name[MAXSIZE];char sex;}Person;typedef char* ElemType;//链队初始化LinkedQueue Init_LinkedQueue(){LinkedQueue Q = (LinkedQueue)malloc(sizeof(LQueue));LinkedQueueNode * head = (LinkedQueueNode *)malloc(sizeof(LinkedQueueNode));if (head != NULL && Q != NULL){head->next = NULL;Q->front = head;Q->rear = head;printf("输入参与者的姓名,性别\n");for (i = 0; i < num; i++){printf("输入第%d个舞者的名字:\n", i + 1);scanf_s("%s", &dancer[i].name, 10);printf("输入第%d个人的性别(F/M):\n", i + 1);scanf_s("%s", &dancer[i].sex, 10);while (dancer[i].sex != 'F' && dancer[i].sex != 'M'){printf("输入错误,请重新输入第%d个人的性别(F/M):\n", i + 1);scanf_s("%s", &dancer[i].sex, 10);}}DancePartner(dancer, num);break;case 0:printf("感谢你的使用!\n");break;default:printf("无此选项!\n");break;}} while (n != 0);return 0;}运行结果:。

算法与数据结构实验报告实验一 完成多项式的相加运算

算法与数据结构实验报告实验一 完成多项式的相加运算

实验一:完成多项式的相加运算(验证性、4学时)一、实验目的完成多项式的相加、相乘运算。

(1)掌握线性表的插入、删除、查找等基本操作设计与实现(2)学习利用线性表提供的接口去求解实际问题(3)熟悉线性表的的存储方法二、实验内容设计一个一元多项式的简单计算程序,其基本功能有:(1)输入并建立多项式;(2)输出多项式;(3)多项式的相加运算。

利用单链表实现。

三、算法描述及实验步骤1描述1、创建两个单链表A、B,分别调用CreatePolyn();2、输出多项式,分别调用PrintPolyn();3、多项式相加运算AddPolyn()。

2算法流程图4 65inputA-B inputA-B inputA-B end3代码(注释)#include<stdio.h>#include<malloc.h>#include<math.h>typedef struct Polynomial{float coef;//系数变量int exp;//指数变量struct Polynomial *next;//定义next指针}*Polyn,Polynomial; //Polyn为结点指针类型void Insert(Polyn p,Polyn h) //插入新的结点p{if(p->coef==0) free(p); //系数为0的话释放结点else{Polyn q1,q2;q1=h;q2=h->next;while(q2&&p->exp<q2->exp) //查找插入位置{q1=q2;q2=q2->next;}if(q2&&p->exp==q2->exp) //将指数相同相合并{q2->coef+=p->coef;free(p);if(!q2->coef) //系数为0的话释放结点{q1->next=q2->next;free(q2);}}else //指数为新时将结点插入{p->next=q2;q1->next=p;}}}//Insertint f(float x)//判断输入是否为整形{float a;a=x-(long int)x;if(a==0&&x==fabs(x))return 1;elsereturn 0;}Polyn CreatePolyn(Polyn head,int m) //建立一个头指针为head、项数为m的一元多项式{int i;Polyn p;p=head=(Polyn)malloc(sizeof(struct Polynomial));head->next=NULL;for(i=0;i<m;i++){p=(Polyn)malloc(sizeof(struct Polynomial));//建立新结点以接收数据printf("please input NO.%d coef and exp:",i+1);scanf("%f %d",&p->coef,&p->exp);while(!f(p->coef)&&!f(p->exp)){printf("输入有错,请重新输入: ");scanf("%f %d",&p->coef,&p->exp);}Insert(p,head); //调用Insert函数插入结点}return head;}//CreatePolynvoid DestroyPolyn(Polyn p) //销毁多项式p{Polyn q1,q2;q1=p->next;q2=q1->next;while(q1->next){free(q1);q1=q2;//指针后移q2=q2->next;}}void PrintPolyn(Polyn P)//输出多项式{Polyn q=P->next;int flag=1; //项数计数器if(!q) //若多项式为空,输出0{putchar('0');printf("\n");return;}while (q){if(q->coef>0&&flag!=1) putchar('+'); //系数大于0且不是第一项if(q->coef!=1&&q->coef!=-1) //系数非1或-1的普通情况{printf("%g",q->coef);if(q->exp==1) putchar('X');else if(q->exp) printf("X^%d",q->exp);}else{if(q->coef==1){if(!q->exp) putchar('1');else if(q->exp==1) putchar('X');else printf("X^%d",q->exp);}if(q->coef==-1){if(!q->exp) printf("-1");else if(q->exp==1) printf("-X");else printf("-X^%d",q->exp);}}q=q->next;flag++;}//whileprintf("\n");}//PrintPolynint compare(Polyn a,Polyn b){if(a&&b){if(!b||a->exp>b->exp) return 1;else if(!a||a->exp<b->exp) return -1;else return 0;}else if(!a&&b) return -1;//A多项式已空,但B多项式非空else return 1;//B多项式已空,但A多项式非空}//comparePolyn AddPolyn(Polyn pa,Polyn pb)//求解并建立多项式A+B,返回其头指针{Polyn qa=pa->next;Polyn qb=pb->next;Polyn headc,hc,qc;hc=(Polyn)malloc(sizeof(struct Polynomial)); //建立头结点hc->next=NULL;headc=hc;while(qa||qb){qc=(Polyn)malloc(sizeof(struct Polynomial));switch(compare(qa,qb)) //功能选择{ case 1:{qc->coef=qa->coef;qc->exp=qa->exp;qa=qa->next;break;}case 0:{qc->coef=qa->coef+qb->coef;qc->exp=qa->exp;qa=qa->next;qb=qb->next;break;}case -1:{qc->coef=qb->coef;qc->exp=qb->exp;qb=qb->next;break;}}//switchif(qc->coef!=0){qc->next=hc->next;hc->next=qc;hc=qc;}else free(qc);//当相加系数为0时,释放该结点}//whilereturn headc;}//AddPolynPolyn SubtractPolyn(Polyn pa,Polyn pb){//求解并建立多项式A-B,返回其头指针Polyn h=pb;Polyn p=pb->next;Polyn pd;while(p){ //将pb的系数取反p->coef*=-1;p=p->next;}pd=AddPolyn(pa,h);for(p=h->next;p;p=p->next) //恢复pb的系数p->coef*=-1;return pd;}//SubtractPolynPolyn MultiplyPolyn(Polyn pa,Polyn pb){//求解并建立多项式A*B,返回其头指针Polyn hf,pf;Polyn qa=pa->next;Polyn qb=pb->next;hf=(Polyn)malloc(sizeof(struct Polynomial));//建立头结点hf->next=NULL;for(;qa;qa=qa->next){for(qb=pb->next;qb;qb=qb->next){pf=(Polyn)malloc(sizeof(struct Polynomial));pf->coef=qa->coef*qb->coef;pf->exp=qa->exp+qb->exp;Insert(pf,hf);//调用Insert函数以合并指数相同的项}}return hf;}//MultiplyPolynvoid DevicePolyn(Polyn pa,Polyn pb){//求解并建立多项式A/B,返回其头指针Polyn hf,pf,af,temp1,temp2,q;Polyn qa=pa->next;Polyn qb=pb->next;hf=(Polyn)malloc(sizeof(struct Polynomial));//建立头结点,存储商hf->next=NULL;pf=(Polyn)malloc(sizeof(struct Polynomial));//建立头结点,存储余数pf->next=NULL;temp1=(Polyn)malloc(sizeof(struct Polynomial));temp1->next=NULL;temp2=(Polyn)malloc(sizeof(struct Polynomial));temp2->next=NULL;temp1=AddPolyn(temp1,pa);while(qa!=NULL&&qa->exp>=qb->exp){temp2->next=(Polyn)malloc(sizeof(struct Polynomial));temp2->next->coef=(qa->coef)/(qb->coef);temp2->next->exp=(qa->exp)-(qb->exp);Insert(temp2->next,hf);pa=SubtractPolyn(pa,MultiplyPolyn(pb,temp2));qa=pa->next;temp2->next=NULL;}pf=SubtractPolyn(temp1,MultiplyPolyn(hf,pb));pb=temp1;printf("the quotient is :");PrintPolyn(hf);printf("the remainder is :");PrintPolyn(pf);}//DevicePolynint main(){int m,n,flag=0;float x;Polyn pa=0,pb=0,pc,pd,pe,pf;//定义各式的头指针,pa与pb在使用前付初值NULL printf("please input A number:");scanf("%d",&m);pa=CreatePolyn(pa,m);//建立多项式Aprintf("please input B number:");scanf("%d",&n);pb=CreatePolyn(pb,n);//建立多项式B//输出菜单printf("**********************************************\n");printf("choise:\n\t1.Output A and B\n\t2.CreatePolyn A+B\n");printf("\t3.CreatePolyn A-B\n\t4.CreatePolyn A*B\n");printf("\t5.CreatePolynA/B\n\t6.Return\n**********************************************\n");for(;;flag=0){printf("choise");scanf("%d",&flag);if(flag==1){printf("多项式A:");PrintPolyn(pa);printf("多项式B:");PrintPolyn(pb);continue;}if(flag==2){pc=AddPolyn(pa,pb);printf("多项式A+B:");PrintPolyn(pc);DestroyPolyn(pc);continue;}if(flag==3){pd=SubtractPolyn(pa,pb);printf("多项式A-B:");PrintPolyn(pd);DestroyPolyn(pd);continue;}if(flag==4){pf=MultiplyPolyn(pa,pb);printf("多项式a*b:");PrintPolyn(pf);DestroyPolyn(pf);continue;}if(flag==5){DevicePolyn(pa,pb);continue;}if(flag==6) break;if(flag<1||flag>6) printf("Error\n");continue;}//forDestroyPolyn(pa);DestroyPolyn(pb);return 0;}一、调试过程一次调试二次调试二、实验结果测试数据(1)多项式A:3x^4+11x^3+21x^2多项式B:2x^5+11x^4+12x^3+7x实验结果(1)多项式A+B=2x^5+14x^4+23x^3+21x^2+7x多项式A-B=-2x^5-8^4-x^3+21x^2-7x多项式A*B=6x^9+55x^8+199x^7+363x^6+273x^5+77x^4+147x^3多项式A/B=0实验截图(1)测试数据(2):多项式A:2x^3+5x^-3多项式B:9x^2+6x^-2+11x^-3实验结果(2):多项式A+B=2x^3+9x^2+6x^-2+16x^-3多项式A-B=2x^3-9x^2-6x^(-2)=16x^(-3)多项式A*B=18x^5+12x+22+45x^(-1)+30x^(-5)+55x^(-6)多项式A/B=0.222222x实验截图(2):测试数据(3)多项式A:-x^7+3x^5多项式B:x^7-4x6%+7x^3实验结果(3)多项式A+B=-x^5+7x^3多项式A-B=-2x^7+7x^5-7x^3多项式A*B=-x^14+7x^12-19x^10+21x^8多项式A/B=-1实验截图(3):三、总结1.在熟悉VC6.0环境的同时,对单链表的存储格式有了深刻的理解;2.复习C++语法的同时,对刚学的线性表进行综合性理解和表达,与之前所学融合。

两个一元多项式相加-c++版

两个一元多项式相加-c++版

《数据结构》实验报告——两个一元多项式相加一、实验题目:两个一元多项式相加二、实验内容:根据所学的数据结构中线性结构(线性表)的逻辑特性和物理特性及相关算法,应用于求解一个具体的实际问题----------两个多项式相加三、设计思想:(1)建立两个顺序列表,分别用来表示两个一元多项式;顺序列表奇数位,存储该多项式的系数;顺序列表的偶数位,存储该相应多项式的指数。

(2)用成员函数merg(qList<Telem>&l2)实现两多项式的相加。

实现的大致方法为:比较第二个多项式列表与第一个多项式列表的偶数位的数值大小(指数),如果相同,则将他们的前一位数(系数)相加;如果不同,就将他的前一位数(系数)及它自己(指数)插入第一个多项式列表的后面。

(3)建立函数shu(double a[],int j)实现多项式的输入。

四、源程序代码#include "stdafx.h"#include<iostream>using namespace std;template<class Telem>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<n;i++)elem[i]=a[i];};~List(){delete[] elem;};Telem gete(int i){if(i>=1&&i<=curlen)return elem[i-1];else return NULL;};int leng(){return curlen;};List<Telem>&merg(List<Telem>&l2);//声明两多项式相加的成员函数};template<class Telem>List<Telem>&List<Telem>::merg(List<Telem>&l2)//两多项式相加的成员函数的实现{int i,j,m,n,k(0);m=curlen;n=l2.curlen;if(m+n<=maxlen){for(i=0;i<n/2;i++){for(j=0;j<m/2;j++)if(elem[2*j+1]==l2.elem[2*i+1]){k++;elem[2*j]+=l2.elem[2*i];break;}if(j==m/2){elem[m+2*(i-k)]=l2.elem[2*i];elem[m+2*(i-k)+1]=l2.elem[2*i+1];}}}curlen=m+n-2*k;return *this;}void fun(double a[],int j)//该函数实现:输入2j个double型的数,并将其存储到数组中{int i;for(i=0;i<j;i++){double m,n;cout<<"请输入第"<<i+1<<"项的系数和指数:";cin>>m>>n;a[2*i]=m;a[2*i+1]=n;}}void main(){int i,j,k;cout<<"第一个多项式的个数:";cin>>j;double *a=new double[2*j];fun(a,j);cout<<"第二个多项式的个数为:";cin>>k;double *b=new double[2*k];shu(b,k);List<double>s1(a,2*j);List<double>s2(b,2*k);s1.merg(s2);cout<<"二个多项式相加结果为:";for(i=1;i<=s1.leng()/2;i++)//用for循环将这二个多项式结果输出{cout<<s1.gete(2*i-1)<<"X^"<<s1.gete(2*i);if(i!=s1.leng()/2)cout<<"+";}cout<<endl;}五、程序运行结果截图。

中国农业大学_821数据结构_《数据结构》实验笔记(2)

中国农业大学_821数据结构_《数据结构》实验笔记(2)

实验2 线性表课程实验共安排8个难度各易的实验,训练重点在于掌握基本的数据结构,而不强调面面俱到。

通过实验,掌握抽象数据类型的概念和基本数据结构,掌握各种数据结构内在的逻辑关系,各种数据结构在计算机中的存储表示,基于各种数据结构上的基本运算、算法实现及算法分析。

●实验目的(1) 掌握用Turbo C 2.0上机调试线性表的基本方法。

(2) 掌握线性表基本操作,如:插入、删除、查找、线性表合并等运算在顺序存储结构和链式存储结构上的运算。

●实验内容1. 线性表基本操作的实现[问题描述] 当要在线性表顺序存储结构上的第i个位置上插入一个数据元素时,必须首先将线性表中第i个元素之后的所有数据元素依次后移一个位置,以便腾空一个位置;再把新元素插入到该位置上。

当要删除第i个数据元素时,也必须把第i个元素之后的所有数据元素前移一个位置。

[基本要求] 要求生成线性表时,可从键盘上读取元素,用顺序和链式存储结构实现存储;要求插入和删除之后输出线性表。

2. 约瑟夫环问题[问题描述] 设有n个人围坐在一圈,现在从某个人开始报数,数到m的人出列,接着从出列的下一个人开始重新报数,数到m的人又出现了;如此下去,直到所有人都出列为止,试设计确定他们出列次序序列的程序。

[基本要求] 选择单向循环链表作为存储结构,模拟报数过程,并且依次输出出列每个人的编号。

3. 一元多项式简单计算[问题描述] 设计一个一元多项式简单的计算器。

[基本要求] 一元多项式简单计算器的基本功能是:(1) 输入并建立多项式;(2) 输出多项式;(3) 两个多项式相加、相减、相乘,建立并输出多项式。

●实验要求(1) 认真分析题目。

(2) 进行算法设计。

(3) 编写程序代码(4) 上机调试程序。

(5) 保存和打印出程序的运行结果,并结合程序进行分析。

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

数据结构多项式相加实验报告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 0typedef struct Lnode{float coef; //存储项系数int expn;//存储项指数struct Lnode *next;}Lnode,*LinkList;typedef LinkList polynomial;Status InitList_L(LinkList &L) {//初始化头节点L=(LinkList)malloc(sizeof(Lnode));if(!L)return(-1);L->next=null;return 1;}void AddPolyn(polynomial pa, polynomial pb){ //实现两个多项式相加的算法float x;polynomial qa;polynomial qb;polynomial s;polynomial u;qa=pa->next; qb=pb->next; s=pa;while(qa&&qb){if(qa->expnexpn){s=qa;qa=qa->next;}else if(qa->expn==qb->expn){x=qa->coef+qb->coef;if(x!=0){qa->coef=x;s=qa;qa=qa->next;u=qb;qb=qb->next;free(u);}else{s->next=qa->next;free(qa);qa=s->next;u=qb;qb=qb->next;free(u);}}else if(qa->expn>qb->expn){ u=qb->next;s->next=qb;s=qb;qb->next=qa;qb=u;}}if(qb)qa->next=qb;free(pb);}void main(){float a;int b;polynomial L1;polynomial L2; LinkList q;LinkList p;LinkList m;LinkList n;InitList_L(L1);q=L1;InitList_L(L2);p=L2;cout 请输入数据:" for(;;){ cin>>a;cin>>b;if(a==0&&b==0) break;m=new Lnode;m->coef=a;m->expn=b;q->next=m;q=m;q->next=null;}//循环输入第一个多项式的系数与指数for(;;){cin>>a;cin>>b;if(a==0&&b==0)break;n=new Lnode;n->coef=a;n->expn=b;p->next=n;p=n;p->next=null;}//循环输入第二个多项式的系数与指数AddPolyn(L1,L2);//调用多项式相加的算法while((L1->next)!=null){coutnext->coefnext->expn L1=L1->next;}//输出计算结果}三、实验小结通过编写多项加法这个程序,我将自己所学到的创建链表,初始化链表和多项式加法算法都应用了一次,这使我们不仅仅只是理论化的学习书本上的知识,而是将学习到的理论知识应用到实际的操作中来增强我们的实际操作能力,这使我增加了实际操作经验,也使我通过实际操作来认识到自己在程序编写上的不足从而增强了我的实际编写程序的能力。

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

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

南昌航空大学实验报告课程名称:数据结构实验名称:实验二线性表的链式存储结构班级:080611 学生姓名:学号:08指导教师评定:签名:题目:设计并实现以下算法:给出用单链表存储多项式的结构,利用后接法生成多项式的单链表结构,实现两个多项式相加的运算,并就地逆置相加后的多项式链式。

一、需求分析1.用户可以根据自己的需求分别输入两个一元多项式,并且能够实现输入的一元多项式的显示。

2.能够完成两个一元多项式的相加功能,而且还能显示相加后的逆置的一元多项式。

3.程序执行的命令包括:(1)构造链表A (2)构造链表B (3)两个链表的相加(4)求链表的长度(5)打印(显示)已有的链表(6)将已相加的链表进行逆序排列二、概要设计⒈为实现上述算法,需要线性表的抽象数据类型:ADT Polynomial {数据对象:D={a i:|a i∈TermSet,i=1…n,n≥0TermSet 中的每个元素包含一个表示系数的实数和表示指数的整数} 数据关系:R1={<a i-1,a i>|a i-1,a i∈D,且a i-1中的指数值< a i中的指数值i=2,…n≥0}基本操作:initlink(& L)操作结果:构造一个空的链表L。

Creatlink(&L,n)操作结果:输入n项的系数和指数,建立一个非空的一元多项式L。

LinkLength(L)初始条件:链表L已经存在。

操作结果:返回一元多项式L中的项数。

Displaylink(L)初始条件:链表L已经存在。

操作结果:打印输出一元多项式L。

Addpolyn(A,B,&C)初始条件:一元多项式A和B已存在。

操作结果:完成多项式相加运算,即:C=A+B,并且带回C。

subtracypolyn(&La,&Lb,)初始条件:一元多项式La和Lb已存在。

操作结果:完成多项式的相减运算La=La+Lb,并且销毁多项式Lb。

数据结构实验报告(一)线性表的应用

数据结构实验报告(一)线性表的应用

数据结构实验报告(⼀)线性表的应⽤实验说明数据结构实验⼀ 线性表的实验——线性表的应⽤⼀、实验⽬的通过本实验使学⽣了解线性表的⼀种简单应⽤,熟悉线性表顺序存储与链式存储的特性,特别训练学⽣编程灵活控制链表的能⼒,为今后编程控制更为复杂的数据结构奠定基础。

⼆、实验内容1.⽤顺序表和链表分别分别编程实现教材中例⼦2-1与2-2。

要求:(1)只能⽤C语⾔编程实现;(2)完全保持书中算法2.1与算法2.2形式,不允许有任何变化,除⾮语法上不允许;所调⽤各函数参照书中19页的功能描述,其中函数名、参数个数及性质、函数功能必须与书中完全⼀致,不能有变化。

2.利⽤线性表表⽰⼀元多项式完成多项式的加、减、乘、求导、求值运算。

要求:(1)输⼊的⼀元多项式可以采⽤只输⼊各项的系数与指数这种简化的⽅式。

如对于多项式2x2+6x5,输⼊可为: 2,2 6,5 这样的简单形式。

(2)遇到有消项时应当处理,如2x2+6x5与3x2-6x5进⾏相加时,结果为5*x^2。

(3)当给定x的值时,能计算表达式相加或相减的结果。

(4)操作的结果放⼊⼀个新线性表中,原来的两个表达式存储表⽰不变,也可以不是产⽣新的线性表,⽽是将两上线性表合并为⼀个。

(5)要求程序功能模块划分合理(每个函数功能单⼀、可重⽤性好),使⽤空间尽可能少,算法尽可能⾼效。

实验报告1.实现功能描述使⽤线性表表⽰⼀元多项式完成多项式的加、减,乘,求导、求值运算。

2.⽅案⽐较与选择(1)因为使⽤的是线性表,所以主要⽅案有数组法和链表法。

(2)从时间复杂度来说,使⽤数组法更优;从空间复杂度来说,链表法更优。

因为数组法是指定好空间的,若式⼦⼤⼩超出设置⼤⼩,那程序必然出错;若式⼦⼤⼩⼩于设置⼤⼩,那就意味着有多余的空间被浪费了。

综合来讲,若计算式⼦较为庞⼤,使⽤链表法更佳;相反,若计算式⼦较⼩,数组法更佳。

3.设计算法描述(1)单个项式的数据存储使⽤了结构体,数组法是在⼀个结构体中定义两个⼀维数组;链表法是通过⼀个结构体作为⼀个节点,通过next指针连接起来。

数据结构:链表的应用-求两个一元多项式之和

数据结构:链表的应用-求两个一元多项式之和

!= NULL && p2 == NULL) || (p1 == NULL && p2 != NULL)) || p1 != NULL || p2 != NULL) { if(p1 == NULL && p2 != NULL) {
Pnode pnew = (Pnode)malloc(sizeof(Pnode)); if(NULL == pnew) { exit(-1); }
printf("\n"); }
int main(void) {
Pnode p1,p2; int a,b; char x;
printf("输入未知字母(如 x,y,z 等):"); scanf("%c",&x);
精美文档
5
printf("输入第一个多项式的项数:"); scanf("%d",&a); p1 = init(a);
printf("输入幂数:"); scanf("%d",&b); pnew->mi = b;
精美文档
2
ptail->next = pnew; pnew->next = NULL;
ptail = pnew; }
return phead; }
Pnode jia(Pnode p1,Pnode p2) {
构建中止 未命名 2: 15 个错误, 1 个警告
2.最后一次调试
--------------------配置: mingw5 - CUI Debug, 编译器类型: MinGW--------------------

链表两个多项式相加与相乘的解释

链表两个多项式相加与相乘的解释

链表两个多项式相加与相乘的解释链表是一种数据结构,其中每个元素(称为节点)包含数据部分和一个指向下一个元素的指针。

在链表中表示多项式,每个节点包含一个系数和一个指示下一个节点在链表中的位置的指针。

多项式的每一项都存储在链表中。

对于两个多项式的相加和相乘,我们可以使用链表来表示这些操作。

1. 多项式相加:假设我们有两个多项式 P(x) 和 Q(x),它们可以表示为链表:```cssP(x) = a_nx^n + a_n-1x^(n-1) + ... + a_1x + a_0Q(x) = b_mx^m + b_m-1x^(m-1) + ... + b_1x + b_0```多项式 P(x) 和 Q(x) 的相加可以通过简单的对应项相加来完成。

即对于每个i,我们找到 P(x) 的第 i 项和 Q(x) 的第 i 项,然后将它们相加并将结果存储在一个新的链表中。

注意,这可能会导致新的链表中的节点数少于原始链表中的节点数,因为如果某个指数在两个原始链表中都不存在,那么它就不会出现在结果链表中。

2. 多项式相乘:多项式相乘稍微复杂一些。

假设我们有两个多项式 P(x) 和 Q(x),它们的链表表示如下:```cssP(x) = a_nx^n + a_{n-1}x^{n-1} + ... + a_1x + a_0Q(x) = b_mx^m + b_{m-1}x^{m-1} + ... + b_1x + b_0```P(x) 和 Q(x) 的相乘可以通过创建一个新的链表来完成,该链表包含所有可能的对应项乘积。

具体来说,结果链表的每个节点包含一个系数,该系数是原始链表中两个节点的系数的乘积。

对于每个 i 和 j(i 从 0 到 n,j 从 0 到m),我们将 P(x) 的第 i 项与 Q(x) 的第 j 项相乘并将结果添加到结果链表中。

注意,这可能会导致结果链表中的节点数多于原始链表中的节点数,因为每个节点可能与其它的多个节点相乘。

两个多项式相加实验报告

两个多项式相加实验报告

两个多项式相加实验报告主要实验内容:根据所学的数据结构中线性结构(线性表)的逻辑特性和物理特性及相关算法,应用于求解一个具体的实际问题----------两个多项式相加一、运行环境:visual C++二、需求分析(1)掌握线性结构的逻辑特性和物理特性(2)掌握线性结构的各种相关算法(3)掌握将算法转换成程序的方法和步骤(4)掌握采用线性结构解决实际问题。

三、概要设计1、抽象数据类型一元多项式的定义如下:ADT Polynomial { 数据对象:D={ a i | a i∈TermSet, i=1,2,...,m, m≥0TermSet 中的每个元素包含一个表示系数的实数和表示指数的整数 }数据关系:R1={ <a i-1 ,a i >|a i-1 ,a i∈D, i=2,...,n,且a i-1中的指数值<a i中的指数值}基本操作:CreatPolyn ( &P, m )操作结果:输入 m 项的系数和指数,建立一元多项式 P。

DestroyPolyn ( &P )初始条件:一元多项式 P 已存在。

操作结果:销毁一元多项式 P。

PrintPolyn ( &P )初始条件:一元多项式 P 已存在。

操作结果:打印输出一元多项式 P。

PolynLength( P )初始条件:一元多项式 P 已存在。

操作结果:返回一元多项式 P 中的项数。

AddPolyn ( &Pa, &Pb )初始条件:一元多项式 Pa 和 Pb 已存在。

操作结果:完成多项式相加运算,即:Pa = Pa+Pb,并销毁一元多项式 Pb。

SubtractPolyn ( &Pa, &Pb )… …} ADT Polynomial2、一元多项式的实现:typedef OrderedLinkList polynomial;// 用带表头结点的有序链表表示多项式结点的数据元素类型定义为:typedef struct { // 项的表示float coef; // 系数int expn; // 指数 term, ElemType;四、详细设计线性表的应用--多项式相加问题多项式的相加操作是线性表处理的典型例子。

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

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

试验一多项式相加一. 实验内容:多项式相加二.实验目的和要求:利用双向链表实现通讯录的建立、删除、检索和列表,并可保存至文件,可重新装入。

用链式存储结构实现一元多项式的相加运算。

三.算法思想描述:1. 以单链表为存储结构插入多项式: 多项式输入:多项式按幂从高到低,以“系数,幂”的格式输入,并以“0,0”结束。

printf("Please input coef:");scanf("%d",&i);printf("Please input exp: ");scanf("%d",&j);while(i!=0){q=(pnode)malloc(sizeof(struct node));q->coef=i;q->exp=j;p->link=q;p=q;printf("Please input coef:");scanf("%d",&i);printf("Please input exp: ");scanf("%d",&j);}p->link=NULL;2. 多项式相加单链表合并:由两个多项式对应的单链表头节点开始,依次扫描各节点。

(1)若两表的节点均非空:比较二者的幂,按幂大者先入表。

如果幂相等,则系数相加再入表。

具体由以下代码实现:while(p!=NULL && q!=NULL){if(p->exp==q->exp){x=p->coef+q->coef;if(x!=0){s=(pnode)malloc(sizeof(struct node));s->coef=x;s->exp=p->exp;r->link=s;r=s;}p=p->link;q=q->link;}else if(p->exp<q->exp){s=(pnode)malloc(sizeof(struct node));s->coef=q->coef;s->exp=q->exp;r->link=s;r=s;q=q->link;}else{s=(pnode)malloc(sizeof(struct node));s->coef=p->coef;s->exp=p->exp;r->link=s;r=s;p=p->link;}(2). 若有一链表已空,则将非空链表插入新表:while(p!=NULL){s=(pnode)malloc(sizeof(struct node));s->coef=p->coef;s->exp=p->exp;r->link=s;r=s;p=p->link;}while(q!=NULL){s=(pnode)malloc(sizeof(struct node));s->coef=q->coef;s->exp=q->exp;r->link=s;r=s;q=q->link;}3. 输出合并后的链表:while(head->link!=NULL){head=head->link;printf(" %d*x^%d",head->coef,head->exp);}4. 主函数调用,完成多项式相加。

数据结构--线性表的基本运算及多项式的算术运算

数据结构--线性表的基本运算及多项式的算术运算

数据结构:线性表的基本运算及多项式的算术运算一、实验目的和要求实现顺序表和单链表的基本运算,多项式的加法和乘法算术运算。

要求:能够正确演示线性表的查找、插入、删除运算。

实现多项式的加法和乘法运算操作。

二、实验环境(实验设备)X64架构计算机一台,Windows 7操作系统,IDE: Dev C++ 5.11编译器: gcc 4.9.2 64bit二、实验原理及内容程序一:实现顺序表和单链表的实现本程序包含了四个文件,分别是LinearListMain.cpp,linearlist.h,seqlist.h,singlelist.h。

分别是主程序,线性表抽象类,顺序储存线性表的实现,链表储存顺序表的实现。

文件之间的关系图:本程序一共包含了三个类:分别是LinearList(线性表抽象类),SeqList(顺序储存的线性表),SingleList(链表储存的线性表)。

类与类之间的关系图如下:其实,抽象类LinearList规定了公共接口。

分别派生了SeqList类和SingleList。

SingleList类与SingleList类分别实现了LinearList类中的所有接口。

程序代码以及分析:Linearlist类:#include <iostream>using namespace std;template <class T>class LinearList{protected:int n; //线性表的长度public:virtual bool IsEmpty() const=0; //判读是否是空线性表virtual int Length() const=0; //返回长度virtual bool Find(int i,T& x) const=0; //将下标为i的元素储存在x中,成功返回true,否则返回falsevirtual int Search(T x) const=0; //寻找值是x的元素,找到返回true,否则返回falsevirtual bool Insert(int i,T x)=0; //在下标为i的元素后面插入xvirtual bool Delete(int i)=0; //删除下标为i的元素virtual bool Update(int i,T x)=0;//将下标为i的元素更新为x virtual void Output(ostream& out)const=0; //将线性表送至输出流};包含了一个保护数据成员n,和8种运算,具体说明见注释。

数据结构(C语言)用单链表存储一元多项式,并实现两个多项式的相加运算

数据结构(C语言)用单链表存储一元多项式,并实现两个多项式的相加运算

#include<stdio.h>#include<stdlib.h>#include<malloc.h>typedef int ElemType;/*单项链表的声明*/typedef struct PolynNode{int coef; // 系数int expn; // 指数struct PolynNode *next;}PolynNode,*PolynList;/*正位序(插在表尾)输入n个元素的值,建立带表头结构的单链线性表*/ /*指数系数一对一对输入*/void CreatePolyn(PolynList &L,int n){int i;PolynList p,q;L=(PolynList)malloc(sizeof(PolynNode)); // 生成头结点L->next=NULL;q=L;printf("成对输入%d个数据\n",n);for(i=1;i<=n;i++){p=(PolynList)malloc(sizeof(PolynNode));scanf("%d%d",&p->coef,&p->expn); //指数和系数成对输入q->next=p;q=q->next;}p->next=NULL;}// 初始条件:单链表L已存在// 操作结果: 依次对L的每个数据元素调用函数vi()。

一旦vi()失败,则操作失败void PolynTraverse(PolynList L,void(*vi)(ElemType, ElemType)){PolynList p=L->next;while(p){vi(p->coef, p->expn);if(p->next){printf(" + "); //“+”号的输出,最后一项后面没有“+”}p=p->next;}printf("\n");}/*ListTraverse()调用的函数(类型要一致)*/void visit(ElemType c, ElemType e){if(c != 0){printf("%dX^%d",c,e); //格式化输出多项式每一项 }}/* 多项式相加,原理:归并 *//* 参数:两个已经存在的多项式 *//* 返回值:归并后新的多项式的头结点 */PolynList MergeList(PolynList La, PolynList Lb){PolynList pa, pb, pc, Lc;pa = La->next;pb = Lb->next;Lc = pc = La; // 用La的头结点作为Lc的头结点while(pa&&pb){if(pa->expn < pb->expn){pc->next = pa; //如果指数不相等,pc指针连上指数小的结点,pc = pa;pa = pa->next; //指向该结点的指针后移}else if(pa ->expn > pb->expn ){pc->next = pb; //pc指针连上指数小的结点,pc = pb;pb = pb->next; //指向该结点的指针后移}else//(pa ->expn = pb->expn ){pa->coef = pa->coef + pb->coef; //指数相等时,系数相加pc->next = pa;pc = pa;pa = pa->next; //两指针都往后移pb = pb->next;}}pc->next = pa ? pa:pb; // 插入剩余段return Lc;}void main(){PolynList ha,hb,hc;printf("非递减输入多项式ha, ");CreatePolyn(ha,5); // 正位序输入n个元素的值 printf("非递减输入多项式hb, ");CreatePolyn(hb,5); // 正位序输入n个元素的值 printf("多项式ha :");PolynTraverse(ha, visit);printf("\n");printf("多项式hb :");PolynTraverse(hb, visit);printf("\n");hc = MergeList(ha,hb);PolynTraverse(hc, visit);}。

数据结构-实验2-多项式求和

数据结构-实验2-多项式求和

数据结构-实验2-多项式求和数据结构实验 2 多项式求和在计算机科学和数学领域中,多项式的操作是一个常见且重要的任务。

本次实验 2 的重点是实现多项式的求和。

首先,让我们来理解一下什么是多项式。

简单来说,多项式就是由变量、系数和运算符组成的表达式。

例如,3x^2 + 2x 1 就是一个多项式,其中 3、2 和-1 是系数,x 是变量,^2 表示幂次。

那么为什么要进行多项式求和呢?在实际的应用中,我们经常会遇到需要对多个多项式进行运算的情况。

比如在数学建模中,通过对不同的多项式进行求和,可以得到更复杂的数学表达式,从而更准确地描述实际问题。

接下来,我们来探讨一下如何实现多项式的求和。

在数据结构中,有多种方式可以表示多项式。

常见的有顺序表和链表两种方式。

使用顺序表来表示多项式时,我们可以将多项式的每一项的系数和指数存储在数组的相应位置。

比如,数组的第一个元素存储第一项的系数和指数,第二个元素存储第二项的系数和指数,以此类推。

这种方式的优点是随机访问速度快,但是在进行多项式的加法运算时,可能需要移动大量的元素,效率较低。

相比之下,链表的方式则更加灵活。

我们可以为每一项创建一个节点,节点中包含系数、指数和指向下一项的指针。

在进行多项式的加法运算时,只需要遍历链表,根据指数的大小进行相应的操作即可。

下面我们通过一个具体的例子来看看如何进行多项式的求和。

假设有两个多项式:P1(x) = 2x^3 + 3x^2 1 和 P2(x) = x^3 + 2x 5 。

首先,我们创建两个链表分别表示这两个多项式。

然后,同时遍历这两个链表。

在遍历的过程中,比较当前节点的指数大小。

如果两个节点的指数相等,那么将它们的系数相加,创建一个新的节点,其系数为相加后的结果,指数不变,并将其插入到结果链表中。

如果一个节点的指数大于另一个节点的指数,那么将指数较小的节点直接插入到结果链表中,并继续遍历。

如果一个链表遍历完了,而另一个链表还有剩余的节点,那么将剩余的节点直接插入到结果链表中。

数据结构实验,用链表实现多项式加减乘

数据结构实验,用链表实现多项式加减乘

#include<stdio.h>#include<malloc.h>#include<stdlib.h>#include<math.h>#define ERROR 0#define POLY sizeof(Polynomial)typedef struct Polynomial /*用单链表存储多项式的结点结构*/{int coef; /*多项式的系数*/int exp; /*指数*/struct Polynomial *next;/*next是struct Polynomial类型中的一个成员,它又指向struct Polynomial类型的数据,以此建立链表*/}Polynomial;Polynomial * CreatPolyn(void)/*指针函数,返回指针类型;用尾插法建立一元多项式的链表的函数*/{Polynomial *head,*tail,*s;int c,e;head=(Polynomial *)malloc(POLY);/*建立多项式的头结点,为头结点分配存储空间*/if(!head)exit(ERROR);tail=head;/*tail指针始终动态指向链表的当前表尾,以便于做尾插入,其初值指向头结点*/ printf("系数:");scanf("%d",&c); /*输入系数*/printf("指数: ");scanf("%d",&e); /*输入指数*/if(c==0){printf("请重新输入");return NULL;}else{while(c!=0) /*输入系数为0时,表示多项式的输入结束*/{s=(Polynomial *) malloc(POLY); /*申请新结点*/s->coef=c; /*申请新结点后赋值*/s->exp=e; /*申请新结点后赋值*/tail->next=s; /*做尾插,插入新结点*/tail=s; /*tail始终指向单链表的表尾*/printf("系数:");scanf("%d",&c);printf("指数: ");scanf("%d",&e);}tail->next=NULL; /*将表的最后一个结点的next置NULL,以示表结束*/ return(head);}}void DestroyPolyn(Polynomial *p)//删除多项式{Polynomial *q;while(p->next!=NULL){q=p->next;free(p);p=q;}}int PolyLength(Polynomial *p){Polynomial *q;int i=0;q=p;while(q->next!=NULL){q=q->next;i++;}return(i);}void Order(Polynomial *p)/*多项式的升幂排序*/{Polynomial *q;int a,b,i=0;q=p;while(q->next!=NULL){if(q->exp>q->next->exp){a=q->coef;b=q->exp;q->coef=q->next->coef;q->exp=q->next->exp;q->next->coef=a;q->next->exp=b;}q=q->next;i++;}}void PaiXu(Polynomial *p)//重复调用升幂排序函数{int j;for(j=1;j<PolyLength(p);j++)Order(p);}void AddPolyn(Polynomial *polya, Polynomial *polyb)/*两个一元多项式相加,将和多项式存放在多项式polya中,并将多项式ployb删除*/ {Polynomial *p,*q,*he,*temp;int sum;p=polya->next;/*令p指向polya多项式链表中的第一个结点*/q=polyb->next;/*令q指向polyb多项式链表中的第一个结点*/he=polya; /*令he指向和多项式polya*/while(p!=NULL&&q!=NULL)/*当两个多项式均未扫描结束时,执行以下操作*/{if(p->exp<q->exp)/*若p指向的多项式指数小于q指的指数*/{he->next=p; /*将p结点加入到和多项式中*/he=he->next;p=p->next; /*将p指针后移一位*/}else if(p->exp==q->exp)/*若指数相等,则相应的系数相加*/{sum=p->coef+q->coef;if(sum!=0) /*系数和不为零,执行下列操作*/{p->coef=sum;he->next=p;he=he->next;p=p->next;temp=q->next;free(q);//q=q->next;q=temp; /*释放原q节点*/}else /*系数和为零,则删除结点p与q,并将指针指向下一个结点*/{temp=p->next;free(p);p=temp;temp=q->next;free(q);q=temp;}}else /*若p指数大于q指数*/{he->next=q; /*p结点不动,将q结点加入到和多项式中*/he=he->next;q=q->next;}}if(p!=NULL)/*多项式A中还有剩余,则将剩余的结点加入到和多项式中*/he->next=p;else /*否则将B的结点加入到和多项式中*/he->next=q;}void PrintPolyn(Polynomial *p) /*输出函数,打印出一元多项式*/{p=p->next;if(p->exp>0)printf("A(x)= %d*x^%d",p->coef,p->exp);else if(p->exp<0)printf("A(x)= %d*x^(%d)",p->coef,p->exp);elseprintf("A(x)= %d",p->coef);while(p->next!=NULL){p=p->next;if(p->coef>0){if(p->exp>0)printf(" + %d*x^%d",p->coef,p->exp);else if(p->exp<0)printf(" + %d*x^(%d)",p->coef,p->exp);elseprintf(" + %d",p->coef);}else{if(p->exp>0)printf(" %d*x^%d",p->coef,p->exp);else if(p->exp<0)printf(" %d*x^(%d)",p->coef,p->exp);elseprintf(" %d",p->coef);}}}void main() /*主函数*/{Polynomial *polya,*polyb;int i;printf(" !!两个多项式的相加!!");//printf("若输入的单项式为0,则表明多项式创建完毕\n");begin: printf("\n\t\t** ** ** ** ** ** * *** *** **");printf("\n\t\t* 1、输入第一个多项式 *");printf("\n\t\t* 2、输入第二个多项式 *");printf("\n\t\t* 3、输出两个多项式的和 *");printf("\n\t\t* 4、退出 *");printf("\n\t\t** ** ** ** ** ** * *** *** **");printf("\n请选择:");scanf("%d",&i);switch(i){case 1:printf("\n请输入多项式中的每一个单项式的系数和指数\n");printf(" 若输入的单项式为0,则表明多项式创建完毕:\n\n");polya=CreatPolyn(); /*调用函数,创建多项式*/if(polya==NULL)goto begin;else{PaiXu(polya);printf("输入的多项式:\n");PrintPolyn(polya);goto begin;}case 2:printf("\n请输入多项式中的每一个单项式的系数和指数:\n"); polyb=CreatPolyn(); /*同理,创建B*/if(polyb==NULL)goto begin;else{PaiXu(polyb);printf("输入的多项式:\n");PrintPolyn(polyb);goto begin;}case 3:printf("\n两个多项式的和为:\n");AddPolyn(polya,polyb); /*调用一元多项式相加函数*/PrintPolyn(polya);DestroyPolyn(polya);goto begin;case 4:printf("08计(3)谢世伟 080201031025\n");break;}}#include <cstdlib>#include <iostream>using namespace std;struct xiang{float xs,zs,x; //分别表示系数、指数、以及Xxiang *next;};class duoxiangshi{private:xiang *first,*p;public:duoxiangshi();~duoxiangshi();void add(float xs,float zs); //n代表多项式的项数个数xiang * operator+(const duoxiangshi & b); //重载多项式的相加xiang * operator-(const duoxiangshi & b);void print(xiang *athead); //输出多项式相加结果void printself(); //看一下};duoxiangshi::duoxiangshi(){first=new xiang;first->next=NULL;p=first;}duoxiangshi::~duoxiangshi(){while(p=first){first=first->next;delete p;}}void duoxiangshi::add(float xs,float zs) //增加多项式的项数,在插入的同时给它由指数的大小进行排序{xiang *q=new xiang;xiang *tmp; //临时指针。

数据结构多项式求和

数据结构多项式求和

数据结构多项式求和多项式求和是数据结构中的一个重要问题,其中给定一个多项式,我们需要计算它的和。

在本文中,我们将讨论多项式求和的算法和数据结构。

多项式是一个数学表达式,由一系列项组成,每个项由一个系数和一个指数组成。

例如,多项式3x^2 + 2x + 1由三个项组成,分别是3x^2、2x和1。

在多项式求和问题中,我们需要计算给定多项式的所有项的总和。

为了解决多项式求和问题,我们可以使用两种主要的数据结构:链表和数组。

这两种数据结构都可以用来表示多项式,并且具有不同的优势和劣势。

链表是一种动态数据结构,可以方便地插入和删除元素。

在链表中,每个节点包含一个项的系数和指数,并且通过指针连接到下一个节点。

通过遍历链表,我们可以计算多项式的总和。

链表的一个主要优点是它可以适应多项式的大小变化,但它的缺点是访问指定位置的项的效率较低。

数组是一种静态数据结构,具有固定大小。

在数组中,每个元素存储一个项的系数和指数。

通过遍历数组,我们可以计算多项式的总和。

数组的一个主要优点是它可以提供快速的随机访问,但它的缺点是它的大小是固定的,无法适应多项式的大小变化。

基于链表的多项式求和算法如下:1. 创建一个空链表来存储多项式的和。

2. 遍历第一个多项式的链表。

3. 将每个项的系数和指数与第二个多项式的链表中的对应项相加。

4. 将结果项插入和链表中。

5. 遍历第二个多项式的链表,将未处理的项插入和链表中。

6. 返回和链表。

基于数组的多项式求和算法如下:1. 创建一个空数组来存储多项式的和。

2. 遍历第一个多项式的数组。

3. 将每个项的系数和指数与第二个多项式的数组中的对应项相加。

4. 将结果项存储在和数组的对应位置。

5. 遍历第二个多项式的数组,将未处理的项存储在和数组的对应位置。

6. 返回和数组。

无论使用链表还是数组,多项式求和的时间复杂度都是O(n),其中n是多项式的项数。

但是,链表的空间复杂度是O(n),而数组的空间复杂度是O(k),其中k是多项式的最高指数。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
{ p=(Node *) malloc(sizeof(Node));
p->coef=x;
p->expn=n;
p->next=NULL;
q->next=p ;
q=p;
}
}
}
void show_link_list(Node *L)
{
Node *p;
p=L->next;
while(p&&p->next )
D->last=n;
}
void main()
{ SeqList A,B,C;
printf("\t\t创建多项式f(x):\n");
create_list(&A);
printf("\t\tf(x)=");
show_list(A);
printf("\t\t创建多项式g(x):\n");
create_list(&B);
{ pc->next=pb;pc=pb;pb=pb->next;}
else if(fabs(pa->coef+pb->coef)<0.000001)
1、实验目的
(1)掌握线性表的顺序存储结构和链式存储结构;
(2)掌握线性表插入、删除等基本运算;
(3)掌握线性表的典型运用——多项式求和。
2、实验内容
编程实现多项式的求和运算:
(1)顺序存储结构的实现
例如,已知:f(x)=8x^6+5x^5-10x^4+32x^2-x+10,g(x)=7x^5+10x^4-20x^3-10x^2+x,
q=L;
printf("\n请按多项式指数由大到小输入系数和指数:\n");
printf("提示: 系数和指数间用空格间隔,每组数据之间用回车间隔(系数和指数为0时结束输入)\n");
while(fabs(x)>0.000001 )
{ scanf("%f %d",&x,&n);
if(fabs(x)>0.00001)
{ printf("\(%.1fx^%d\) + ",p->coef,p->expn);
p=p->next;
}
printf("\(%.1fx^%d\) ",p->coef,p->expn);
printf("\n");
}
void mergelist(Node *La,Node *Lb,Node *Lc) // 多项式合并
for(int k=99;k>=0;k--)
D->data[k]=0;
printf("\t\t请输入多项式X的次数由大到小输入系数,缺少项用0补齐\n");
for(i=n;i>=0;i--)
{printf("\t\t输入X^%d项的系数: ",i);
scanf("%d",&D->data[i]);
}
求和结果:f(x)+g(x)=8x^6+12x^5-20x^3+22x^2+10。
顺序表的定义类型如下:
#define MAXLEN 100
typedef struct
{ int data[MAXLEN];
Int last;
}SeqList;
(2)链式存储结构的实现
例如,已知:f(x)=100x^100+5x^50-30x^10 +10,g(x)=150x^90-5x^50+40x^20-20x^10+3x,
printf("\(%dx^%d\)+",C.data[i],i);
printf("\(%dx^%d\)\n",C.data[0],0);
}
void create_list(SeqList *D)
{ int n,i;
printf("\t\t请输入多项式X的最高次数:");
scanf("%d",&n);
C->last=st>st? st:st;
for(i=0;i<=C->last;i++)
C->data[i]=A.data[i]+B.data[i];
}
void show_list(SeqList C)
{ int i;
for(i=st;i>=1;i--)
if(C.data[i])
源代码
顺序存储结构:
#include<stdio.h>
#define MAXLEN 100
typedef struct
{ int data[MAXLEN];
int last;
} SeqList;
void add_List(SeqList A, SeqList B, SeqList *C)
{ int i;
4、实验步骤与源程序
实验步骤
我先从具体的问题中抽象出适当的数学模型,然后设计出相应的算法,对于用顺序存储结构实现多项式求和而言,需要设计3个main函数调用的子函数,分别实现创建多项式,多项式相加和显示多项式;对于用链式存储结构实现多项式求和,也同样需要3个这样的子函数,最后,编写程序,并调试程序,得出实验结果。
{ Node *pa,*pb,*pc;Node 来自q1,*q2;Lc=La;
pc=Lc;
pa=La->next;
pb=Lb->next;
while(pa && pb)
if(pa->expn > pb->expn)
{ pc->next=pa;pc=pa;pa=pa->next;}
else if(pa->expn < pb->expn)
printf("\t\tg(x)=");
show_list(B);
printf("\t\t多项式f(x)和g(x)的和: ");
add_List (A,B,&C);
printf("\n\t\tf(x)+g(x)=");
show_list(C);
}
链式存储结构:
#include<stdio.h>
#include<malloc.h>
求和结果:f(x)+g(x)=100x^100+150x^90+40x^20-10x^10+3x+10。
3、实验要求
(1)利用C(C++)语言完成程序设计。
(2)上机调试通过实验程序。
(3)输入数据,检验程序运行结果。
(4)给出具体的算法分析,包括时间复杂度和空间复杂度等。
(5)撰写实验报告(把输入实验数据及运行结果用抓图的形式粘贴到实验报告上)。
#include<math.h>
typedef struct linknode
{
float coef;
int expn;
struct linknode *next;
} Node;
void create_link_list(Node *L)
{ Node *p,*q;
int n=1;
float x=1;
相关文档
最新文档