一元多项式

功能：1>.求解2个一元多项式的和

           2>.求解2个一元多项式的差

           3>.打印一元多项式

        注:3>这个本来不算是一个功能，但是发现打印一元多项式的时候问题很多。例如:-1X应该打印成-X，X^0不应该应该打印出来

1.结点的定义

typedef struct Polynomial 
{
	int coef;
	int expn;
	struct Polynomial *next;
}Polynomial;

2.多项式的创建（尾插法）

Polynomial *Create_List()
{
	int coef;
	int expn;
	Polynomial *pHead;
	pHead=(Polynomial*)malloc(sizeof(Polynomial));
	pHead->next=NULL;//很重要 
	Polynomial *pnew=NULL;
	Polynomial *rear=NULL;
	rear=pHead;
	printf("请输入数字coef和expn\n");
	scanf("%d %d",&coef,&expn);
	while(coef!=0)
	{
		pnew=(Polynomial*)malloc(sizeof(Polynomial));
		pnew->coef=coef;
		pnew->expn=expn;
		pnew->next=rear->next;
		rear->next=pnew;
		rear=pnew;
	scanf("%d %d",&coef,&expn);
	}
	printf("创建完成！\n");
	return pHead;
}

3.多项式求和

Polynomial *AddPolyn(Polynomial *pa,Polynomial *pb)
{
	Polynomial *pc=(Polynomial*)malloc(sizeof(Polynomial));//尾结点 
	Polynomial *chead=pc;//头结点 
	pc->next=NULL;
	Polynomial *qa=pa->next;
	Polynomial *qb=pb->next;
	Polynomial *qc=NULL;//新结点 
	while(qa!=NULL&&qb!=NULL)
	{
		qc=(Polynomial*)malloc(sizeof(Polynomial));
		if(qa->expn<qb->expn)
		{
			qc->coef=qa->coef;
			qc->expn=qa->expn;
			qa=qa->next;	
		}
		else if(qa->expn>qb->expn)
		{
			qc->coef=qb->coef;
			qc->expn=qc->expn;
			qc=qc->next;
		}
		else
		{
			qc->coef=qa->coef+qb->coef;
			qc->expn=qa->expn;
			qa=qa->next;
			qb=qb->next;	
		}
		if(qc->coef!=NULL)
		{
			qc->next=pc->next;
			pc->next=qc;
			pc=qc;
		}	
		else
		free(qc);	
	} 
	while(qa!=NULL)
	{
		qc=(Polynomial*)malloc(sizeof(Polynomial));
		qc->coef=qa->coef;
		qc->expn=qa->expn;
		qc->next=pc->next;
			pc->next=qc;
			pc=qc;
		qa=qa->next;
	 } 
	while(qb!=NULL)	
	{
		qc=(Polynomial*)malloc(sizeof(Polynomial));
		qc->coef=qb->coef;
		qc->expn=qb->expn;
		qc->next=pc->next;
			pc->next=qc;
			pc=qc;
		qb=qb->next;
	}
	return chead;
}

设计思路:

               1>.当qa与qb结点都不为空时，将结点qx->expn较小的结点赋给qc,并且将qc采用尾插法连接给pc;

                   相等时，qa与qb进行运算，将结果赋给qc并且将qc采用尾插法连接给pc

               2>.当qa为空时,将pb中未遍历的结点逐一复制连接在pc后面

               3>.当qa为空时,将pb中未遍历的结点逐一复制连接在pc后面

4.多项式求差

Polynomial *SubPolyn(Polynomial *pa,Polynomial *pb)
{
	Polynomial *headc=NULL;
	Polynomial *p=pb->next;
	while(p!=NULL)
	{
		p->coef=p->coef*(-1);
		p=p->next;
	}
	headc=AddPolyn(pa,pb);
	p=pb->next;
	while(p!=NULL)
	{
		p->coef=p->coef*(-1);
		p=p->next;
	}
	return headc;
}

设计思路: 

                1>.由于要实现多项式pc-pb,可以考虑将多项式pb的每一项的系数*-1；

                2>.调用求和函数

                3>.恢复多项式pb,将多项式pb的每一项的系数*-1

5.打印多项式

     说明：原本以为这只是一个很简单的打印函数,但是却是花的时间最长的。。。。。。。因为考虑的东西稍微有点多

int Print_List(Polynomial *pHead)
{
	Polynomial *p=pHead->next;
	int flag=0;
	if(p==NULL)
	{
		printf("链表为空!\n");
		return 0;
	}
	else{
	while(p!=NULL){
			if(flag!=0&&p->coef>0)
				putchar('+');
			if(p->coef!=1&&p->coef!=-1)
				{
					printf("%d",p->coef);
					if(p->expn==1)	putchar('X');
					else if(p->expn) printf("X^%d",p->expn);//不为0 
				}
			else
			{
				if(p->coef==1)
				{
					if(!p->expn) putchar('1');//为0 
					else if(p->expn=1) putchar('X');
					else printf("X%d",p->expn);
					
				}
				if(p->coef==-1)
				{
					if(!p->expn) printf("-1");
					else if(p->expn==1)
					printf("-X");
					else printf("-X^%d",p->expn);
				}
				
			}
		
			p=p->next;
				flag=1;
		}
		}
		printf("\n");
	return 1;
	
}

设计思路:

               1.首先区分打印的是不是多项式的第一个数,因为当多项式的第一个数为整数时不应该打印"+"号,其余的应该打印"+"号

                2.其次,因该分为三种情况

                          1>.多项式的系数不为-1&&+1;

                           2>.多项式的系数不为-1

                           3>.多项式的系数不为-1

               在以上三种情况的基础上必须讨论多项式X的指数是不是为0；

一元多项式计算器代码.doc 
一元多项式计算器代码INCLUDEINCLUDEINCLUDETYPEDEFSTRUCTPOLYNODE{FLOATCOEF//系数INTEXP//指数STRUCTPOLYNODENEXT}POLY,POLYNODE//POLY为结点指针类型VOIDINSERTPOLYP,POLYHEAD{IFPCOEF0//系数为0时释放结点FREEPELSE{POLYQ1,Q2Q1HEADQ2HEADNEXTWHILEQ2Q2Q2NEXT}IFQ2FREEPIFQ2COEF//系数为0时释放结点{Q1NEXTQ2NEXTFREEQ2}}ELSE{PNEXTQ2Q1NEXTP}}}//INSERTPOLYCREATELISTPOLYHEAD,INTM{//建立一个头指针为HEAD、项数为M的一元多项式INTIPOLYPPOLYNODEQPHEADPOLYMALLOCSIZEOFSTRUCTPOLYNODEHEADNEXTNULLFORI0IPCOEFPEXPINSERTP,HEAD//调用INSERT函数插入结点}QHEADNEXTWHILEQNULL{COUTCOEFEXPNEXT}RETURNHEAD}//CREATEPOLYVOIDDESTROYLISTPOLYP{//销毁多项式PPOLYQ1,Q2IFPNEXTNULL{Q1PNEXTQ2Q1NEXTWHILEQ1NEXT{FREEQ1Q1Q2//指针后移Q2Q2NEXT}}}INTOUTPUTLISTPOLYP{//输出多项式POLYQPNEXTINTFLAG1//项数计数器IFQ{//若多项式为空，输出0COUTCOEF0IFQEXP1COUTEXPCOUTEXP}ELSE{IFQCOEF1{IFQEXPCOUTEXP1COUTEXPCOUTEXP}IFQCOEF1{IFQEXPCOUTEXP1COUTEXP}}QQNEXTFLAG}//WHILECOUTEXPBEXPRETURN1ELSEIFA||AEXPEXPRETURN1ELSERETURN0}ELSEIFA//A多项式已空，但B多项式非空ELSERETURN1//B多项式已空，但A多项式非空}//COMPAREPOLYADDPOLYPOLYPA,POLYPB{//求解并建立和多项式AB，返回其头指针POLYQAPANEXTPOLYQBPBNEXTPOLYHEADC,HC,QCHCPOLYMALLOCSIZEOFSTRUCTPOLYNODE//建立头结点HCNEXTNULLHEADCHCWHILEQA||QB{QCPOLYMALLOCSIZEOFSTRUCTPOLYNODESWITCHCOMPAREQA,QB{CASE1{QCCOEFQACOEFQCEXPQAEXPQAQANEXTBREAK}CASE0{QCCOEFQACOEFQBCOEFQCEXPQAEXPQAQANEXTQBQBNEXTBREAK}CASE1{QCCOEFQBCOEFQCEXPQBEXPQBQBNEXTBREAK}}//SWITCHIFQCCOEF0{QCNEXTHCNEXTHCNEXTQCHCQC}ELSEFREEQC//当相加系数为0时，释放该结点}//WHILERETURNHEADC}//ADDPOLYPOLYSUBTRACTPOLYPOLYPA,POLYPB{//求解并建立和多项式AB，返回其头指针POLYQAPANEXTPOLYQBPBNEXTPOLYHEADC,HC,QCHCPOLYMALLOCSIZEOFSTRUCTPOLYNODE//建立头结点HCNEXTNULLHEADCHCWHILEQA||QB{QCPOLYMALLOCSIZEOFSTRUCTPOLYNODESWITCHCOMPAREQA,QB{CASE1{QCCOEFQACOEFQCEXPQAEXPQAQANEXTBREAK}CASE0{QCCOEFQACOEFQBCOEFQCEXPQAEXPQAQANEXTQBQBNEXTBREAK}CASE1{QCCOEFQBCOEFQCEXPQBEXPQBQBNEXTBREAK}}//SWITCHIFQCCOEF0{QCNEXTHCNEXTHCNEXTQCHCQC}ELSEFREEQC//当相减系数为0时，释放该结点}//WHILERETURNHEADC}//ADDPOLYPOLYMULTIPLYPOLYPOLYPA,POLYPB{//求解并建立积多项式AB，返回其头指针POLYHF,PFPOLYQAPANEXTPOLYQBPBNEXTHFPOLYMALLOCSIZEOFSTRUCTPOLYNODE//建立头结点HFNEXTNULLFORQAPANEXTQAQAQANEXT{FORQBPBNEXTQBQBQBNEXT{PFPOLYMALLOCSIZEOFSTRUCTPOLYNODEPFCOEFQACOEFQBCOEFPFEXPQAEXPQBEXPINSERTPF,HF//调用INSERT函数以合并指数相同的项}}RETURNHF}//MULTIPLYPOLYVOIDDEVICEPOLYPOLYPA,POLYPB{//求解并建立商多项式A/B，返回其头指针POLYHF,PF,TEMP1,TEMP2POLYQAPANEXTPOLYQBPBNEXTHFPOLYMALLOCSIZEOFSTRUCTPOLYNODE//建立头结点,存储商HFNEXTNULLPFPOLYMALLOCSIZEOFSTRUCTPOLYNODE//建立头结点，存储余数PFNEXTNULLTEMP1POLYMALLOCSIZEOFSTRUCTPOLYNODETEMP1NEXTNULLTEMP2POLYMALLOCSIZEOFSTRUCTPOLYNODETEMP2NEXTNULLTEMP1ADDPOLYTEMP1,PAWHILEQANULLTEMP2NEXTCOEFQACOEF/QBCOEFTEMP2NEXTEXPQAEXPQBEXPINSERTTEMP2NEXT,HFPASUBTRACTPOLYPA,MULTIPLYPOLYPB,TEMP2QAPANEXTTEMP2NEXTNULL}PFSUBTRACTPOLYTEMP1,MULTIPLYPOLYHF,PBCOUTNEXTPPPNEXT{T1FORIPEXPI0{IFICOEFT}RETURNSUM}//VALUEPOLYPOLYDERIVATIVEPOLYHEAD{//求解并建立A的导函数多项式，并返回其头指针POLYQHEADNEXT,P1,P2,HDHDP1POLYMALLOCSIZEOFSTRUCTPOLYNODE//建立头结点HDNEXTNULLWHILEQ{IFQEXP0{//该项不是常数项时P2POLYMALLOCSIZEOFSTRUCTPOLYNODEP2COEFQCOEFQEXPP2EXPQEXP1P2NEXTP1NEXT//尾插法插入结点P1NEXTP2P1P2}ELSEIFQEXP0//该项为常数项BREAKQQNEXT}RETURNHD}//DERVATIVEINTMAIN{INTM,N,FLAG0FLOATXPOLYPA0,PB0,PC,PD,PE,PF//定义各

一、实验原理

利用链式存储实现存储一元多项式，并计算两个一元多项式之和。一元多项式由系数和指数构成。

1、create()存储系数指数：首先建立一个头结点headLnode，从headLnode->next开始存入系数和指数，只有系数是0时，才表示这个多项式的结束，否则每次把系数和指数存入结点后，就把指针向后移动一个接着存入，直到输入的系数是0为止。返回的是一个带头结点的链表

2、Print()输出链表：只要当前指针指向的结点不是空，就把系数和指数输出，直到系数为0为止

3、Compare()比较指数大小：根据这个结果确定先插入哪个结点

4、AddLine()链表相加：先让hc=lc=ha,即相当于给hc和lc创建了一个头结点，然后以后通过比较得到的结点都插入了hc为头结点的链表中。

      比较：

       （1）ha为空，hb不为空，直接return(hb)

       （2）ha和hb都不空，通过比较指数大小，决定插入hc的顺序

二、参考程序

#include<stdio.h>

#include<stdlib.h>

#define NULL 0

typedef struct Lnode

{

  int coef;  //定义系数变量 

  int exp;   //定义指数变量 

  struct Lnode *next;   //定义指针next变量 

 } Lnode,*LinkList;

 

 /*建立多项式列表*/

LinkList  create()

{                     

 int n;

  LinkList headLnode;

  LinkList  head;     

  LinkList p1,p2;    //定义p1，p2指针 

  n=0;

  printf("请输入多项式(输入的数必须是整数，指数须从小到大依次输入,系数为零表示多项式结束)\n");

  p1=p2= ( LinkList)malloc(sizeof(Lnode)); /*开辟一个新单元*/

  scanf("%d%d",&p1->coef,&p1->exp);      /*录入多项式*/

  headLnode=(LinkList)malloc(sizeof(Lnode));

  if (p1->coef==0){//开始输入的就是0，创建空链表 

   head=NULL;

  } 

  else

  {

    while(p1->coef!=0)

      { n++;

        if(n==1){ 

head=p1;//记录第一个输入的是头结点 

} 

        else{

 p2->next=p1;//P1指向下一个结点,并输入数据 

} 

        p2=p1;

        p1=( LinkList)malloc(sizeof(Lnode));

        scanf("%d%d",&p1->coef,&p1->exp);

       }

     p2->next=0;

     headLnode->next=head;//把头结点与第一个结点相连 

    }

      return(headLnode);

     }

/* 以下是输出多项式的函数 */

void print (LinkList p)

     {

       LinkList p0;   //定义p0指针 

       p0=p->next;

         if(p0!=NULL){ //只要不是头结点就输出 

         do 

          {

            printf("%dx的%d次幂",p0->coef,p0->exp);

            p0=p0->next;

            if(p0!=NULL){

 printf("+");

} 

          }while(p0!=0);

        } 

           else  {

    printf("  空多项式!!");

   }

   printf("\n");

 }

 

/*比较两个指数的大小的函数*/

int compare(int m,int n)    

{

 int j;

 if (m<n) j=-1;

 if (m==n) j=0;

 if (m>n) j=1;

 return(j);

}

/*两个非空多项式相加*/

LinkList  AddLine(LinkList  ha, LinkList  hb)   

{

 LinkList  la, lb, lc,hc;       //定义三个指针la,lb,lc 

 int a,b,sum;

 lc=hc=ha;

 la=ha->next;//从头结点的下一个元素开始 

 lb=hb->next;

 //如果ha为空，hb不为空，直接返回hb 

 if ((ha->next==NULL)&&(hb->next!=NULL)){

    return(hb);  

}   

//如果ha,hb都不为空，根据指数大小，移动指针lc，形成新的链表hc 

 while ((la!= NULL)&&(lb!= NULL))     //当两个多项式都不为空时 

   {

    a=la->exp;     //将la的指数赋给a 

b=lb->exp;      //将lb的指数赋给b 

    switch( compare(a,b) )     /*比较当前结点指数的大小 */

     {

      case -1:     //a<b，lc指向la 

 {   lc->next =la;

  lc=la;

  la=la->next;//la向后移 

            break;

 }

      case 0:   //a=b

         { 

  sum=la->coef+lb->coef;

    if(sum!=0)//不等于0时，把sum值存入la的系数中， 

      {               /* 将其不为零的系数和保存 */

           

      la->coef=sum;

      lc->next=la;

 lc=la; 

la=la->next;

//释放掉lb，利用ha 

ha=lb;

lb=lb->next;

free(ha);

 

      } 

    else  //两系数之和为0 

     {   /* 分别删除系数和为零的对应的两个结点 */

        

   

    ha=la;

    la=la->next;

    free(ha);

    ha=lb;

    lb=lb->next;

    free(ha);

 

   } /* 刚开始时特殊处理头结点 */

 

   break;

  }

      case 1:     //a>b 

  {              /* 将指数小的项插入到la的前部 */

    lc->next=lb;

    lc=lb;

    lb=lb->next;

    break;

  }

    }  /*end swtich*/

  }   /*end while*/

  //当两个链表长度不一致时，会有一个先都插入到lc中 

   if (lb!= NULL ){ 

   lc->next=lb;

  }

  else{

   lc->next=la;

  }

 

   return(hc);

} /*end AddLine */

 /*主程序*/

 main()

 {

  LinkList  la,lb,lc;

  printf("请输入多项式La: ");

  la=create();

  printf("请输入多项式Lb: ");

  lb=create();

  printf("多项式La:\n");

  print(la);

  printf("多项式Lb:\n");

  print(lb);

  printf("多项式La与Lb的和是: \n");

  lc=AddLine(la,lb);

  print(lc);

  }

 

/*运行结果：请输入多项式La: 请输入多项式(输入的数必须是整数，指数须从小到大依次输入,系数为零表示多项式结束)

2 1

3 2

4 5

0 9

请输入多项式Lb: 请输入多项式(输入的数必须是整数，指数须从小到大依次输入,系数为零表示多项式结束)

2 3

4 4

5 6

7 8

0 9

多项式La:

2x的1次幂+3x的2次幂+4x的5次幂

多项式Lb:

2x的3次幂+4x的4次幂+5x的6次幂+7x的8次幂

多项式La与Lb的和是:

2x的1次幂+3x的2次幂+2x的3次幂+4x的4次幂+4x的5次幂+5x的6次幂+7x的8次幂

 

--------------------------------

Process exited after 24.31 seconds with return value 0

请按任意键继续. . .

*/

 

 

 

一元多项式的表达和相加
​ 使用单链表表示一元多项式，由于使用java语言自己编写实现，没有使用LinkedList集合实现。所以需要创建单链表的类，类中包含指数，系数和后继元素的地址。类的设计如下：
public class SingleList {
public double coef;//系数
public int expn;//指数
public SingleList next;//后继
//构造函数
public SingleList(double coef, int expn) {
this.coef = coef;
this.expn = expn;
}
}
​ 下面来讲解一下如何用单链表表示和运算。
/*
*
* 1.一元多项式的表示：
* 采用单链表的形式表示，只存储非0系数项
* 链表中的每一个项封装成一个对象：coef--系数 expn--指数 next--后继元素
*
* 2.一元多项式的相加：
* 2.1定义两个指针qa和qb分别指向两个链表的当前元素
*  2.2如果两个指针都不为空的时候执行while循环
*  2.3循环语句中包含三种情况：
*  2.3.1 qa的指数小于qb的指数：qa的指针后移，qb不动，结束本次循环
*  2.3.2 qa的指数等于qb的指数：
*  计算系数和sum
*  1.如果系数和为0，将qa指向的元素删除，qa指针同时后移一位
*  2.如果系数和不为0，将qa指向的元素的系数修改为sum，qa指针后移一位
*  3.无论系数是不是为0，，删除qb指向的元素，qb指针后移
*  2.2.2 qa的指数大于qb的指数：qb的指针后移，qa不动，结束本次循环
*  2.4如果第二个链表不为空，将剩余元素插入到第一个链表的最后
*  2.5清空并释放链表2
*/
**1.**在类中首先定义两个头结点，用于指向链表中的第一个元素，不表示具体的元素项。
import java.util.Scanner;
public class PolynomialOfOne {
//两个 链表的头结点
public static SingleList head1 = new SingleList(0,0);
public static SingleList head2 = new SingleList(0,0);
}
**2.**初始化链表方法
/*
* 多项式链表初始化
*/
public static void init(SingleList head) {
head.next = null;
}
**3.**增加元素项
/*
* 多项式链表增加元素项
*/
public static void put(SingleList head,SingleList m){
//1.如果链表为空，直接放到头结点后
if(head.next == null) {
head.next = m;
return;
}
//2.如果链表不空，找到链表的最后一个元素，插入
SingleList p = head.next;
while(p.next != null) {
p = p.next;
}
p.next = m;
}
**4.**遍历输出多项式
/*
* 遍历输出
*/
public static void traverse(SingleList head) {
SingleList p = head.next;
int k = 0;//记录位置
while(p != null) {
k++;
if(k == 1 || p.coef < 0) {//第一项或者系数为负数时，不需要另加运算符
System.out.print(p.coef+"x^"+p.expn);
}
else {//不是第一项的正数项，需要加“+”运算符
System.out.print("+"+p.coef+"x^"+p.expn);
}
p = p.next;
}
System.out.println();
}
**5.**两个多项式相加
/*
* 两个多项式相加
*/
public static void addition() {
//多项式加法：head1+head2，利用两个多项式的节点构成“和多项式”
//pa和pb分别指向head1和head2中的当前结点
SingleList qa = head1.next;
SingleList qb = head2.next;
//当pa和pb均为非空时
while(qa !=null && qb !=null) {
if(qa.expn < qb.expn) {//多项式ha中的当前结点指数值小
qa = qa.next;
}//if
else if(qa.expn == qb.expn) {//多项式ha和hb中的当前结点指数值相等
double sum = qa.coef + qb.coef;//系数和
if(sum != 0.0) {//如果系数值不为0就修改当前ha中当前结点的值
qa.coef = sum;
qa = qa.next;
}//else if
else {//删除多项式ha中的当前结点,并将qa指向下一个结点
qa = freeElement(head1, qa);
}
//无论系数和为不为0，都要将当前的qb的元素删除
qb = freeElement(head2, qb);
}
else {//多项式hb中的当前结点指数值小
qb = qb.next;
}//else
}//while
//如果链表2不为空，将元素加入到链表1的后边
if(!isEmpty(head2)) {
appEnd(head1, head2);
}
//释放链表2
clear(head2);
}
**6.**删除多项式中的项
/*
* 删除链表中的某个元素并返回所删元素的下一个元素
*/
public static SingleList freeElement(SingleList head,SingleList l) {
SingleList p = head.next;//当前位置的元素
SingleList q = head;//q为p的前驱
while(p!=null) {
//如果找到该元素，删除后跳出循环
if(p == l) {
q.next = p.next;
p = null;
break;
}
//否则元素后移，前驱也跟着后移
else {
p = p.next;
q = q.next;
}
}
return q.next;
}
**7.**判断链表是否为空
/*
* 判断链表是否为空
*/
public static boolean isEmpty(SingleList head) {
if(head.next == null) {
return true;
}
else {
return false;
}
}
**8.**清空链表
/*
* 清空链表
* 如果head的后继为空，直接return即可
* 否则定义一个指针，依次后移将元素置空，最后将head的后继置空
*/
public static void clear(SingleList head) {
if(head.next==null) {
return;
}
SingleList p = head.next;
while(p.next!=null) {
head.next = p.next;//记录p的后继
p = null;
p = head.next;//p后移
}
head.next = null;//表置空
}
**9.**将一个链表的元素插入到另一个链表的最后
/*
* 将一个链表h2的元素插入到另一个链表h1的最后
*/
public static void appEnd(SingleList h1,SingleList h2) {
SingleList p = h1.next;//指针
while(p!=null) {
//当p.next等于空时，找到了h1的最后元素
if(p.next==null) {
//h1的最后元素指向h2的第一个元素完成连接
p.next = h2.next;
break;
}
p = p.next;
}
}
**10.**测试主函数
public static void main(String[] args) {
Scanner reader = new Scanner(System.in);
//初始化链表
System.out.println("请输入你的选择：\n输入-1停止添加：");
init(head1);
init(head2);
while(true) {
//选择操作
System.out.println("请输入你的选择：\n1.给多项式1添加新项\n2.给多项式2添加新项\n输入-1结束");
int select = reader.nextInt();//输入的选择
//输入-1结束添加
if(select == -1) {
break;
}
else {
//输入系数和指数
System.out.println("请输入系数：");
double coef = reader.nextDouble();
System.out.println("请输入指数：");
int expn = reader.nextInt();
//封装成对象
SingleList L = new SingleList(coef, expn);
//如果输入的为1给多项式1添加 否则给多项式2添加
if(select == 1) {
put(head1, L);
}
else {
put(head2, L);
}
}
}
//添加结束，打印输出
System.out.println("多项式1如下：");
traverse(head1);
System.out.println("多项式2如下：");
traverse(head2);
System.out.println("*****************************");
addition();
traverse(head1);
}
**11.**运行实例
多项式1如下：
3.0x^1+5.0x^2+9.0x^6
多项式2如下：
6.0x^1-5.0x^2+7.0x^3+8.0x^4+11.0x^5+7.0x^7
*****************************
9.0x^1+9.0x^6+7.0x^3+8.0x^4+11.0x^5+7.0x^7
本文地址：https://blog.csdn.net/weixin_47666481/article/details/110245019
如您对本文有疑问或者有任何想说的，请点击进行留言回复，万千网友为您解惑！