02-线性结构2 一元多项式的乘法与加法运算

02-线性结构2 一元多项式的乘法与加法运算 (20分)

设计函数分别求两个一元多项式的乘积与和。

输入格式:

输入分2行，每行分别先给出多项式非零项的个数，再以指数递降方式输入一个多项式非零项系数和指数（绝对值均为不超过1000的整数）。数字间以空格分隔。

输出格式:

输出分2行，分别以指数递降方式输出乘积多项式以及和多项式非零项的系数和指数。数字间以空格分隔，但结尾不能有多余空格。零多项式应输出0 0。

输入样例:

4 3 4 -5 2 6 1 -2 0
3 5 20 -7 4 3 1

输出样例:

15 24 -25 22 30 21 -10 20 -21 8 35 6 -33 5 14 4 -15 3 18 2 -6 1
5 20 -4 4 -5 2 9 1 -2 0

分析

本题要求计算指数递降多项式的相加和相乘，分步完成需要读入、相加、相乘、输出这4步，由于反复需要用到向一个链表添加新结点的操作，所以需要一个Attach函数，其中较难写的是相乘，我们可以把相乘这样看：

1. 用前面多项式的第一项乘以后面多项式的每一项，得到一个新的多项式；
2. 用前面多项式的第二项乘以后面多项式的每一项等到一个新的多项式后，与第1步得出的多项式相加，相加后得到新的多项式；
3. 重复上面操作，每次得出一个多项式后进行累加

代码

#include<stdio.h>
#include<stdlib.h>
typedef struct Node *Ptr;
typedef int ElementType;
struct Node{
	ElementType coef;//系数 
	ElementType expon;//指数 
	struct Node *link;
};
//需要5个函数完成各项功能
Ptr Read();
Ptr Sum(Ptr p1,Ptr p2);
Ptr Multiply(Ptr p1,Ptr p2);
void Print(Ptr p);
void Attach(int c,int e,Ptr *p);

int main()
{
	Ptr p1,p2,p3;
	
	p1=Read();
	p2=Read();
	//Print(p1);
	//Print(p2);
	
	p3=Multiply(p1,p2);
	Print(p3);
	
	p3=Sum(p1,p2);
	Print(p3);
	
	return 0;	
}

//Attach函数向链表中添加新结点，并将指针指向当前最后一个结点
void Attach(int c,int e,Ptr *p)
{
	Ptr temp;
	temp=(Ptr)malloc(sizeof(struct Node));
	temp->expon=e;
	temp->coef=c;
    temp->link=NULL;
                
	(*p)->link=temp;
	(*p)=temp;
	//(*p)=(*p)->link;
}

//Read读入输入数据，存入链表后返回头结点地址
Ptr Read()
{
	int n,c,e;
	Ptr p,p1,temp;
	p1=(Ptr)malloc(sizeof(struct Node));
    p1->link=NULL;
	p=p1;
	scanf("%d",&n);
	while(n--)
	{
		scanf("%d %d",&c,&e);
		Attach(c,e,&p1);
	}
	return p;
}

//Print输出链表中的数据
void Print(Ptr p)
{
	
	if(p->link==NULL)
	{
		printf("0 0\n");
		return;
	}
	p=p->link;
	int flag=0;
	while(p)
	{
	// 这两句选择语句是为了输出空格的需要——结尾不输出空格
	// 实际操作是按空格、一对数字、空格、一对数字的形式输出，第一对数字前不输出空格，这样就避免了结尾空格的输出
		if(!flag)
		flag=1;
		else
		printf(" ");
		
		printf("%d %d",p->coef,p->expon);
		p=p->link;	
	}
	printf("\n");
}

//Sum实现两个多项式的相加
Ptr Sum(Ptr p1,Ptr p2)
{
	Ptr pp1=p1->link,pp2=p2->link;
	Ptr p3,pp3,temp;
	pp3=(Ptr)malloc(sizeof(struct Node));
    pp3->link=NULL;
	p3=pp3;
	while(pp1&&pp2)
	{
		if(pp1->expon>pp2->expon)
		{

			Attach(pp1->coef,pp1->expon,&pp3);
			pp1=pp1->link;
		}
		else if(pp1->expon<pp2->expon)
		{
			Attach(pp2->coef,pp2->expon,&pp3);
			pp2=pp2->link;
		}
		else if(pp1->expon==pp2->expon)
		{
			int a=pp1->coef+pp2->coef;
			if(a==0) ;
			else{
				Attach(a,pp1->expon,&pp3);
			}
			
			pp1=pp1->link;
			pp2=pp2->link;
		}
		
	}
	for(;pp1;pp1=pp1->link) 
	{
		Attach(pp1->coef,pp1->expon,&pp3);
	}
	for(;pp2;pp2=pp2->link)
	{
		Attach(pp2->coef,pp2->expon,&pp3);
	} 
	pp3->link=NULL; 
	return p3;
}

//Multiply实现两个多项式相乘
Ptr Multiply(Ptr p1,Ptr p2)
{
	Ptr pp1=p1->link,pp2=p2->link;
	Ptr pp3,L,Lm;
	L = (Ptr)malloc(sizeof(struct Node));
	L->link=NULL;
	if(pp1&&pp2){
		for(pp1=p1->link;pp1;pp1=pp1->link){
			Lm = (Ptr)malloc(sizeof(struct Node));
			Lm->link = NULL;
			pp3 = Lm;
			for(pp2=p2->link;pp2;pp2=pp2->link){
				int c=pp1->coef*pp2->coef;
				int e=pp1->expon+pp2->expon;
				Attach(c,e,&pp3);
			}
			L=Sum(L,Lm);
			free(Lm);
		}
	}
	return L;
}