精华内容
下载资源
问答
  • 一元多项式相加减 详细的解释 源代码 运行结果
  • 数据结构 - 一元多项式相加减(C语言)

    千次阅读 多人点赞 2017-12-07 23:02:26
    通常情况下,一元多项式可写成: an(x) = a1x^e1 + a2x^e2 + a3x^e3 + ... + amx^em (数字,m为下标),其中:pi是指数为ei的项的非零系数,0 例如: An(x) = 5x^3 - 2x^12 + 13x^99。可用线性表:((5,3),(-2,12),...

    通常情况下,一元多项式可写成: an(x) = a1x^e1 + a2x^e2 + a3x^e3 + ... + amx^em (数字,m为下标),其中:pi是指数为ei的项的非零系数,0<= e1 < e2 <...< em <=n.可以用线性表表示为:((p1,e1),(p2,e2),...(pm,em)).

    例如:

    An(x) = 5x^3 - 2x^12 + 13x^99。可用线性表:((5,3),(-2,12),(13,99))表示。

    为了操作方便,采用单链表作存储结构,结点有三个域:系数,指数,指针。存储结构如下:

    typedef struct Polynomial
    {
    	float coef;		//系数.
    	int expn;		//指数:常见的次幂都是整数,所以这里不考虑小数.
    	struct Polynomial *next; 
    }Polynomial,*Polyn;
    算法实现的具体思路在这里就不敖述了,下面放代码,哪里看不懂的可以评论区评论,看到第一时间回复。完整代码如下:

    #include <stdio.h>
    #include <stdlib.h>
    
    typedef struct Polynomial
    {
    	float coef;		//系数.
    	int expn;		//指数:常见的次幂都是整数,所以这里不考虑小数.
    	struct Polynomial *next; 
    }Polynomial,*Polyn;
    
    Polyn Create_Polyn();	//尾插法建立多项式.
    
    void Print_Polyn(Polynomial *head);	//打印多项式.
    
    Polyn Add_Polyn(Polynomial *pa,Polynomial *pb);	//多项式相加. 
    
    Polyn Suberact_Polyn(Polynomial *pa,Polynomial *pb);	//多项式相减. 
     
    int main()
    {
    	Polynomial *pa,*pb,*pc,*pd;
    	
    	/*--------------------一元多项式的创建---------------------*/ 
    	printf("请输入多项式pa的各项系数和指数(输入0结束): \n");
    	pa=Create_Polyn();
    	printf("请输入多项式pb的各项系数和指数(输入0结束): \n");
    	pb=Create_Polyn();
    	
    	/*------------------一元多项式的格式输出-------------------*/
    	printf("\n多项式: pa = ");
    	Print_Polyn(pa);
    	printf("\n多项式: pb = ");
    	Print_Polyn(pb);
    	
    	/*--------------------一元多项式相加-----------------------*/
    	printf("\n多项式pa和pb的和为:pa+pb = ");
    	pc=Add_Polyn(pa,pb);
    	Print_Polyn(pc);
    	
    	/*--------------------一元多项式相减-----------------------*/
    	printf("\n多项式pa和pb的差为:pa-pb = ");
    	pd=Suberact_Polyn(pa,pb);
    	Print_Polyn(pd);
    	printf("\n");
    	
    	return 0;
    }
    
    Polyn Create_Polyn()	//尾插法建立多项式.
    {
    	Polynomial *head,*rear,*s;
    	int c,e;
    	head = (Polyn)malloc(sizeof(Polynomial));
    	rear = head;				/*rear始终指向单链表的尾部,便于尾插法建表。*/ 
    	scanf("%d,%d",&c,&e);	 	/*键入多项式的系数和指数项*/
    	while(c!=0){				/*若c=0,代表多项式输入结束*/ 
    		s = (Polyn)malloc(sizeof(Polynomial));
    		s->coef = c;
    		s->expn = e;
    		rear->next = s;		 /*尾插*/
    		rear = s;
    		scanf("%d,%d",&c,&e); 
    	} 
    	rear->next = NULL;	/*将表中最后一个结点的next置为NULL*/
    	
    	return head; 
    } 
    
    void Print_Polyn(Polynomial *head)	/*打印多项式.*/
    {
    	Polyn q=head->next;
    	int flag=1;
    	if(!q){
    		putchar('0');
    		printf("\n");
    		return;
    	}
    	while(q){
    		if(q->coef > 0 && flag!=1){		/*多项式中某一项系数大于0,输出+号*/ 
    			putchar('+');
    		}
    		if(q->coef!=1 && q->coef!=-1){		/*多项式系数不是正负1*/ 
    			printf("%g",q->coef);			/*%g表示以%f%e中较短的输出宽度输出单双精度实数*/ 
    			if(q->expn==1) putchar('X');	/*若指数为1,输出X*/ 
    			else if(q->expn) printf("X^%d",q->expn); /*指数不为1,输出x^%d格式*/ 
    		}
    		else{
    			if(q->coef==1){				/*系数为1*/ 
    				if(!q->expn) putchar('1');
    				else if(q->expn==1) putchar('X');
    				else printf("X^%d",q->expn);
    			}
    			if(q->coef==-1){			/*系数为-1*/ 
    				if(!q->expn) printf("-1");
    				else if(q->expn==1) printf("-X");
    				else printf("-X^%d",q->expn);
    			}
    		}
    		q=q->next;
    		flag++;
    	}
    	printf("\n");
    }
    
    Polyn Add_Polyn(Polynomial *pa,Polynomial *pb)	//多项式相加.
    {
    	Polyn qa=pa->next;
    	Polyn qb=pb->next;
    	Polyn headc,pc,qc;
    	pc = (Polyn)malloc(sizeof(Polynomial));		/*单链表pc用来存放pa,pb的和*/
    	pc->next = NULL;
    	headc = pc;
    	while(qa!=NULL && qb!=NULL)	/*当两个多项式均未扫描结束时*/
    	{
    		qc = (Polyn)malloc(sizeof(Polynomial));
    		if(qa->expn < qb->expn) /*pa的指数项小于pb的指数项*/
    		{
    			qc->coef = qa->coef;
    			qc->expn = qa->expn;
    			qa = qa->next;
    		}
    		else if(qa->expn == qb->expn) /*指数项相同时*/
    		{
    			qc->coef = qa->coef + qb->coef;
    			qc->expn = qa->expn;		/*当然也可以是qb->expn*/
    			qa=qa->next;
    			qb=qb->next; 
    		}
    		else{				/*pb的指数项小于pa的指数项*/ 
    			qc->coef=qb->coef;
    			qc->expn=qb->expn;
    			qb=qb->next;
    		}
    		if(qc->coef!=0){
    			qc->next = pc->next;
    			pc->next = qc;
    			pc = qc;
    		}
    		else free(qc);
    	}
    	while(qa!=NULL){ 	/*pa存在剩余项,将剩余项插入到pc当中*/ 
    		qc = (Polyn)malloc(sizeof(Polynomial));
    		qc->coef = qa->coef;
    		qc->expn = qa->expn;
    		qa = qa->next;
    		qc->next = pc->next;
    		pc->next = qc;
    		pc = qc;
    	}
    	while(qb!=NULL){	/*pb存在剩余项,将剩余项插入到pc当中*/ 
    		qc = (Polyn)malloc(sizeof(Polynomial));
    		qc->coef = qb->coef;
    		qc->expn = qb->expn;
    		qb = qb->next;
    		qc->next = pc->next;
    		pc->next = qc;
    		pc = qc;
    	}
    	return headc;
    }
    
    Polyn Suberact_Polyn(Polynomial *pa,Polynomial *pb)	//多项式相减.
    {
    	Polyn h=pb;
    	Polyn p=pb->next;
    	Polyn pd;
    	while(p){			/*pa-pb就等于pa+(-pb),所以将pb多项式的各项符号循环遍历变号*/ 
    		p->coef*=-1;
    		p=p->next;
    	}
    	
    	pd=Add_Polyn(pa,h);		/*利用已创函数Add_Polyn()执行pa+(-pb),即减法运算*/
    	 
    	for(p=h->next;p;p=p->next){	/*执行完pa+(-pb)后,循环遍历,将pb的符号全部更改为之前的状态*/ 
    		p->coef*=-1;
    	}
    	return pd;
    }
    随便输入一组数据,显示结果如下:



    谢谢浏览,如果哪里写的有问题,感谢指出。

    参考:数据结构与算法 - 王曙燕主编版。

    展开全文
  • 由于多项式的加肯定会用到链表,所以本题运用链表来实现,其中会用到链表的插入,删除以及一些细节的地方,同时为了处理好一些其他的输入问题,或者是不是按照顺序的输入,加入了一些自己的理解,关于链表的知识点...

    由于多项式的加减肯定会用到链表,所以本题运用链表来实现,其中会用到链表的插入,删除以及一些细节的地方,同时为了处理好一些其他的输入问题,或者是不是按照顺序的输入,加入了一些自己的理解,关于链表的知识点,可以通过此题多多学习,加上此代码非原创,但通过这个代码学到了许多,注意复习*的用法以及含义加上链表初级知识的复习。

    #include <stdio.h>
    #include <stdlib.h>
    #include<malloc.h>   //考虑全局静态变量 
    
    #define LEN sizeof(struct poly)
    static struct poly *head1,*head2; 
    struct poly
    {
        int index;
        float ratio;
        struct poly *next;
    };//建立链表,index储存指数,ratio储存系数
    struct poly *creat()
    {
        struct poly *temp,*head,*rear,*t;
        int index;
        float ratio;
        int flag=0;
        head=rear=(struct poly*)malloc(sizeof(LEN));
        rear->next=NULL;
        printf("请输入多项式的各项的系数与指数,以空格隔开,输入0 0代表输入结束\n");
        while(1)
        {
    
            scanf("%f %d",&ratio,&index);
            if(ratio==0&&index==0)
                return head;
            if(head->next==NULL)
            {
                temp=(struct poly*)malloc(sizeof(LEN));
                rear->next=temp;
                rear=temp;
                rear->next=NULL;
                rear->index=index;
                rear->ratio=ratio;
                continue;
            }
    		for(t=head->next; t!=NULL; t=t->next)
            {
                if(t->index==index)
                {
                    flag=1;
                    t->ratio=t->ratio+ratio;
                    break;
                }
            }
            if(flag==0)
            {
                temp=(struct poly*)malloc(sizeof(LEN));
                rear->next=temp;
                rear=temp;
                rear->next=NULL;
                rear->index=index;
                rear->ratio=ratio;
    
            }
    
        }
        return head;
    };//输入数据,在输入时,可能存在输入两次相同系数的数据,此时将两组数据合并
    struct poly sort(struct poly *head)
    {
        struct poly *temp1,*temp2;
        temp1=head->next;
        temp2=NULL;
        while(temp1!=temp2)
        {
            while(temp1->next!=temp2)
            {
                if(temp1->index>temp1->next->index)
                {
                    temp1->index=temp1->index+temp1->next->index;
                    temp1->next->index=temp1->index-temp1->next->index;
                    temp1->index=temp1->index-temp1->next->index;
                    temp1->ratio=temp1->ratio+temp1->next->ratio;
                    temp1->next->ratio=temp1->ratio-temp1->next->ratio;
                    temp1->ratio=temp1->ratio-temp1->next->ratio;
    
                }
                temp1=temp1->next;
            }
            temp2=temp1;
            temp1=head->next;
        }
    };//将多项式进行排序,以符合我们通常状态下升幂的次序
    struct poly add(struct poly *head1,struct poly *head2)
    {   
        struct poly *head,*rear,*temp1,*p,*q;
        head=rear=(struct poly*)malloc(sizeof(LEN));
        rear->next=NULL;
        p=head1->next;
        q=head2->next;
        while(p!=NULL||q!=NULL)
        {
    
    
            if(p==NULL||q==NULL)
            {
                if(p==NULL)
                {
                    while(q!=NULL)
                    {
                        temp1=(struct poly*)malloc(sizeof(LEN));
                        rear->next=temp1;
                        temp1->next=NULL;
                        temp1->index=q->index;
                        temp1->ratio=q->ratio;
                        rear=temp1;
                        q=q->next;
                    }
                }//求和时,若head1为空,则直接将head2复制到新结果中去
                else if(q==NULL)
                {
                    while(p!=NULL)
                    {
                        temp1=(struct poly*)malloc(sizeof(LEN));
                        rear->next=temp1;
                        temp1->next=NULL;
                        temp1->index=p->index;
                        temp1->ratio=p->ratio;
                        rear=temp1;
                        p=p->next;
                    }
                }//若head2为空,则将head1复制到结果中去
            }
            else
            {
                if(p->index<q->index)
                {
                    temp1=(struct poly*)malloc(sizeof(LEN));
                    temp1->index=p->index;
                    temp1->ratio=p->ratio;
                    rear->next=temp1;
                    rear=temp1;
                    rear->next=NULL;
                    p=p->next;
                }
                else if(p->index>q->index)
                {
                    temp1=(struct poly*)malloc(sizeof(LEN));
                    temp1->index=q->index;
                    temp1->ratio=q->ratio;
                    rear->next=temp1;
                    rear=temp1;
                    rear->next=NULL;
                    q=q->next;
                }
                else
                {
                    temp1=(struct poly*)malloc(sizeof(LEN));
                    temp1->index=p->index;
                    temp1->ratio=q->ratio+p->ratio;
                    if(temp1->ratio!=0)
                    {
                        rear->next=temp1;
                        rear=temp1;
                        rear->next=NULL;
                        p=p->next;
                        q=q->next;
                    }
                    else
                    {
                        p=p->next;
                        q=q->next;
                    }
                }
    
            }//若head1和head2都不为空,则按照升幂的次序将其排序相加,系数为0的项不需要,注意,一定要按照次序来,少使用排序函数
        } 
       void print(struct poly *head);
       print(head);
      
    
       
    };//对两多项式进行求和,求和结果储存在另一个结构体中
    struct poly sub(struct poly *head1,struct poly *head2)
    {
        struct poly *head,*rear,*temp1,*temp2,*p,*q;
        head=rear=(struct poly*)malloc(sizeof(LEN));
        head->next=rear->next=NULL;
        p=head1->next;
        q=head2->next;
    
        while(p!=NULL||q!=NULL)
        {
            if(p==NULL||q==NULL)
            {
                if(p==NULL)
                {
                    while(q!=NULL)
                    {
                        temp1=(struct poly*)malloc(sizeof(LEN));
                        rear->next=temp1;
                        temp1->next=NULL;
                        temp1->index=q->index;
                        temp1->ratio=-q->ratio;
                        rear=temp1;
                        q=q->next;
                    }
                }
                else if(q==NULL)
                {
                    while(p!=NULL)
                    {
                        temp1=(struct poly*)malloc(sizeof(LEN));
                        rear->next=temp1;
                        temp1->next=NULL;
                        temp1->index=p->index;
                        temp1->ratio=p->ratio;
                        rear=temp1;
                        p=p->next;
                    }
                }
            }
            else
            {
                if(p->index<q->index)
                {
                    temp1=(struct poly*)malloc(sizeof(LEN));
                    temp1->index=p->index;
                    temp1->ratio=p->ratio;
                    rear->next=temp1;
                    rear=temp1;
                    rear->next=NULL;
                    p=p->next;
                }
                else if(p->index>q->index)
                {
                    temp1=(struct poly*)malloc(sizeof(LEN));
                    temp1->index=q->index;
                    temp1->ratio=-q->ratio;
                    rear->next=temp1;
                    rear=temp1;
                    rear->next=NULL;
                    q=q->next;
                }
                else
                {
                    temp1=(struct poly*)malloc(sizeof(LEN));
                    temp1->index=p->index;
                    temp1->ratio=p->ratio-q->ratio;
                    if(temp1->ratio!=0)
                    {
                        rear->next=temp1;
                        rear=temp1;
                        rear->next=NULL;
                        p=p->next;
                        q=q->next;
                    }
                    else
                    {
                        p=p->next;
                        q=q->next;
                    }
                }
    
            }
            
            
        }
      
       void print(struct poly *head);
       print(head);
       
       
    };//多项式求差,与求和同理
    
    
    void print(struct poly *head)
    {   FILE * fp;
    	fp=fopen("test18.txt","a+");
        struct poly *temp;
        temp=head->next;
        if(temp==NULL)
        {
            fprintf(fp,"0\n");
            return;
        }//多项式的输出,若多项式为NULL则直接输出0
        while(temp!=NULL)
        {
            if(temp==head->next)
            {
                fprintf(fp," %.2f",temp->ratio);
                if(temp->index!=0)
                {
                    if(temp->index==1)
                        fprintf(fp,"x");
                    else
                        fprintf(fp,"x^%d",temp->index);
                }
                else
                    fprintf(fp," ");
            }//在输出第一项时,系数为正,直接输出,系数为负,也直接输出
            else
            {
                if(temp->ratio>0)
                {
                    fprintf(fp,"+%.2f",temp->ratio);
                    if(temp->index!=0)
                    {
                        if(temp->index==1)
                            fprintf(fp,"x");
                        else
                            fprintf(fp,"x^%d",temp->index);
                    }
    
                    else
                        fprintf(fp," ");
                }
                else
                {
                    fprintf(fp,"%.2f",temp->ratio);
                    if(temp->index!=0)
                    {
                        if(temp->index==1)
                            fprintf(fp,"x");
                        else
                            fprintf(fp,"x^%d",temp->index);
                    }
    
                    else
                        fprintf(fp," ");
                }//之后的每一项中,系数为正,则加上正号,即加号,系数为负,可直接输出
            }
            temp=temp->next;
        }
        fprintf(fp,"\n");
    fclose(fp);
    };
    
    int main()
    {
    	int a,b;
        head1=creat();
        head2=creat();
        sort(head1);
        sort(head2);
        printf("\n多项式a(x)为:\n");
        print(head1);
        printf("\n多项式b(x)为:\n");
        print(head2);
        printf("\n两多项式之和为:\n");
        add(head1,head2);
        printf("\n两多项式之差为:\n");
        sub(head1,head2);
       
        
        return 0;
    }
    
    
    展开全文
  • 一元多项式相加减(数据结构)

    千次阅读 2017-10-25 15:40:37
    //完成多项式相加运算,即:Pa = Pa + Pb,并销毁一元多项式Pb void AddPolyn(polynomial &Pa,polynomial &Pb); //完成多项式相减运算,即:Pa = Pa - Pb,并销毁一元多项式Pb void SubtractPolyn(polynomial &Pa,...
    /*
      Name: 类C通用模块 
      Copyright: BTC 2004
      Author: Zhuang Bo
      Date: 2004
      Description:  
        [Constants]
           TRUE/FALSE/OK/ERROR/INFEASIBLE/DS_OVERFLOW      
        [Types]  
           Status      
        [Functions]
           max(a,b)
           min(a,b)
           read(char/int/float/double/char*)
           write(char/int/float/double/char*)
    */
    
    #ifndef _DS_H_
    #define _DS_H_
    
    // 函数结果状态代码
    const int TRUE      = 1;
    const int FALSE     = 0;
    const int OK        = 1;
    const int ERROR     = 0;
    const int INFEASIBLE    = -1;
    const int DS_OVERFLOW      = -2;
    
    // Status 是函数的类型,其值是函数结果状态代码
    typedef int Status;
    
    //基本函数
    #define max(a,b) (((a)<(b))?(b):(a)) 
    #define min(a,b) (((a)<(b))?(a):(b))
    
    #include <stdio.h>
    //不用格式串的输入输出(目的是为了方便书写算法)
    //    比如输入一个基本类型(char, int, float, double, char*)的
    //    变量 x,可以直接用 read(x);输入,而打印则用 write(x);。 
    //    对于自定义类型,可以继续扩充。
    inline void readM(char& e)     { getchar(); e = getchar(); }
    inline void read(char& e)     {  e = getchar(); }
    inline void read(int& e)      { scanf("%d", &e); }
    inline void read(float& e)    { scanf("%f", &e); }
    inline void read(double& e)   { scanf("%lf", &e); }
    inline void read(char *e)     { gets(e); }
    inline void read(float &e1, int &e2)  {scanf("%f%d",&e1,&e2);}
    inline void write(char e)     { printf("%c", e); }
    inline void write(int e)      { printf("%d", e); }
    inline void write(float e)    { printf("%f", e); }
    inline void write(double e)   { printf("%lf", e); }
    inline void write(char *e)    { printf("%s",e); }
    
    
    
    #endif  // _DS_H_
    
    
    /* 
       Name: Polynomial.h
       Author: WangHeng
       Data: 3 / 4 / 2017 ;
       Description: 1)调用LinkList.h头文件,用实现链表的各种功能
                      来创建一元多项式的各种算法实现;
                    2)调用ds.h来进行基本的输入输出等操作
                    3)头文件Polynomial.h主要完成一元多项式的各种操作
    
    */
    
    #ifndef POLYNOMIAL_H_INCLUDED
    #define POLYNOMIAL_H_INCLUDED
    
    #ifndef ElemType
    #define ElemType int //数据类型默认为int
    #define ELEMTYPE_TAG
    #endif 
    
    #include "ds.h"
    #include "LinkList.h"
    
    typedef LinkList polynomial;
    
    /*************************************************************************
    *  基本操作的函数原型说明
    *************************************************************************/
    
    //输入m项的系数和指数,建立表示一元多项式的有序链表P
    void CreatPolyn(polynomial &P, int m);
    
    //销毁一元多项式P
    void DestroyPolyn(polynomial &P);
    
    //打印输出一元多项式P
    void PrintPolyn(polynomial P);
    
    //返回一元多项式P中的项数
    int PolynLength(polynomial P);
    
    //完成多项式相加运算,即:Pa = Pa + Pb,并销毁一元多项式Pb
    void AddPolyn(polynomial &Pa,polynomial &Pb);
    
    //完成多项式相减运算,即:Pa = Pa - Pb,并销毁一元多项式Pb
    void SubtractPolyn(polynomial &Pa,polynomial &Pb);
    
    //完成多项式相乘运算,即:Pa = Pa * Pb,并销毁一元多项式Pb
    void MultiplyPolyn(polynomial &Pa,polynomial &Pb);
    
    //完成多项式的求导函数,即:Pa = Pa' 
    void Derivative(polynomial &P);
    
    //完成多项式的积分函数, Pa = ∫Pa' dx 
    void Calculus (polynomial &P);
    
    
    /*********************************************************************
    * 基本操作的算法描述和实现
    *********************************************************************/
    
    //创建一元多项式P,当输入的指数和系数都为0时,输入结束。
    // 一元多项式就被创建 。   
    void CreatPolyn(polynomial &P)
    {
    
        InitList(P);
        printf(" \n输入系数和指数:\n");
        read(P->coef,P->expn);     //输入系数和指数
                                   //这里的read读的是ds.h通用模板中的inline void read(float &e1, int &e2)  {scanf("%f%d",&e1,&e2);}
                                   //通用模板中的read可以是任意类型的
        //-------------------TODO------------------//
        while(P->coef!=0||P->expn!=0){
               ListInsert(P,1,P->coef,P->expn);
               printf("\n输入系数的指数:\n");
               read(P->coef,P->expn);
        }
        //------------初始化表达式,不断输入系数和指数,直到读到0,0为止----------//
    
    }
    
    //销毁一元多项式P
    void DestroyPolyn(polynomial &P)
    {
        DestroyList(P);   //调用LinkList.h头文件中的销毁函数
    
    }
    
    //打印输出一元多项式P
    void PrintPolyn(polynomial P)
    {
        printf("打印一员多项式的各系数和指数\n ");
        UnionList(P);   //用来合并在一元多项式计算结果中具有相同指数的项
        PrintLinkList(P);   
    }
    
    //返回一元多项式P中的项数
    int PolynLength(polynomial P)
    {
        return ListLength(P);    //合并后的一元多项式的项数
    }
    
    //完成多项式相加运算,即:Pa = Pa + Pb,并销毁一元多项式Pb
    void AddPolyn(polynomial &Pa,polynomial &Pb)
    {
        UnionList(Pa);   //合并一元多项式中具有
        UnionList(Pb);   //相同指数的项
    
    
        for (int i=1; i<=ListLength(Pb); i++)
        {
            float co;
            int ex;
            GetElem(Pb, i, co, ex);
            if(LocateElem(Pa, ex) > 0)    //判断Pa中是否具有Pb中相同指数的项,
            {                             //如果有,进行相加 
                int j = LocateElem(Pa, ex);   //记录Pa中相同项的位置
                int k = 0;
                polynomial s = Pa;
                while(k < j)     //查找这一位置
                {
            //-------------------TODO------------------//
                 s=s->next;
                 k++;
                }
    
                s->coef += co;    //系数项相加
    
            }
            else       //不存在相同的指数,将Pb中的该项插入Pa
                ListInsert(Pa, 1, co, ex);
        }
        DestroyList(Pb);    //销毁Pb  
    }
    
    
    
    //完成多项式相减运算,即:Pa = Pa - Pb,并销毁一元多项式Pb
    void SubtractPolyn(polynomial &Pa,polynomial &Pb)
    {
        UnionList(Pa);   //合并一元多项式中具有
        UnionList(Pb);   //相同指数的项
    
    
        for (int i=1; i<=ListLength(Pb); i++)
        {
            float co;
            int ex;
            GetElem(Pb, i, co, ex);
            if(LocateElem(Pa, ex) > 0)    //判断Pa中是否具有Pb中相同指数的项,
            {                             //如果有,进行相加 
                int j = LocateElem(Pa, ex);   //记录Pa中相同项的位置
                int k = 0;
                polynomial s = Pa;
                while(k < j)     //查找这一位置
                {
            //-------------------TODO------------------//
                 s=s->next;
                 k++;
                }
    
                s->coef -= co;    //系数项相加
    
            }
            else       //不存在相同的指数,将Pb中的该项插入Pa
                ListInsert(Pa, 1, co, ex);
        }
        DestroyList(Pb);    //销毁Pb  
    
    }
    
    //完成多项式相乘运算,即:Pa = Pa * Pb,并销毁一元多项式Pb
    void MultiplyPolyn(polynomial &Pa,polynomial &Pb)
    {
            UnionList(Pa);   //合并一元多项式中具有
        UnionList(Pb);   //相同指数的项
    
    
        for (int i=1; i<=ListLength(Pb); i++)
        {
            float co;
            int ex;
            GetElem(Pb, i, co, ex);
            if(LocateElem(Pa, ex) > 0)    //判断Pa中是否具有Pb中相同指数的项,
            {                             //如果有,进行相加 
                int j = LocateElem(Pa, ex);   //记录Pa中相同项的位置
                int k = 0;
                polynomial s = Pa;
                while(k < j)     //查找这一位置
                {
            //-------------------TODO------------------//
                 s=s->next;
                 k++;
                }
    
                s->coef *= co;    //系数项相加
                s->expn+=ex;
            }
            else       //不存在相同的指数,将Pb中的该项插入Pa
                ListInsert(Pa, 1, co, ex);
        }
        DestroyList(Pb);    //销毁Pb
    }
    
    
    //完成多项式的求导函数,即:Pa = Pa' 
    void Derivative(polynomial &P)
    {
    
    }
    
    //完成多项式的积分函数, Pa = ∫Pa' dx 
    void Calculus (polynomial &P)
    {
    
    }
    
    #ifdef ELEMTYPE_TAG
    #undef ElemType
    #undef ELEMTYPE_TAG
    #endif
    
    #endif  // POLYNOMIAL_H_INCLUDED
    
    

    这里写图片描述

    这里写图片描述
    这里写图片描述

    展开全文
  • 一元多项式相加

    2012-04-15 11:05:06
    一元多项式相加 c c++ 算法 数据结构
  • 一元多项式相加 实现了一元多项式相加 教你熟悉运用C语言编程
  • c++一元多项式相加源码
  • 相加相减运行不来,C语言和数据结构自己学的不好,一元多项式相加减是第一个大作业,感觉自己好像没问题,求指点谢谢!
  • 一元多项式相加实验报告(C语言实现)
  • JAVA一元多项式相加

    2010-04-20 21:19:26
    用JAVA来实现数据结构的一元多项式相加
  • 一元多项式相加 C++

    2009-09-22 12:40:50
    一元多项式相加的 一个程序 你仔仔 看 啊
  • 五、一元多项式相加

    2020-07-22 11:07:10
    五、一元多项式相加 文章目录五、一元多项式相加题目描述解题思路上机代码 题目描述 编写一元多项式加法运算程序。要求用线性链表存储一元多项式(参照课本)。该程序有以下几个功能: 1、多项式求和 输入:输入三...

    五、一元多项式相加

    题目描述

    编写一元多项式加法运算程序。要求用线性链表存储一元多项式(参照课本)。该程序有以下几个功能:

    1、多项式求和

    • 输入:输入三个多项式,建立三个多项式链表Pa、Pb、Pc

    (提示:调用CreatePolyn(polynomial &P,int m)。

    • 输出:显示三个输入多项式Pa、Pb、Pc、和多项式Pa+Pb、多项式Pa+Pb+Pc

    (提示:调用AddPolyn(polynomial &Pa, polynomial Pb), 调用PrintPolyn(polynomial P))。

    0、退出

    输入

    根据所选功能的不同,输入格式要求如下所示(第一个数据是功能选择编号,参见测试用例):

    • 1

      • 多项式A包含的项数,以指数递增的顺序输入多项式A各项的系数(整数)、指数(整数)
      • 多项式B包含的项数,以指数递增的顺序输入多项式B各项的系数(整数)、指数(整数)
      • 多项式C包含的项数,以指数递增的顺序输入多项式C各项的系数(整数)、指数(整数)
    • 0

      • 操作终止,退出。

    输出

    对应一组输入,输出一次操作的结果(参见测试用例)。

    • 1

      多项式输出格式:以指数递增的顺序输出: <系数,指数>,<系数,指数>,<系数,指数>,参见测试用例。零多项式的输出格式为<0,0>

    • 0

      无输出

    测试输入期待的输出时间限制内存限制额外进程
    测试用例 11
    2
    1 1 2 2
    2
    1 1 2 2
    2
    1 1 2 2
    <1,1>,<2,2>
    <1,1>,<2,2>
    <1,1>,<2,2>
    <2,1>,<4,2>
    < 3,1>,<6,2>
    1秒1024KB0
    测试用例 21
    2
    6 3 8 6
    2
    3 4 4 8
    3
    1 1 5 5 9 9
    <6,3>,<8,6>
    < 3,4>,<4,8>
    <1,1>,<5,5>,<9,9>
    <6,3>,< 3,4>,<8,6>,<4,8>
    <1,1>,<6,3>,< 3,4>,<5,5>,<8,6>,<4,8>,<9,9>
    1秒1024KB0
    测试用例 31
    2
    1 1 2 2
    2
    -1 1 -2 2
    2
    1 1 2 2
    <1,1>,<2,2>
    <-1,1>,<-2,2>
    <1,1>,<2,2>
    <0,0>
    <1,1>,<2,2>
    1秒1024KB0

    解题思路

    教材上的解法挺好,就是显得比较麻烦,需要调用的函数较多。这里我们采用链表的方式进行求解,实现三个函数即可:

    • 构造多项式create()
    • 多项式相加add()
    • 打印多项式print()

    其中多项式相加是核心,因为输入是按指数递增的顺序,所以我们只需要分三种情况进行讨论,直接求和就好。若某一个链表较长,还需要单独遍历后续结点。

    还有一个要注意的点就是,零多项式的输出是<0,0>,对于零多项式也需要建立结点

    上机代码

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    typedef struct node
    {
    	int ax, ex;//系数、指数
    	struct node *next;
    }LinkNode, *LinkList;
    
    LinkList create(int);//构造多项式
    LinkList add(LinkList, LinkList);//多项式相加
    void print(LinkList);//打印多项式
    
    int main()
    {
    	int T = 1;
    	scanf("%d", &T);
    	//0为假,1为真
    	if(T)
    	{
    		LinkList head1, head2, head3, p;
    
    		//构造多项式
    		int n=0;
    		scanf("%d", &n);
    		head1 = create(n);
    		print(head1);
    
    		scanf("%d", &n);
    		head2 = create(n);
    		print(head2);
    
    		scanf("%d", &n);
    		head3 = create(n);
    		print(head3);
    
    		//多项式相加并输出
    		p = add(head1, head2);
    		print(p);
    		p = add(p, head3);
    		print(p);
    	}	
    	return 0;
    }
    
    LinkList create(int n)
    {
    	LinkList head, q;
    	int ax=0, ex=0;
    
    	//初始化头结点
    	head = (LinkList)malloc(sizeof(LinkNode));
    	head->next=NULL;
    	q = head;
    
    	while(n--)
    	{
    		scanf("%d%d", &ax, &ex);
    
    		//尾插法建立链表
    		LinkList p = (LinkList)malloc(sizeof(LinkNode));
    		p->ax = ax;
    		p->ex = ex;
    		p->next = NULL;
    
    		q->next = p;
    		q = p;
    	}
    
    	//如果没有输入则置0
    	if(q == head)
    	{
    		LinkList p = (LinkList)malloc(sizeof(LinkNode));
    		p->ax = 0;
    		p->ex = 0;
    		p->next = NULL;
    
    		q->next = p;
    		q = p;
    	}
    
    	return head;
    }
    
    LinkList add(LinkList head1, LinkList head2)
    {
    	/* 链表 head3 = head1 + head2 */
    	//初始化头结点
    	LinkList head3, ans;
    	head3 = (LinkList)malloc(sizeof(LinkNode));
    	head3->next = NULL;
    	ans = head3;
    
    	LinkList p, q;
    	p = head1->next;
    	q= head2->next;
    
    	/* 因为输入按指数递增的顺序,直接开始求和即可, 分为三种情况讨论:
    		1. p指数小于q
    		2. p指数大于q
    		3. p指数等于q
    	*/
    	while(p != NULL && q != NULL)
    	{
    		if(p->ex < q->ex)//p指数小于q
    		{
    			if(p->ax)//系数不为0才进行操作
    			{
    				//尾插法
    				LinkList s = (LinkList)malloc(sizeof(LinkNode));
    				s->ax = p->ax;
    				s->ex = p->ex;
    				s->next = NULL;
    
    				ans->next = s;
    				ans = s;
    			}
    			p = p->next;
    		}
    		else if(p->ex > q->ex)//p指数大于q
    		{
    			if(q->ax)
    			{
    				LinkList s = (LinkList)malloc(sizeof(LinkNode));
    				s->ax = q->ax;
    				s->ex = q->ex;
    				s->next = NULL;
    
    				ans->next = s;
    				ans = s;
    			}
    			q = q->next;
    		}
    		else//p指数等于q
    		{
    			if(p->ax + q->ax)//系数求和不为0才进行操作
    			{
    				LinkList s = (LinkList)malloc(sizeof(LinkNode));
    				s->ax = p->ax + q->ax;
    				s->ex = p->ex;
    				s->next = NULL;
    
    				ans->next = s;
    				ans = s;
    			}
    			p = p->next;
    			q = q->next;
    		}
    	}
    	//如果某一个链表较长,则需要单独遍历
    	while(p != NULL)
    	{
    		if(p->ax)
    		{
    			LinkList s = (LinkList)malloc(sizeof(LinkNode));
    			s->ax = p->ax;
    			s->ex = p->ex;
    			s->next = NULL;
    
    			ans->next = s;
    			ans = s;
    		}
    		p = p->next;
    	}
    	while(q != NULL)
    	{
    		if(q->ax)
    		{
    			LinkList s = (LinkList)malloc(sizeof(LinkNode));
    			s->ax = q->ax;
    			s->ex = q->ex;
    			s->next = NULL;
    
    			ans->next = s;
    			ans = s;
    		}
    		q = q->next;
    	}
    	//如果求和的结果为0则置0
    	if(ans == head3)
    	{
    		LinkList s = (LinkList)malloc(sizeof(LinkNode));
    		s->ax = 0;
    		s->ex = 0;
    		s->next = NULL;
    
    		ans->next = s;
    		ans = s;
    	}
    
    	return head3;
    }
    
    void print(LinkList p)
    {
    	p = p->next;//越过头结点
    	while(p->next != NULL)
    	{
    		printf("<%d,%d>,", p->ax, p->ex);
    		p = p->next;
    	}
    	printf("<%d,%d>\n", p->ax, p->ex);//最后一个结点
    }
    
    展开全文
  • 一元多项式相加问题的实验报告.doc
  • 一元多项式相加c实现

    2013-04-18 20:26:47
    c语言实现一元多项式相加,用两种方法实现,数组和链表!
  • 对一元多项式能实现输入、输出,以及两个一元多项式相加及结果显示,实现链表的说明、创建以及结点的插入和删除等操作,使用vs2010直接打开就可以
  • 两个一元多项式相加的程序——/定义结点 /创建链表 /递增排序 /两个多项式相加 /显示多项式 /主函数
  • 实验2 一元多项式相加

    千次阅读 2017-12-05 13:52:24
    结合书上第41页的例子,采用链式存储结构,将两个线性链表表示的一元多项式相加,并输出。此一元多项式遵循多项式相加运算规则:对于两个一元多项式中存在指数相同的项时,其对应系数相加。合并后系数和为零时,删除...
  • 中南大学 数据结构与算法课程实验 实验报告 题目 实验一线性表的操作 学生姓名 谭淇蔚 学生学号 3901130721 专业班级 软件工程 1307班 完成日期 2014 年 3 月 31 日星期一 实验一线性表的操作一元多项式相加 1....
  • 一元多项式相加,输入两个一元多项式,进行相加运算,输入系数和指数,以0,0为结束
  • C语言一元多项式相加(链表)

    千次阅读 多人点赞 2020-10-30 21:10:52
    今天写一个关于一元多项式相加的程序,就当是在练习运用一下链表的知识。首先,我们先来分析一波,一元多项式相加,首先要用链表创建两个或多个多项式,每个节点里的数据有两个,系数和指数;其次,如果要实现乱幂...
  • Poly CreatePoly(Poly head, int m){//建立一个头指针为head、项数为m的一元多项式 int i; Poly p; p = head = (Poly)malloc(sizeof(struct Polyomial)); head->next = NULL; for (i = 0; i ; i++){ p = ...

空空如也

空空如也

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

一元多项式相加减