C语言实现——一元多项式运算器

雨点打透心脏的1/2处 2024-04-19 16:23 84阅读 0赞

/*
    程序简介：
    功能：对多项式求值，求导，两多项式相加，相减，相乘等运算
    作者：xuqg
    时间：2019.9.19 
    */
    
    #include<stdio.h>
    #include<stdlib.h>
    #include<math.h>
    
    typedef struct NodeType{
    	int id;//系数 
    	int index;//指数 
    	struct NodeType *next;
    }Nodetype;
    
    NodeType *CreatList();//创建一个人链表，用来存放一个多项式，返回一个头指针 
    void PrintList(NodeType *pHead);//输出函数，输出多项式的表达式 
    int Evaluation(NodeType *la,int x);//输入x，求表达式的值 
    NodeType *TwoListAdd(NodeType *la,NodeType *lb);//两个多项式求和 
    NodeType *MultipTwoList(NodeType *la,NodeType *lb);//两个多项式求相减 
    NodeType *TwoListSubtract(NodeType *la,NodeType *lb);//两个多项式相乘 
    NodeType *ListQiuDao(NodeType *la);//多项式求导 
    
    //主要是数据的测试
    int main(){
    	
    	NodeType *la;
    	printf("\n---------------------请输入第一个多项式---------------------\n");
    	la = CreatList();
    	printf("第一个多项式的信息为：");
    	PrintList(la);
    	
    	NodeType *lb;
    	printf("\n---------------------请输入第二个多项式---------------------\n");
    	lb = CreatList();
    	printf("第二个多项式的信息为：");
    	PrintList(lb);
    	
    	int x;
    	int a,b;
    	printf("请输入x的值：");
    	scanf("%d",&x);
    	
    	/*
    	a=Evaluation(la,x);
    	printf("suma=%d\n",a);
    	b=Evaluation(lb,x);
    	printf("sumb=%d\n",b);
    	printf("suma*sumb=%d\n",a*b);*/
    	
    	NodeType *lf;
    	lf=MultipTwoList(la,lb);
    	printf("---------------------第一个与第二个多项式的乘法为---------------------\n");
    	PrintList(lf);/*
    	printf("第一个多项式的信息为：\n");
    	PrintList(la);
    	printf("第二个多项式的信息为：\n");
    	PrintList(lb);
    	a=Evaluation(lf,x);
    	printf("sumMU=%d\n",a);*/
    	
    	NodeType *lc;
    	lc=TwoListAdd(la,lb);
    	printf("---------------------第一个与第二个多项式的和为---------------------\n");
    	PrintList(lc);
    	/*printf("第一个多项式的信息为：\n");
    	PrintList(la);
    	printf("第二个多项式的信息为：\n");
    	PrintList(lb);*/
    	
    
    	NodeType *ld;
    	ld=TwoListSubtract(la,lb);
    	printf("第一个与第二个多项式的差为：\n");
    	PrintList(ld);
    	/*printf("第一个多项式的信息为：\n");
    	PrintList(la);
    	printf("第二个多项式的信息为：\n");
    	PrintList(lb);*/
    	
    	NodeType *le=ListQiuDao(la);
    	printf("第一个求导的后的值为：\n");
    	PrintList(le);
    	/*printf("第一个多项式的信息为：\n");
    	PrintList(la);
    	*/ 
    	
    	return 0;
    }
    
    //创建一个人链表，用来存放一个多项式，返回一个头指针
    //创建一个带有头结点的单链表,本代码中的链表都是带有头结点的  
    NodeType *CreatList(){
    	
    	NodeType *pNew,*pEnd;
    	NodeType *pHead = (NodeType *)malloc(sizeof(NodeType));
    	pHead->next = NULL;
    	pEnd = pHead;
    	
    	printf("————注意要将指数按从小到大依次输入————");
    	printf("请依次交叉输入表达式id(系数)和index(指数)(id=0时退出)：");
    	while(1){
    		
    		int id,index;
    		pNew = (NodeType *)malloc(sizeof(NodeType));
    		scanf("%d",&id);
    		if(id == 0)  break;
    		scanf("%d",&index);
    		pNew->id=id;
    		pNew->index=index;
    		
    		pEnd->next = pNew;	
    		pNew->next = NULL;
    		pEnd = pNew;		
    	}
    	return pHead;			
    }
    
    //输出函数，输出多项式的值 
    void PrintList(NodeType *pHead){
    	
    	NodeType *pTemp = pHead->next;
    
    	while(pTemp!=NULL){
    		
    		//当一个一元多项式的系数（-1\1或其他）和指数（0或其他）不同时，输出的格式不同 
    		if(pTemp->id==1&&pTemp->index!=0)        printf("x^%d",pTemp->index);
    		else if(fabs(pTemp->id)==1&&pTemp->index==0)	 printf("%d",pTemp->id);
    		else if(fabs(pTemp->id)==1&&pTemp->index!=0)   printf("x^%d",pTemp->index);
    		else 	printf("%dx^%d",pTemp->id,pTemp->index);
    		
    		pTemp = pTemp->next;
    		
    		//输出适当的+号和- 
    		if(pTemp!=NULL&&pTemp->id>0) 		printf("+");
    	}	
    }
    
    //两个多项式求和 
    NodeType *TwoListAdd(NodeType *la,NodeType *lb){
     	
     	NodeType *pa;
     	NodeType *pb;
     	NodeType *pc,*qc;
     	
     	pa=la->next;
     	pb=lb->next;
     	NodeType *lc=(NodeType *)malloc(sizeof(NodeType));//创建一个带头结点的单链表用来存放来年各个多项式和的值 
     	lc->next=NULL; 
     	
     	pc=lc;
     	
     	//pa,pb不为NULL时，比较指数大小进行…… 
     	while(pa!=NULL&&pb!=NULL){//while{}
     		
     		qc=(NodeType *)malloc(sizeof(NodeType));
     		if(pa->index<pb->index){
     			qc->id=pa->id;
     			qc->index=pa->index;
     			
     			pa=pa->next;
     			pc->next=qc;
     			qc->next=NULL;
     			pc=qc;
    		 }
    		 
    		else if(pa->index>pb->index){
    		 	qc->id=pb->id;
     			qc->index=pb->index;
     			
     			pb=pb->next;
     			pc->next=qc;
     			qc->next=NULL;
     			pc=qc;
    		 }
    		
    		else{
    		 	
    		 	qc->index=pa->index;
    		 	qc->id=pa->id+pb->id;
    		 	
    		 	if(qc->id==0){
    		 		free(qc);	
    			 }
    			 
    		 	else{	
    		 	pc->next=qc;
     			qc->next=NULL;
     			pc=qc;	
    			 }
    			 
    			pa=pa->next;
    			pb=pb->next; 	
    		 }
     		}//while{}
     		
     		
     		while(pa!=NULL){
     			qc=(NodeType *)malloc(sizeof(NodeType));
     			qc->id=pa->id;
     			qc->index=pa->index;
     			
     			pa=pa->next;
     			pc->next=qc;
     			qc->next=NULL;
     			pc=qc;
     			
    		 }
     		
     		
     		while(pb!=NULL){
     			qc=(NodeType *)malloc(sizeof(NodeType));
     			qc->id=pb->id;
     			qc->index=pb->index;
     			
     			pb=pb->next;
     			pc->next=qc;
     			qc->next=NULL;
     			pc=qc;
    		 }
     		
    
     	return lc;
     	
     }
    
    //两个多项式求相减 
    NodeType *TwoListSubtract(NodeType *la,NodeType *lb){
    
     	NodeType *pb;
     	NodeType *ld;
     	pb=lb->next;
    	 
    	//将减数多项式lb系数变成相反数-lb，在求和就是两个多项式相减 
    	while(pb!=NULL){
    		pb->id=-pb->id;
    		pb=pb->next;
    	} 
    	
    	ld=TwoListAdd(la,lb);
    	
    	//将pb指向头指针，将lb的符号变回来 
    	pb=lb->next;
    	while(pb!=NULL){
    		pb->id=-pb->id;
    		pb=pb->next;
    	} 
    	
    	return ld;
    	} 
    
    //多项式求导 
    NodeType *ListQiuDao(NodeType *la){
    	
    	NodeType *le=(NodeType *)malloc(sizeof(NodeType));
    	NodeType *pe,*qe;
    	NodeType *pa=la->next;
    	
    	le->next=NULL;
    	pe=le;
    	
    	while(pa!=NULL){	
    		
    		//常数项的导数为零 
    		if(pa->index!=0){	
    			qe=(NodeType *)malloc(sizeof(NodeType));
    			qe->id=pa->id*pa->index;
    			qe->index=pa->index-1;
    			
     			pe->next=qe;
     			qe->next=NULL;
     			pe=qe;
    		}
    		pa=pa->next;
    	}
    	
    	return le;	
    }
    
    //两个多项式相乘 
    NodeType *MultipTwoList(NodeType *la,NodeType *lb){
    	
    	NodeType *lf=(NodeType *)malloc(sizeof(NodeType));
    	lf->next=NULL;
    	NodeType *pa=la->next;
    	NodeType *pb;
    	
    	//用一个多项式的一项分别乘以另一个多项式每一项，然后相加 
    	while(pa!=NULL){
    		pb=lb->next;
    		NodeType *lalb=(NodeType *)malloc(sizeof(NodeType));
    		NodeType *pab,*qab;
    		lalb->next=NULL;
    		pab=lalb;
    		
    		while(pb!=NULL){
    			qab=(NodeType *)malloc(sizeof(NodeType));
    			qab->id=pa->id*pb->id;
    			qab->index=pa->index+pb->index;
    			
    			pab->next=qab;
    			pab->next->next=NULL;
    			pab=qab;
    			pb=pb->next;
    		}
    			
    		lf=TwoListAdd(lf,lalb);
    		pa=pa->next;
    	}
    	return lf;
    }
    
    //输入x，求表达式的值 
    int Evaluation(NodeType *la,int x){
    	NodeType *pa=la->next;
    	int sumla=0;
    	int sum;
    	
    	while(pa!=NULL){
    		sum=1;
    		for(int i=0;i<pa->index;i++){
    			sum=sum*x;
    		}
    		sumla=sumla+pa->id*sum;	
    		pa=pa->next; 	
    	}
    	return sumla;
    }
    
    https://mp.csdn.net/postedit/101036340