数据结构：一元多项式的乘法与加法运算

中国大学MOOC视屏讲解

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

输入格式:

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

以下是这道题的提示情况：

无法通过的情况，可能有：
1，没有考虑，有零多项式，其中包括(输入的时候，系数为0，指数不为0的这种情况)。
2，合并同项时出现抵消的这种情况。

对于1这种错误，比较好解决，下面我来说一下，2这种情况，当我们解决了 1这种情况呢。那么2这种情况就好解决多了，第一，我们不需要考虑，相乘时，会产生系数为0的这种情况，而则种情况，只会发生在，相加的时候。所以在这里我将告诉你们两种解决方案。

对于第一种：就是，每次相加的时候我们就处理，等于0的这种情况，对于 多项式加法运算 就是不添加这个节点，对于 多项式乘法运算 就是删除这个节点，这种方法我认为较为复杂。

那么第二种方法时怎么样的呢？就是这些情况我都不考虑，那我们怎么处理 等于0的这种情况呢，我们只需要在输出的时候加上一个条件，系数等于0，我们就不输出，不就可以了吗？

对于二这种情况可以试试输入如下数据进行测试:
2 2 2 -2 1
2 2 2 2 1

第一种方法如下：

#include<bits/stdc++.h>  //万能头文件，如果不是特别清楚可以百度。 
using namespace std;

typedef struct Node{
	int coef;//系数 
	int exp;//指数 
	struct Node *next;
} *List;

List read(List L);
void print(List L);
List getMuti(List L1,List L2);
List getSum(List L1,List L2);


List read(List L){
	List s=NULL,temp;
	L = (struct Node*)malloc(sizeof(struct Node));
	temp = L;
	int n,COEF,EXP;
	cin>>n;
	for(int i=0;i<n;i++){
		
		cin>>COEF>>EXP;
		//这一步的作用是，排除读入过程中出现 系数:0  指数:不为0  的这种情况。 
		if(COEF!=0){	
			s = (struct Node *)malloc(sizeof(struct Node));
			s->coef = COEF; s->exp=EXP;
			L->next = s;
			L = s;
		}	
	}
	L->next=NULL;
	return temp;
	
}


void print(List L){
	
	if(L->next!=NULL){
		L = L->next;	
		while(L){
			if(L->next)
			cout<<L->coef<<" "<<L->exp<<" ";
			else
			cout<<L->coef<<" "<<L->exp<<endl;
			L = L->next;
		}
	}
	else
	cout<<0<<" "<<0<<endl;
}


List getSum(List L1,List L2){
	
	List L,temp = NULL,s = NULL;
	L = (struct Node *)malloc(sizeof(struct Node));
	temp = L;
	
	while(L1->next&&L2->next){
		
		if(L1->next->exp>L2->next->exp){
			s = (struct Node *)malloc(sizeof(struct Node));
			s->coef = L1->next->coef;
			s->exp = L1->next->exp;
			L->next = s;
			L = s; 
			L1 = L1->next;
		}
		else if(L1->next->exp<L2->next->exp){
			s = (struct Node *)malloc(sizeof(struct Node));
			s->coef = L2->next->coef;
			s->exp = L2->next->exp;
			L->next = s;
			L = s; 
			L2 = L2->next;
		}
		else{ 
			if(L2->next->coef+L1->next->coef!=0){	
				s = (struct Node *)malloc(sizeof(struct Node));
				s->coef = L2->next->coef+L1->next->coef;
				s->exp = L2->next->exp;
				L->next = s;
				L = s; 
			}
			//不管，他们的和是不是 0，我们都要，将L1,L2后移一个单位。 
			L1 = L1->next;
			L2 = L2->next;
		}		
	}
	if(L1->next)
	L->next = L1->next;
	else
	L->next = L2->next;
	return temp;		
}


List getMuti(List L1,List L2){
	/*
	在这里我们采用的是：逐项插入。
	什么是逐项插入？
	1，先拿出L2的第一项，让它与L1的每一项相乘。从而得到 L。
	2，在拿出L2的第二项，让它与L1的每一项相乘，然后每乘一项，就将其插入到 L中。
	3，依次重复上面的步骤，最终得到L。将其打印出来。 
	*/ 
	List L,temp = NULL,s = NULL;
	L = (struct Node *)malloc(sizeof(struct Node));
	temp = L;
	List La = L1;
	
	//出L2的第一项，让它与L1的每一项相乘。从而得到 L。
	while(La->next){	
		s = (struct Node *)malloc(sizeof(struct Node));
		s->coef = La->next->coef * L2->next->coef;
		s->exp = La->next->exp + L2->next->exp;
		L->next=s;
		L = s;
		La = La->next;
	}
	
	L->next = NULL;
	L = temp;
	List Lb = L2->next;
	bool flag = true;
	/*
	在这里说明一下 flag 在这里的作用：
	用于标记，在下面的程序中，是否进行了，  if( > ) 和 if( == )里面的操作，
	若进行了，则flag就变为 false，则不用进行， while(.....){.....},结束后的第一条语句，
	这条语句的含义是，在L中没有找到，这个 待插入项 的位置，所以将其置于l的尾部。 
	*/
	while(Lb&&Lb->next){
		La = L1;		
		while(La->next){
			s = (struct Node *)malloc(sizeof(struct Node));
			s->coef = La->next->coef * Lb->next->coef;
			s->exp = La->next->exp + Lb->next->exp;
			while(L->next){
				
				if(s->exp > L->next->exp){		
					
					List val = L->next;
					L->next = s;
					s->next = val;
					flag = false;
					break;			
				}
				else if(s->exp == L->next->exp)
				{
					if(s->coef + L->next->coef==0){
						List val = L->next->next;
						L->next = val;	
					}
					else
					L->next->coef += s->coef;
					flag = false;
					break;
				}
				L = L->next;
			}
			
			if(flag){
				L->next = s;
				s->next = NULL;
			}
			L = temp;
			La = La->next;
			flag  = true;
		}		
		Lb = Lb->next;
	}
	return temp;
	
}

int main(){
	List L1,L2,L=NULL;
	L1 = read(L1);
	L2 = read(L2);
	L = getMuti(L1,L2);
	print(L);
	L = getSum(L1,L2);
	print(L);
	return 0;
}

第二种方法：

#include<bits/stdc++.h>  //万能头文件，如果不是特别清楚可以百度。 
using namespace std;

typedef struct Node{
	int coef;//系数 
	int exp;//指数 
	struct Node *next;
} *List;

List read(List L);
void print(List L);
List getMuti(List L1,List L2);
List getSum(List L1,List L2);


List read(List L){
	List s=NULL,temp;
	L = (struct Node*)malloc(sizeof(struct Node));
	temp = L;
	int n,COEF,EXP;
	cin>>n;
	for(int i=0;i<n;i++){
		
		cin>>COEF>>EXP;
		//这一步的作用是，排除读入过程中出现 系数:0  指数:不为0  的这种情况。 
		if(COEF!=0){	
			s = (struct Node *)malloc(sizeof(struct Node));
			s->coef = COEF; s->exp=EXP;
			L->next = s;
			L = s;
		}	
	}
	L->next=NULL;
	return temp;
	
}


void print(List L){
	int num = 0,temp=0;  //temp用于统计 L里面有多少个元素。 num 用于统计有多少个系数为0的数。 
	List val = L;
	while(val->next){
		val = val->next;
		temp++;
	}
	if(L->next!=NULL){
		while(L->next){
			if(L->next->coef!=0){
				cout<<L->next->coef<<" "<<L->next->exp;
				List val = L->next;
				while(val->next&&val->next->coef==0){
					val = val->next;
				} 
				if(val->next==NULL)
				cout<<endl;
				else
				cout<<" ";
			}
			else
			num++;
			L = L->next;
		}
		if(num==temp)
		cout<<0<<" "<<0<<endl;
	}
	else
	cout<<0<<" "<<0<<endl;
}


List getSum(List L1,List L2){
	
	List L,temp = NULL,s = NULL;
	L = (struct Node *)malloc(sizeof(struct Node));
	temp = L;
	
	while(L1->next&&L2->next){
		
		if(L1->next->exp>L2->next->exp){
			s = (struct Node *)malloc(sizeof(struct Node));
			s->coef = L1->next->coef;
			s->exp = L1->next->exp;
			L->next = s;
			L = s; 
			L1 = L1->next;
		}
		else if(L1->next->exp<L2->next->exp){
			s = (struct Node *)malloc(sizeof(struct Node));
			s->coef = L2->next->coef;
			s->exp = L2->next->exp;
			L->next = s;
			L = s; 
			L2 = L2->next;
		}
		else{ 
			s = (struct Node *)malloc(sizeof(struct Node));
			s->coef = L2->next->coef+L1->next->coef;
			s->exp = L2->next->exp;
			L->next = s;
			L = s; 
			//不管，他们的和是不是 0，我们都要，将L1,L2后移一个单位。 
			L1 = L1->next;
			L2 = L2->next;
		}		
	}
	if(L1->next)
	L->next = L1->next;
	else
	L->next = L2->next;
	return temp;		
}


List getMuti(List L1,List L2){
	/*
	在这里我们采用的是：逐项插入。
	什么是逐项插入？
	1，先拿出L2的第一项，让它与L1的每一项相乘。从而得到 L。
	2，在拿出L2的第二项，让它与L1的每一项相乘，然后每乘一项，就将其插入到 L中。
	3，依次重复上面的步骤，最终得到L。将其打印出来。 
	*/ 
	List L,temp = NULL,s = NULL;
	L = (struct Node *)malloc(sizeof(struct Node));
	temp = L;
	List La = L1;
	
	//出L2的第一项，让它与L1的每一项相乘。从而得到 L。
	while(La->next){	
		s = (struct Node *)malloc(sizeof(struct Node));
		s->coef = La->next->coef * L2->next->coef;
		s->exp = La->next->exp + L2->next->exp;
		L->next=s;
		L = s;
		La = La->next;
	}	
	L->next = NULL;
	L = temp;
	List Lb = L2->next;	
	while(Lb&&Lb->next){
		La = L1;		
		while(La->next){
			s = (struct Node *)malloc(sizeof(struct Node));
			s->coef = La->next->coef * Lb->next->coef;
			s->exp = La->next->exp + Lb->next->exp;
			while(L->next){		
				if(s->exp > L->next->exp){		
									
					List val = L->next;
					L->next = s;
					s->next = val;
					break;			
				}
				else if(s->exp == L->next->exp)
				{
					L->next->coef += s->coef;
					break;
				}
				L = L->next;
			}
			
			if(L->next==NULL){
				L->next = s;
				s->next = NULL;
			}
			L = temp;
			La = La->next;
		}		
		Lb = Lb->next;
	}
	return temp;	
}

int main(){
	List L1,L2,L=NULL;
	L1 = read(L1);
	L2 = read(L2);
	L = getMuti(L1,L2);
	print(L);
	L = getSum(L1,L2);
	print(L);
	return 0;
}