C语言链表实现整数系数多项式加法、减法、乘法

#include <stdio.h>
#include <stdlib.h>

typedef struct Polynomial{
	int coeffNum;//每项的系数
	int Power;//每项的幂
	struct Polynomial *next;
}Polynomial_t;

Polynomial_t *list_create_node(void)
{
	Polynomial_t *head = (Polynomial_t *)malloc(sizeof(Polynomial_t));
	
	return head;
}

void list_free(Polynomial_t *head)
{
	if(!head)
	{
		printf("List is null.\n");
		return;
	}
	
	Polynomial_t *pNode=NULL;
	while(head)
	{
		pNode=head->next;
		free(head);
		head=pNode;
	}
	head=NULL;
}

//多项式初始化（赋值）
void poly_init(Polynomial_t *head, int *coeff, int *power,int numsSize)
{
	int idx=0;
	Polynomial_t *pNode=NULL;
	if(!head)
	{
		head=list_create_node();
		if(!head)
		{
			printf("list_create_node error.\n");
			return;
		}
	}
	head->coeffNum=coeff[0];
	head->Power=power[0];
	pNode=head;
	
	for(idx=1;idx<numsSize;idx++)
	{
		pNode->next=list_create_node();
		pNode=pNode->next;
		pNode->coeffNum=coeff[idx];
		pNode->Power=power[idx];
	}
}

void print_list(Polynomial_t *head)
{
	if(!head)
	{
		printf("List head is NULL.\n");
		return;
	}
	
	printf("\n******************* %s START *******************\n", __FUNCTION__);
	Polynomial_t *pNode=head;
	while(pNode)
	{
		printf("coeff=%d, power=%d\n", pNode->coeffNum, pNode->Power);
		pNode=pNode->next;
	}
	printf("******************* %s END *******************\n", __FUNCTION__);
}

/*多项式相加*/
Polynomial_t *polyno_add(Polynomial_t *P1, Polynomial_t *P2)
{
	if(!P1 || !P2)
	{
		printf("Invalid List head.\n");
		return NULL;
	}

	Polynomial_t *p1=P1, *p2=P2;
	Polynomial_t *Pnew=list_create_node();
	Pnew->coeffNum=p1->coeffNum;
	Pnew->Power=p1->Power;
	p1=p1->next;
	
	Polynomial_t *pHead=Pnew;
	int combined=0;
	
	while(p1)
	{
		Pnew->next=list_create_node();
		Pnew->next->coeffNum=p1->coeffNum;
		Pnew->next->Power=p1->Power;
		Pnew=Pnew->next;
		p1=p1->next;
	}
	
	while(p2)
	{
		combined=0;
		Pnew=pHead;
		while(Pnew->next)
		{
			if(p2->Power==Pnew->Power)
			{
				Pnew->coeffNum +=p2->coeffNum;
				combined=1;
				break;
			}
			Pnew=Pnew->next;
		}
		if(combined==0)
		{
			Pnew->next=list_create_node();
			Pnew->next->coeffNum=p2->coeffNum;
			Pnew->next->Power=p2->Power;
		}
		p2=p2->next;
	}
	
	Pnew=pHead;
	
	return Pnew;
}

/*
**多项式相减，需要明确减数和被减数：subtrahend减数，minuend被减数；
**例如：P1(X)-P2(X), 那么subtrahend传P1(X), minuend传P2(X)；
*/
Polynomial_t *polyno_sub(Polynomial_t *subtrahend, Polynomial_t *minuend)
{
	if(!subtrahend || !minuend)
	{
		printf("Invalid List head.\n");
		return NULL;
	}

	Polynomial_t *pSub=subtrahend, *pMin=minuend;
	Polynomial_t *PolyHead=list_create_node();
	PolyHead->coeffNum=pSub->coeffNum;
	PolyHead->Power=pSub->Power;
	pSub=pSub->next;
	
	Polynomial_t *pNode=PolyHead;
	int combined=0;
	
	while(pSub)
	{
		PolyHead->next=list_create_node();
		PolyHead->next->coeffNum=pSub->coeffNum;
		PolyHead->next->Power=pSub->Power;
		PolyHead=PolyHead->next;
		pSub=pSub->next;
	}
	
	while(pMin)
	{
		combined=0;
		PolyHead=pNode;
		while(PolyHead->next)
		{
			//合并同类项
			if(pMin->Power==PolyHead->Power)
			{
				PolyHead->coeffNum -=pMin->coeffNum;
				combined=1;
				break;
			}
			PolyHead=PolyHead->next;
		}
		if(combined==0)
		{
			PolyHead->next=list_create_node();
			PolyHead->next->coeffNum=pMin->coeffNum;
			PolyHead->next->Power=pMin->Power;
		}
		pMin=pMin->next;
	}
	
	PolyHead=pNode;
	
	return PolyHead;
}

/*用于多项式相乘后的多项式合并*/
void *comine_polyno(Polynomial_t *poly)
{
	Polynomial_t *pnext=NULL, *tmp=NULL;
	Polynomial_t *pNode=poly;
	
	while(pNode->next)
	{
		pnext=pNode->next;
		while(pnext)
		{
			if(pnext->Power==pNode->Power)
			{
				pNode->coeffNum += pnext->coeffNum;
				tmp=pnext->next;
				pnext->next=pnext->next->next;
				free(pnext);
				pnext=tmp;
				pNode->next=tmp;
				continue;
			}
			pnext=pnext->next;
		}
		pNode=pNode->next;
	}
}

/*多项式相乘*/
Polynomial_t *polyno_multiplicate(Polynomial_t *P1, Polynomial_t *P2)
{
	if(!P1 || !P2)
	{
		printf("Invalid List head.\n");
		return NULL;
	}

	Polynomial_t *p1=P1, *p2=P2;
	Polynomial_t *Pnew=list_create_node();
	Pnew->coeffNum=p1->coeffNum*p2->coeffNum;
	Pnew->Power=p1->Power+p2->Power;
	p2=p2->next;
	Polynomial_t *pNode=Pnew;
	
	while(p1)
	{
		while(p2)
		{
			Pnew->next=list_create_node();
			Pnew->next->coeffNum=p1->coeffNum*p2->coeffNum;
			Pnew->next->Power=p1->Power+p2->Power;
			Pnew=Pnew->next;
			p2=p2->next;
		}
		p2=P2;
		p1=p1->next;
	}
	
	Pnew=pNode;
	comine_polyno(Pnew);
	return Pnew;
}

//接口测试
int main(void)
{
	int PCoeff1[]	={1,2,3,4};
	int Power1[]	={1,3,5,6};
	int PCoeff2[]	={6,7,8,9};
	int Power2[]	={2,3,4,5};
	
	Polynomial_t *P1=list_create_node();
	Polynomial_t *P2=list_create_node();

	poly_init(P1, PCoeff1, Power1, sizeof(PCoeff1)/sizeof(int));
	poly_init(P2, PCoeff2, Power2, sizeof(PCoeff2)/sizeof(int));

	Polynomial_t *PolyAdd = polyno_add(P1, P2);
	Polynomial_t *PolySub = polyno_sub(P1, P2);
	Polynomial_t *PolyMulti = polyno_multiplicate(P1, P2);
	
	print_list(PolyAdd);
	print_list(PolySub);
	print_list(PolyMulti);

	list_free(PolyAdd);
	list_free(PolySub);
	list_free(PolyMulti);
	list_free(P1);
	list_free(P2);
	
	return 0;
}