PTA||DSA 一元多项式的乘法和加法运算

一元多项式的乘法与加法运算

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

输入格式：

输入分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

参考代码：

#include<stdio.h>
#include<stdlib.h>
typedef struct{
	int coef;
	int expn;
}term, ElemType;
typedef struct LNode{
	ElemType data;
	struct LNode *next;
}LNode, *LinkList;

typedef LinkList polynomial;
//建立空多项式 
polynomial CreatPolyn();
//对多项式进行赋值 
polynomial inputPolyn(polynomial A);
//将多项式A与多项式B相加，返回值即为相加之和的多项式 
polynomial AddPolyn(polynomial A, polynomial B);
//打印多项式 
void displayPolyn(polynomial A);
// 将多项式A与多项式B相乘，返回值即为相乘之积的多项式 
polynomial MultiplyPolyn(polynomial A, polynomial B);
//释放多项式A所占空间 
void freePolyn(polynomial A);
int main(){
	//A，B为输入的多项式，C为相乘所得结果 
	polynomial A, B, C, D;
	int n;
	//建立多项式A 
	A = CreatPolyn();
//	printf("建立多项式A：\n");
	//输入多项式A的数据元素 
	A = inputPolyn(A);
//	displayPolyn(A);
//	printf("\n");
	//建立多项式B 
	B = CreatPolyn();
//	printf("建立多项式B：\n");
	//输入多项式B的数据元素 
	B = inputPolyn(B);
//	displayPolyn(B);
//	printf("\n");
	//将多项式A与多项式B相乘的结果存入C中 
	C = MultiplyPolyn(A, B);
//	printf("%d\n", GetLength(C));
	D = AddPolyn(A, B);
	//打印多项式C 
	displayPolyn(C);
	printf("\n");
	displayPolyn(D);
	return 0;
}
polynomial CreatPolyn(){
	polynomial h;
	h = (polynomial)malloc(sizeof(LNode));
	h->next = NULL;
	return h;
}
polynomial inputPolyn(polynomial A){
	int n, i;
	LNode *pa = A;
	scanf("%d", &n);
	if(n == 0) return A;
	for(i = 0; i < n; i++){
		LNode *set;
		set = (polynomial)malloc(sizeof(LNode));
		scanf("%d %d", &(set->data.coef), &(set->data.expn));
		set->next = NULL;
		pa->next = set;
		pa = pa->next;
	}
	return A;
}
void displayPolyn(polynomial A){
	if(A->next == NULL) {
		printf("0 0");
		return;
	}
	LNode *pa = A->next;
	while(pa->next != NULL){
		printf("%d %d ", pa->data.coef, pa->data.expn);
		pa = pa->next;
	}
	printf("%d %d", pa->data.coef, pa->data.expn);
	
}
polynomial MultiplyPolyn(polynomial A, polynomial B){
	//异常处理 
	if(A->next == NULL || B->next == NULL){
		polynomial A = CreatPolyn();
		return A;
	}
	LNode *pa = A->next, *pb, *p;
	polynomial C;
	C = CreatPolyn();

	//先将多项式A的第i个元素（i=1，2，3...n）
	//与多项式B中的各个元素相乘后再相加得到第i个多项式 
	while(pa != NULL){
		pb = B->next;
		polynomial temp;
		temp = CreatPolyn();//表示第i个多项式 
		LNode *pt = temp;//pt为temp的头指针 
		while(pb != NULL){
			LNode *set;//保存当前pa与pb所指数据元素相乘所得结果 
			set = (polynomial)malloc(sizeof(LNode));
			set->data.coef = pa->data.coef * pb->data.coef;
			set->data.expn = pa->data.expn + pb->data.expn;
			set->next = NULL;
			pt->next = set;//将set插入多项式temp中 
			pt = pt->next;
			pb = pb->next;
		}
//		printf("\n");
//		displayPolyn(temp);
//		printf("\n");
		C = AddPolyn(C, temp);
//		displayPolyn(C);
//		printf("\n");
		pa = pa->next;
	//	freePolyn(temp);
	}
	return C;
}
polynomial AddPolyn(polynomial A, polynomial B){
	//简化处理 
	if(B->next == NULL)return A;
	if(A->next == NULL)return B;
	LNode *pa = A->next, *pb = B->next, *pc;
	polynomial C;
	C = CreatPolyn();
	pc = C;
	while(pa != NULL && pb != NULL){
		LNode *temp;
		temp = (polynomial)malloc(sizeof(LNode));
		if(pb->data.expn > pa->data.expn){
			temp->data.expn = pb->data.expn;
			temp->data.coef = pb->data.coef;
			pc->next = temp;
			pc = pc->next;
			pc->next = NULL;
			pb = pb->next;
		}else if(pb->data.expn < pa->data.expn){
			temp->data.expn = pa->data.expn;
			temp->data.coef = pa->data.coef;
			pc->next = temp;
			pc = pc->next;
			pc->next = NULL;
			pa = pa->next;
		}else{
			temp->data.coef = pa->data.coef + pb->data.coef;
			if(temp->data.coef != 0){
				temp->data.expn = pa->data.expn;
				pc->next = temp;
				pc = pc->next;
				pc->next = NULL;
			}
			pa = pa->next;
			pb = pb->next;
		}
	}
	if(pa == NULL && pb != NULL){
		while(pb){
			LNode *temp;
			temp = (polynomial)malloc(sizeof(LNode));
			temp->data.expn = pb->data.expn;
			temp->data.coef = pb->data.coef;
			pc->next = temp;
			pc = pc->next;
			pc->next = NULL;
			pb = pb->next;
		}
	}else if(pa != NULL && pb == NULL){
		while(pa){
			LNode *temp;
			temp = (polynomial)malloc(sizeof(LNode));
			temp->data.expn = pa->data.expn;
			temp->data.coef = pa->data.coef;
			pc->next = temp;
			pc = pc->next;
			pc->next = NULL;
			pa = pa->next;
		}
	}
	return C;
}
void freePolyn(polynomial A){
	if(A == NULL) {
		printf("The polynomial is empty.\n");
		exit(0);
	}
	LNode *pa = A->next;
	while(pa->next != NULL){
		free(A);
		A = pa;
		pa = pa->next;
	}
	free(pa);
}

代码分析：

首先根据输入样例不难发现这是一元稀疏多项式，如果使用数组来保存则会浪费许多空间，因此考虑使用链表数据结构。再结合MOOC中提到的思路，即将多项式乘法转换为多项式加法，而多项式加法实现则容易实现。
下来看看4个测试点：

在第一次提交时，并没有AC，而在测试点1出现问题，后来发现自己并没有考虑当同类项合并系数为0的情况，即：
诸如** -100X²⁰⁰+ 100X²⁰⁰ = 0**这类情况。
因此通过判断系数和是否为0来产生新结点，问题得到解决。

结尾杂说：

之前发过一元多项式乘法和加法的代码，但只是提交实验，并没有经过OJ的测试，无法保证其正确性。恰好最近在通过浙大的数据结构MOOC复习，顺便在PTA里做些数据结构的编程题。