精华内容
下载资源
问答
  • 一元多项式

    2019-01-06 21:37:13
    一元多项式 功能:1>.求解2个一元多项式的和  2>.求解2个一元多项式的差  3>.打印一元多项式  注:3>这个本来不算是一个功能,但是发现打印一元多项式的时候问题很多。例如:-1X...

    一元多项式

    功能: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;

    展开全文
  • PAGE PAGE 17 湖南工学院课程设计 一元多项式计算 班级 信息本1002 学号 09 姓名 班级 信息本1002 学号 26 姓名 班级 信息本1002 学号 34 姓名 班级 信息本1002 学号 41 姓名 目 录 TOC \o "1-3" \h \z \u 一课题...
  • 一元多项式计算器代码.doc 一元多项式计算器代码INCLUDEINCLUDEINCLUDETYPEDEFSTRUCTPOLYNODE{FLOATCOEF//系数INTEXP//指数STRUCTPOLYNODENEXT}POLY,POLYNODE//POLY为结点指针类型VOIDINSERTPOLYP,POLYHEAD{IFPCOEF0...

    41528d3028836879cd698677c3999917.gif一元多项式计算器代码.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时,才表示...

    一、实验原理

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

    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 ...

    一元多项式的表达和相加

    ​ 使用单链表表示一元多项式,由于使用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

    a9dafb4371abc43ec95b9f2695700007.png

    本文地址:https://blog.csdn.net/weixin_47666481/article/details/110245019

    如您对本文有疑问或者有任何想说的,请点击进行留言回复,万千网友为您解惑!

    展开全文
  • 一元多项式加减乘除运算中国计量学院实验报告实验课程:算法与数据结构实验名称:一元二项式班 级:学 号:姓 名:实验日期: 2013-5-7实验题目:创建2个一元多项式实现2个多项式相加实现2个多项式相减实现2个多项式...
  • 数据结构之链表创建一元多项式,求一元多项式之和 前言 对于一元多项式,我们完全可以利用线性表P(a0,a1,a2,…,an)表示,这样的线性表在求两个多项式相加等操作时确实简单,但是多于如下的多项式: 利用上述...
  • 依据一元多项式相加的运算规则:对于两个一元多项式中全部指数同样的项。相应系数相加,若其和不为零,则构成“和多项式”中的一项。对于两个一元多项式中全部指数不同样的项,则分别复抄到“和多项式”中去。#...
  • 注意嗷:这里的一元多项式输入时,指数exp不一定是按照递增顺序输入的,但是最终我们想获得一个指数递增的链表形式,所以在插入新结点时,需要进行判断,把他放在合适的位置。 #include<stdio.h> #include<...
  • 上课的作业:利用java数据结构的知识表示一元多项式,以及实现一元多项式的加法运算以及合并同类项链表节点类:package PloyItem;public class Lnode implements Comparable{public float coef;public int exp;...
  • 实验名称:一元多项式相加1 //multiply.cpp : 定义控制台应用程序的入口点。2 //34 #include "stdafx.h"5 #include6 #include "stdio.h"7 using namespacestd;8910 /***********************定义多形式的数据结构***...
  • 1010 一元多项式求导设计函数求一元多项式的导数。(注:x​n​​ (n为整数)的一阶导数为nx​n−1​​ 。) 输入格式: 以指数递降方式输入多项式非零项系数和指数(绝对值均为不超过 1000 的整数)。数字间以空格...
  • 一元多项式求导设计函数求⼀一元多项式的导数。(注:xn(n为整数)的⼀一阶导数为n*xn-1。)输⼊格式:以指数递降⽅方式输⼊入多项式⾮非零项系数和指数(绝对值均为不不超过1000的整数)。数字间以空格分 隔。输出格式:...
  • 中南大学 数据结构与算法课程实验 实验报告 题目 实验一线性表的操作 学生姓名 谭淇蔚 学生学号 3901130721 专业班级 软件工程 1307班 完成日期 2014 年 3 月 31 日星期一 实验一线性表的操作一元多项式相加 1....
  • 一元多项式相加减 详细的解释 源代码 运行结果
  • 设计函数求一元多项式的导数。(注:x​n​​(n为整数)的一阶导数为nx​n−1​​。)输入格式:以指数递降方式输入多项式非零项系数和指数(绝对值均为不超过 1000 的整数)。数字间以空格分隔。输出格式:以与输入相同的...
  • 1010 一元多项式求导 (25分) 设计函数求一元多项式的导数。(注:x​n​​ (n为整数)的一阶导数为nx​n−1​​ 。) 输入格式: 以指数递降方式输入多项式非零项系数和指数(绝对值均为不超过 1000 的整数)。数字...
  • word文档 可自由复制编辑一元多项式各种运算本程序可完成一元多项式的加,减,乘,积分,微分运算输入可按习惯书写形式输入各项,输出按指数降序//头文件 :#include#include#include#include#include#include#...
  • 设有一个一元多项式 f(x)=∑aixi ,我们要用一个单链表将它表示出来,并实现它的加和乘运算。多项式的每一项放在一个结点中,每个结点中放两个信息,即每一项的系数和幂。在这里我们用有头结点的链表来表示,那么...
  • 1010 一元多项式求导每日编程中遇到任何疑问、意见、建议请公众号留言或直接撩Q474356284(备注每日编程)设计函数求一元多项式的导数。(注:xn(n为整数)的一阶导数为nxn−1。)输入格式:以指数递降方式输入多项式非零...
  • 一元多项式加法运算

    2021-01-01 07:39:17
    编写一元多项式加法运算程序。要求用线性链表存储一元多项式。该程序有以下几个功能: 1. 多项式求和 输入:输入三个多项式,建立三个多项式链表Pa、Pb、Pc (提示:调用CreatePolyn(polynomial &P,int m)。 输出:...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,253
精华内容 2,101
关键字:

一元多项式