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

/*
程序简介：
功能：对多项式求值，求导，两多项式相加，相减，相乘等运算
作者：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