多项式相乘Java代码 java两数相乘代码

谁知道用java怎么写出两个多项式相除的程序啊。。求解啊。。速度啊。。

网上有用单链表来实现多项式的加减乘，你可以参考一下，代码如下

网站建设公司,为您提供网站建设,网站制作,网页设计及定制网站建设服务,专注于成都定制网页设计,高端网页制作,对成都卫生间隔断等多个行业拥有丰富的网站建设经验的网站建设公司。专业网站设计,网站优化推广哪家好,专业成都网站推广优化,H5建站,响应式网站。

public class Polynomial {

private Monomial first; // 首项

//添加单项式

public void append(Monomial monomial) {

if (monomial == null) {

// do nothing

} else if (first == null) {

first = monomial;

} else {

Monomial current = first;

while (current != null) {

// Examda提示:如果指数相同，则相加

if (current.index == monomial.index) {

current.coefficient += monomial.coefficient;

break;

} else if (current.next == null) { // 否则直接扔到最后

current.next = monomial;

break;

}

current = current.next;

}

}

}

public void append(double c, int i) {

append(new Monomial(c, i));

}

public String toString() {

StringBuffer sb = new StringBuffer();

Monomial current = first;

while (current.next != null) {

sb

.append("(" + current.coefficient + "x^" + current.index

+ ") + ");

current = current.next;

}

sb.append("(" + current.coefficient + "x^" + current.index + ")");

return sb.toString();

}

// 两个多项式相加

public Polynomial add(Polynomial p2) {

Polynomial result = new Polynomial();

Monomial current = this.first;

while (current != null) {

result.append(current.coefficient, current.index); // Examda提示:注意这里

current = current.next;

}

current = p2.first;

while (current != null) {

result.append(current.coefficient, current.index);

current = current.next;

}

return result;

}

// 两个多项式相减 this- p2

public Polynomial substract(Polynomial p2) {

Polynomial result = new Polynomial();

Monomial current = this.first;

while (current != null) {

result.append(current.coefficient, current.index); // 注意这里

current = current.next;

}

current = p2.first;

while (current != null) {

result.append(-current.coefficient, current.index);

current = current.next;

}

return result;

}

/**

* this * p2

*

* @return

*/

public Polynomial multiply(Polynomial p2) {

Polynomial result = new Polynomial();

Monomial c1 = this.first;

Monomial c2 = p2.first;

while (c1 != null) {

while (c2 != null) {

result.append(c1.coefficient * c2.coefficient, c1.index

+ c2.index);

c2 = c2.next;

}

c1 = c1.next;

c2 = p2.first;

}

return result;

}

public Polynomial divide(Polynomial p2) {

// todo 实现相除

return null;

}

public static void main(String[] args) {

Polynomial p1 = new Polynomial();

p1.append(2.2, 1);

p1.append(3.3, 2);

p1.append(4.111, 7);

System.out.println("p1: " + p1);

Polynomial p2 = new Polynomial();

p2.append(2.232, 5);

p2.append(3.444, 6);

p2.append(5.777, 1);

System.out.println("p2: " + p2);

Polynomial result = p1.add(p2);

System.out.println("加: " + result);

result = p1.substract(p2);

System.out.println("减: " + result);

result = p1.multiply(p2);

System.out.println("乘: " + result);

}

}

/**

* 单项式

*/

class Monomial {

double coefficient; // 系数

int index; // 指数

Monomial next; // 后继结点

public Monomial() {

}

public Monomial(double c, int i) {

this.coefficient = c;

this.index = i;

}

}

多项式求导问题（线性表） 怎么用java语言编写啊 急用！！

＃包括“stdio.h中”

typedef结构节点

{C，E / /节点的数据域，C为系数的多项式e多项式指数

结构节点下/ /节点的指针字段

} PN / /自定义的节点结构类型PN

PN * createPoly（）/ /这个函数用于创建一个链表，返回值是一个节点的指针

{N，E，C;

PN *头，* P / /定义头结点指针头节点的指针p

printf（“请输入项目编号项目：“）;

scanf的（”％d“，＆N）; / / n的值，无论是项目的数量

头= P = PN / / * malloc的（大小（PN））;/ /头，p指向头节点（头节点不必存储的数据）

P- = NULL; / /这里，创建一个空列表

（ - ）/ /循环n次

{

P- =新PN ;/ / * malloc的（如sizeof（PN））;/ /动态分配新的节点，然后在链末端（尾插）

P = P-下;

/ / printf的（“CE”）; / /到新的节点，添加数据

scanf的（“ ％d月％d“，＆P- C：P- E）;

}

P- = NULL; / /指针域页脚设置为空

返回头; / /返回头节点地址

}

无效printPoly（PN *头）/ /这个函数是用来

{PN * P =头下输入链接的列表信息; / /用来遍历链表节点指针P，P点的表头

（P）/ /当p = NULL的表底，在周期结束

{printf（“请（％D，％D）”，P- C，P- E）/ /显示当前节点的数据

P = P-; / / P点移动到下一个节点

}

printf的（“\ n”）; / /输出一个回车

}

的无效freePoly（PN *头）/ /函数是用来摧毁的链表

{PN * P / /释放节点（动态内存块）

同时（头）/ /头= NULL（已经到了结束的表），在循环结束

{P =头; / /让p指向头节点称为

头=头下; / /指向头移动到下一个节点/删除（P）/ / P所指节点释放（动态内存块）

}

}的

PN * polyAdd的（PN公顷，PN * HB）/ /这个函数两个多项式的总和

{C，E; / / C是多项式的系数，e是多项式指数

PN * PA = HA-下一个* PB = HB-下，/ /？PA，PB用于遍历两个链表传递的参数（参数两个链表的头结点指针），让我们称呼他们为链表AB

* HC，* PC / / HC新列表头的总和的两个列表中的相应节点的节点，PC，用于遍历新的列表，链接列表的称之为C

HC = PC =新PN;

（PA |以pb计）/ /当两个链表的遍历完成循环停止

{

（PA （PB == NULL | | PA- E E））/ /取指数项链成一个链表或链接列表b遍历完成后，执行内容

，如果{C = PA- C;

E = PA- E;

PA = PA-下;

}

其他（PB （PA == NULL | | PA- E PB- E））/ /走索引就是少了一个项链成一个链表，链表的遍历完成实施的内容，如果

{C = PB- C;

E = PB- E;

PB = PB-;

}

/ /指数等于执行

{C = PA- C + PB- C;

E = PA- E;

PA = PA-下;

PB = PB-下;

}

（C）/ /添加一个链接到一个新的列表清单 BR / {

PC-下一个新的PN;

PC = PC-

PC - C = C;

PC- E = E; BR /}

}

PC-下一个= NULL;

回报HC / /返回一个新的列表头节点的指针

}的

PN * mulxmul的（PN公顷PN HB）/ /这个函数是每个项目表关闭一次onexmul功能，并最终实现多项式乘法的a和b

{PN * T * HC，* PA = HA-“下;

PN * onexmul（PN * PA，PN * HB）/ /函数的声明，因为下一个步骤是使用

PN * polyAdd的（ PN *公顷，PN * HB）/ /函数声明，因为下一个步骤是使用

T =新的PN，T - = NULL; / /存储最终的结果链表，t为头，该表姑且称之为T台上

（PA）/ /遍历一个链表

{HC = onexmul（PA，HB）; / / PA所指的项目表中的b表所有的项目都乘以（即多项式多项式B乘）

T = polyAdd（T，HC）; / /将分别相乘的结果中添加

freePoly（HC）; / /将调用onexmul功能生产破坏中间的链表，链表的项目已经在t链表

PA = PA-下;

}

回报吨; / / T-表头结点指针返回

}

PN * onexmul的（* PA，PN PN * HB）/ /这个函数是用来PA所指的项目表中的b表项相乘（即多项式一个多项式B相乘）

{PN * HC，PC，PB = HB-; / / HC是新的列表头节点，PC遍历新的列表 BR / HC = PC = PN / / HC，PC指向头节点

一段时间（以pb计）/ /遍历b链接列表

{PC-下一步= PN / /创建一个新的链表节点

PC = PC - 下;

PC- C = PA- C * PB- C; / /到新的节点分配的系数，系数等于乘以

PC- E = PA - E + PB- E / /指数指数总和等于

PB = PB-下;

}

PC - 下一步= NULL;

返回HC / /新的列表头节点的指针返回

}

诠释的main（）

{ PN *下*，HB，HC;

freopen（“; poly.in”，“R”状态，stdin）; / /只读模式poly.in

freopen（“poly.txt “，”W“中，stdout）; / /只写模式打开poly.txt

公顷= createPoly（）/ /创建一个新的链接列表，哈头节点的指针（多项式）

printPoly医管局总（公顷）; / /输出节点的指针链表信息

HB = createPoly（）/ /创建一个新的链接列表，HB头节点指针（多项式）

printPoly（HB）; / /输出HB头节点的指针链表信息

HC = polyAdd（HA，HB）/ /多项式一个多项式B和结果，HC是头节点的指针链表

printPoly（HC） /添加/输出链表信息

freePoly（HC）; / /销毁链表的

HC = mulxmul（HA，HB）/ /多项式一个多项式B相乘的结果，HC头节点的指针

printPoly（HC）/ /输出链表的信息后乘以链表

freePoly（公顷）; / /销毁链表

freePoly（HB）; / /销毁链表

freePoly（HC）; / /销毁的链表

返回0;

}

OK，花了大量的时间来帮你写下来笔记，完整的，完全一样的原理和数学模型，它应该是能读“，”流程图“，相信，理解程序，它是难以划清，尝试下。

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

除以上功能外，还有乘法和除法的计算和导数计算呢。

这是我以前做的数据结构课程设计。希望能帮上你的忙。

#includestdio.h

#includemalloc.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(q2p-expnq2-expn){ //查找插入位置

q1=q2;

q2=q2-next;

}

if(q2p-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;im;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-coef0flag!=1) putchar('+'); //系数大于0且不是第一项

if(q-coef!=1q-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(ab){

if(!b||a-expnb-expn) return 1;

else if(!a||a-expnb-expn) return -1;

else return 0;

}

else if(!ab) 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(i0){t/=x;i++;}//指数小于0，进行除法

else{t*=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!=NULLqa-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(flag1||flag8) printf("Error!!!\n");continue;

}//for

DestroyPolyn(pa);

DestroyPolyn(pb);

return 0;

}