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

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

输入:

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 <iostream>
using namespace std;


typedef struct node
{
int coef;
int expon;
struct node * Next;
}PolyNode, *Polynomial;

void Attach(int c,int e,PolyNode** rear_) /如果是*rear 会导致p=rear，p跟着rear跑，所以最好的办法是让一个指针来指向rear，
//从而使得改变rear不影响p,从而达到解耦合的目的
{
PolyNode* P0;
P0=(PolyNode*)malloc(sizeof(node));
P0->coef=c;
P0->expon=e;
P0->Next=0;
(*rear_)->Next=P0; //初始化时 rear=p 不好理解，一旦形成一个链，就很好理解了 rear 是一个链表，p0是另一个链表
(*rear_)=P0;
}


PolyNode* read()
{
PolyNode* P,*rear;
int N,c,e;
P=(PolyNode*)malloc(sizeof(node));
P->Next=0;
rear=P;   //拷贝指针
cin>>N;

while(N)
{
cin>>c>>e;
Attach(c,e,&rear);
N--;
}
PolyNode* temp; //目的是删除开头的那个空结点
temp=P;
P=P->Next;
free(temp);
return P;
// cout<<P->coef<<endl;
}


 PolyNode* add(PolyNode* p1,PolyNode* p2)
{
PolyNode* rear,*front,*temp;
int sum(0);
// p1=read();
// p2=read();
front=(PolyNode*)malloc(sizeof(PolyNode));
rear=front;
front->Next=0;
// while(p)
// {
//  cout<<p->coef<<endl;
//  cout<<p->expon<<endl;
//  p=p->Next;
// }
while(p1 && p2)
{

 if(p1->expon < p2->expon)
{
Attach(p2->coef,p2->expon,&rear);
p2=p2->Next;
// cout<<"<"<<endl;
}
else if(p1->expon > p2->expon)
{
Attach(p1->coef,p1->expon,&rear);
p1=p1->Next;
// cout<<">"<<endl;


}
else if(p1->expon == p2->expon)
{
sum=p1->coef+p2->coef;
if(sum)
{
Attach(sum,p1->expon,&rear);
p1=p1->Next;
p2=p2->Next;
// cout<<sum<<endl;
}
else
{
p1=p1->Next;
p2=p2->Next;
}
}

}
for(;p1;p1=p1->Next) Attach(p1->coef,p1->expon,&rear); //p1不空，P2空
for(;p2;p2=p2->Next) Attach(p2->coef,p2->expon,&rear); //p2不空，P1空
rear->Next=NULL;
temp=front;
front=front->Next;
free(temp);
return front;
}


PolyNode* read2()
{
PolyNode* rear,*p1,*p2,*temp;
int N,c,e;
p1=(PolyNode*)malloc(sizeof(PolyNode));
rear=p1;
p1->Next=0;
cin>>N;
while(N)
{
cin>>c>>e;
PolyNode* P0;
P0=(PolyNode*)malloc(sizeof(PolyNode));
P0->coef=c;
P0->expon=e;
P0->Next=0;
rear->Next=P0;
rear=P0;
N--;
}
// front_=add();
temp=p1;
p1=p1->Next;
free(temp);
return p1;
}
int main()
{
PolyNode* front,*front1,*front2,*front3,*rear,*rear1,*rear2,*rear3,*p1,*p2,*temp1,*temp2,*temp3;
PolyNode* front_;
PolyNode* front__;
front=(PolyNode*)malloc(sizeof(PolyNode));
rear=front;
p1=read2();
p2=read2();
// front1=front;
temp1=p1; //之所以采用临时变量是因为指针只能单向的执行一个轮回，不会反过来再访问
temp2=p2;
while(temp2) //先得到一个初始的链表，好在以后操作
{
PolyNode* multiply;
multiply=(PolyNode*)malloc(sizeof(PolyNode));
multiply->coef=temp1->coef * temp2->coef;
multiply->expon=temp1->expon + temp2->expon;
multiply->Next=0;
rear->Next=multiply;
rear=multiply;
temp2=temp2->Next;


// cout<<"p2"<<endl;

}
temp1=temp1->Next;
// cout<<"p1"<<endl;
PolyNode* temp;
temp=front;
front=front->Next;
free(temp);

while(temp1)

{
front2=(PolyNode*)malloc(sizeof(PolyNode)); //再创建一个链表，用p1的第二项去乘以p2的所有的项，好方便后面的加运算
rear2=front2;
temp3=p2; //再次求解。 此时temp1 指向了下一个
while(temp3)
{
PolyNode* multiply;
multiply=(PolyNode*)malloc(sizeof(PolyNode));
multiply->coef=temp1->coef * temp3->coef;
multiply->expon=temp1->expon + temp3->expon;
multiply->Next=0;
rear2->Next=multiply;
rear2=multiply;
temp3=temp3->Next;


// cout<<"p2"<<endl;

}
temp1=temp1->Next;
// cout<<"p1"<<endl;
// PolyNode* temp;
temp=front2;
front2=front2->Next;
free(temp);


front=add(front,front2);
}
while(front)
{
cout<<front->coef<<" ";
cout<<front->expon<<" ";
front=front->Next;
}
cout<<endl;
// PolyNode* front__;
front__=add(p1,p2);
while(front__)
{
cout<<front__->coef<<" ";
cout<<front__->expon<<" ";
front__=front__->Next;
}

}