java中完成一元稀疏多项式的基本运算

Posted 2023-02-18

（1）基本功能：完成一元稀疏多项式的基本运算。加、减、在某点处的函数值、导
函数运算等。
（2）输入要求：多项式的输入按项输入，即按（系数、指数）对输入，以（0，0）结束。且
各项的输入可以不按指数递增、递减顺序形式输入，并可输入同类项
如输入为：
-5 0
2.3 2
0 0 //输入结束标志
表示多项式：-5+2.3X^2
若输入为：
3 0
4.2 7
1 3
0 4
-2 3
0 0
表示多项式：3-X^3+4.2X^7
恰当存储结构实现多项式的存储、输出一个类
多项式的加、减运算一个类
多项式的函数值、求导运算一个类

除以上功能外，还有乘法和除法的计算和导数计算呢。
这是我以前做的数据结构课程设计。希望能帮上你的忙。

#include<stdio.h>
#include<malloc.h>
typedef struct Polynomial
float coef;
int expn;
struct Polynomial *next;
*Polyn,Polynomial; //Polyn为结点指针类型
void Insert(Polyn p,Polyn h)
if(p->coef==0) free(p); //系数为0的话释放结点
else
Polyn q1,q2;
q1=h;q2=h->next;
while(q2&&p->expn<q2->expn) //查找插入位置
q1=q2;
q2=q2->next;

if(q2&&p->expn==q2->expn) //将指数相同相合并
q2->coef+=p->coef;
free(p);
if(!q2->coef) //系数为0的话释放结点
q1->next=q2->next;
free(q2);


else //指数为新时将结点插入
p->next=q2;
q1->next=p;


//Insert
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("请输入第%d项的系数与指数:",i+1);
scanf("%f %d",&p->coef,&p->expn);
Insert(p,head); //调用Insert函数插入结点

return head;
//CreatePolyn
void 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->expn==1) putchar('X');
else if(q->expn) printf("X^%d",q->expn);

else
if(q->coef==1)
if(!q->expn) putchar('1');
else if(q->expn==1) putchar('X');
else printf("X^%d",q->expn);

if(q->coef==-1)
if(!q->expn) printf("-1");
else if(q->expn==1) printf("-X");
else printf("-X^%d",q->expn);


q=q->next;
flag++;
//while
printf("\n");
//PrintPolyn
int compare(Polyn a,Polyn b)
if(a&&b)
if(!b||a->expn>b->expn) return 1;
else if(!a||a->expn<b->expn) return -1;
else return 0;

else if(!a&&b) return -1;//a多项式已空，但b多项式非空
else return 1;//b多项式已空，但a多项式非空
//compare
Polyn 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->expn=qa->expn;
qa=qa->next;
break;

case 0:

qc->coef=qa->coef+qb->coef;
qc->expn=qa->expn;
qa=qa->next;
qb=qb->next;
break;

case -1:

qc->coef=qb->coef;
qc->expn=qb->expn;
qb=qb->next;
break;

//switch
if(qc->coef!=0)
qc->next=hc->next;
hc->next=qc;
hc=qc;

else free(qc);//当相加系数为0时，释放该结点
//while
return headc;
//AddPolyn
Polyn 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;
//SubtractPolyn
float ValuePolyn(Polyn head,float x)//输入x值，计算并返回多项式的值
Polyn p;
int i;
float sum=0,t;
for(p=head->next;p;p=p->next)
t=1;
for(i=p->expn;i!=0;)
if(i<0)t/=x;i++;//指数小于0，进行除法
elset*=x;i--;//指数大于0，进行乘法

sum+=p->coef*t;

return sum;
//ValuePolyn
Polyn Derivative(Polyn head)//求解并建立a的导函数多项式，并返回其头指针
Polyn q=head->next,p1,p2,hd;
hd=p1=(Polyn)malloc(sizeof(struct Polynomial));//建立头结点
hd->next=NULL;
while(q)
if(q->expn!=0) //该项不是常数项时
p2=(Polyn)malloc(sizeof(struct Polynomial));
p2->coef=q->coef*q->expn;
p2->expn=q->expn-1;
p2->next=p1->next;//连接结点
p1->next=p2;
p1=p2;

q=q->next;

return hd;
//Dervative
Polyn 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->expn=qa->expn+qb->expn;
Insert(pf,hf);//调用Insert函数以合并指数相同的项


return hf;
//MultiplyPolyn
void 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->expn>=qb->expn)
temp2->next=(Polyn)malloc(sizeof(struct Polynomial));
temp2->next->coef=(qa->coef)/(qb->coef);
temp2->next->expn=(qa->expn)-(qb->expn);
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("商是：");
PrintPolyn(hf);
printf("余数是：");
PrintPolyn(pf);
//DevicePolyn

int main()
int m,n,flag=0;
float x;
Polyn pa=0,pb=0,pc,pd,pe,pf;//定义各式的头指针，pa与pb在使用前付初值NULL
printf("请输入a的项数:");
scanf("%d",&m);
pa=CreatePolyn(pa,m);//建立多项式a
printf("请输入b的项数:");
scanf("%d",&n);
pb=CreatePolyn(pb,n);//建立多项式a
//输出菜单
printf("**********************************************\n");
printf("操作提示：\n\t1.输出多项式a和b\n\t2.建立多项式a+b\n\t3.建立多项式a-b\n");
printf("\t4.计算多项式a在x处的值\n\t5.求多项式a的导函数\n\t6.建立多项式a*b\n");
printf("\t7.建立多项式a/b\n\t8.退出\n**********************************************\n");
for(;;flag=0)
printf("执行操作");
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)
printf("输入x的值：x=");
scanf("%f",&x);
printf("多项式a的值%g\n",ValuePolyn(pa,x));continue;

if(flag==5)
pe=Derivative(pa);
printf("多项式a的导函数：");PrintPolyn(pe);
DestroyPolyn(pe);continue;

if(flag==6)
pf=MultiplyPolyn(pa,pb);
printf("多项式a*b：");PrintPolyn(pf);
DestroyPolyn(pf);continue;

if(flag==7)
DevicePolyn(pa,pb);
continue;

if(flag==8) break;
if(flag<1||flag>8) printf("Error!!!\n");continue;
//for
DestroyPolyn(pa);
DestroyPolyn(pb);
return 0;
参考技术A ▌JUnit
JUnit 应该不需要过多介绍。哪怕你是一位 Java 初学者，我想你也应该听说过它，它能够让你为 Java 代码编写单元测试。
几乎所有常用的 IDE，比如 Eclipse、NetBeans 和 IntelliJ，都能够集成 JUnit，这意味着开发者直接可以在这些 IDE 中编写并运行单元测试。
目前大多数人仍然在使用 JUnit 4，事实上新的 JUnit 5 已经发布。你可以用 JUnit 进行单元测试和集成测试，此外，它还支持 Java 8 功能。

▌REST Assured
相比于 Groovy 这类动态语言，在 Java 中测试和验证 REST 服务更难。
REST Assured 为 Java 带来了这些语言的简单性。这对于 REST API 集成测试来说是一个很好的工具。

▌Selenium
Selenium 应该是最受欢迎的 Java UI 测试工具，有了它，你不需要在浏览器中启动 JSP 页面即可对其进行测试。
你可以使用 JUnit 和 Selenium 来测试 Web 应用程序 UI。还可以使用它进行 Web 应用程序验收测试。

▌TestNG
TestNG 这款测试框架最早源于 JUnit 和 NUnit 的启发，但它在这两者的基础上引入了许多新的功能，其功能更强大，也更易于使用，提供了注解功能，支持在任意大型线程池中运行各种可用策略的测试（所有方法都在自己的线程中，每个测试类对应一个线程）。
随着 JUnit 4 中注解功能的引入以及 Hamcrest 框架的整合，JUnit 4 和 TestNG 之间的差距已经很小。

▌Mockito
Java 有许多 Mock 框架，例如 PowerMock 和 JMock，但我个人更喜欢 Mockito，它具有简单的 API、优秀的文档以及大量示例。
Mock 测试是现代单元测试的关键技术之一，开发者不需要依赖其他情况也可独立测试代码，因此我建议每个 Java 开发人员都应该学习 Mock 框架来与 JUnit 结合使用。
我个人最喜欢的 Mock 框架是 Mockito，如果你喜欢的话，也可以了解一下 PowerMock或者 JMock。
▌Spock 框架
Spock 是一款用于 Java 和 Groovy 应用程序的测试和规范框架。它用 Groovy 编写，因此它具有很强的表现力，并且非常规范。
使用 Spock 时，测试将变得更加易读易维护。此外，得益于它的 JUnit 运行器，Spock能够兼容大多数 IDE、构建工具和持续集成服务器。
不过遗憾的是，线上讲述 Spock 框架的课程好像不多，“使用 Spock 进行 Java 测试”这本书倒是一个不错的学习资源。

▌Cucumber
Cucumber 是一款很好的自动化集成测试工具，与其他同类工具相比，它的规范功能是一大特色。
Cucumber 将规范和测试文档合并为一个文档，由于文档也会被 Cucumber 自动测试，因此规范文档始终会被更新为最新版本。

▌Spring 测试
Spring MVC 自带了一个非常有用的测试框架，可以在不涉及 Web 容器的情况下进行深入测试。
这个是一个非常有用的库，可以为 Spring 应用程序编写自动化测试。它为 Spring 应用程序（包括 MVC 控制器）编写单元和集成测试提供了强有力的支持。
还有一个 Spring Test DbUnit，它将 Spring 测试框架与 DbUnit 以及 htmlUnit 集成在了一起。
使用这些工具，你可以轻松完成 Spring MVC 应用程序的自动化测试。
▌DBUnit
对于大多数的 Java 应用程序，不管是核心 Java 程序还是 Java Web 应用，数据库都是其不可或缺的重要组成部分，并且数据库还很可能是单元测试的最大障碍。
连接到 Dev 或者 UAT 数据库进行集成测试是不可靠的，因为任何人都可以更改数据和模式，比如表和存储过程，这都会导致自动化集成测试的失败。
DbUnit 是 JUnit 的扩展，在每次集成测试之前它可以将数据库初始化为已知状态，从而确保数据库包含正确的数据。
DbUnit 是一个非常有用的工具，它可以帮助我们将测试数据和测试代码分开。

▌Robot 框架
Robot 框架是一个基于 Python 的通用自动化测试框架，主要用于验收测试以及验收测试驱动开发。
它采用表格测试数据语法，是一个关键字驱动的测试框架。分布式异构应用程序的验证往往需要多种技术和接口，非常适合用 Robot 来测试。 参考技术B 哪怕你是一位 Java 初学者，我想你也应该听说过它，它能够让你为 Java 代码编写单元测试。