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

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

输入格式:

输入分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>
#include <math.h>

typedef struct Node* PtrToNode;
struct Node{
    int coef;
    int expon;
    PtrToNode next;
};

typedef PtrToNode List;

List Read(void);/*创建并读入多项式的各项系数与指数，且返回多项式链表的首地址*/
List Add(List L1, List L2);/*将两个多项式进行相加后存储在结果多项式中，且返回结果多项式链表的首地址*/
List Multiple(List L1, List L2);/*将两个多项式进行相乘后存储在结果多项式中，且返回结果多项式链表的首地址*/
void Attach(int c, int e, List* r);/*创建一个结点存入某项的系数和指数且插在以r作为首地址的节点后*/
int Compare(int e1, int e2);
void Print(List L);

int main()
{
    List L1, L2, LX, LS;
    L1 = NULL; L2 = NULL; LX = NULL; LS = NULL;
    L1 = Read();
    L2 = Read();
    LS = Add(L1, L2);
    LX = Multiple(L1, L2);
    Print(LX);
    printf("\n");
    Print(LS);
    return 0;
}

//创建并读入多项式的各项系数与指数，且返回多项式链表的首地址
List Read(void)
{
    List L, r, t;
    int c, e, n;//n记录结果多项式的项数

    L = (List)malloc(sizeof(struct Node));
    r = L;//r作为一个中间变量，存储最后结点的首地址
    scanf("%d", &n);
    while(n--){
        QQ: ;
        scanf(" %d %d", &c, &e);
        if(fabs(c) > 1000 || fabs(e) > 1000){
            printf("输入有误！\n请重新输入上一项的系数和指数\n");
            goto QQ;
        }
        Attach(c, e, &r);
    }
    t = L; L = L->next; free(t);//删除临时生成的头结点
    return L;
}

//将两个多项式进行相加后存储在结果多项式中，且返回结果多项式链表的首地址
List Add(List L1, List L2)
{
    List L, p1, p2, r, temp;//r记录结果多项式的最后一项结点的首地址
    int sum = 1;

    p1 = L1, p2 = L2;
    L = (List)malloc(sizeof(struct Node));
    r = L;

    /*分别比较结果多项式每一项的指数，将指数大的拷贝到结果多项式中，指数相等且系数和不为0，
      拷贝系数和与任意一项的指数，直到某一个多项式全部比较完，再将没比较完的多项式拷贝到结果多项式中，
      如同时比较完，则在末尾加NULL。
    */
    while(p1 && p2){
        if(Compare(p1->expon, p2->expon) == 1){
            Attach(p1->coef, p1->expon, &r);
            p1 = p1->next;
        }else if(Compare(p1->expon, p2->expon) == -1){
            Attach(p2->coef, p2->expon, &r);
            p2 = p2->next;
        }else{
            sum = p1->coef + p2->coef;
            if(sum) Attach(sum, p2->expon, &r);
            p1 = p1->next;
            p2 = p2->next;
        }
    }
    for(; p1; p1 = p1->next){
        Attach(p1->coef, p1->expon, &r);
    }
    for(; p2; p2 = p2->next){
        Attach(p2->coef, p2->expon, &r);
    }
    temp = L; L = L->next; free(temp);
    return L;
}

//将两个多项式进行相乘后存储在结果多项式中，且返回结果多项式链表的首地址
List Multiple(List L1, List L2)
{
    List L, p1, p2, r, temp, pre;
    int c, e;

    /*先用第一个多项式的第一项与第二个多项式的每一项相乘，得到一组有序多项式E，
      然后用两个循环将第一个多项式剩下的项分别与第二个多项式的每一项相乘，乘一个就
      插到有序多项式E中。
    */

    L = (List)malloc(sizeof(struct Node));
    p1 = L1; p2 = L2; r = L;
    if(!p1 || !p2){
        return NULL;
    }else{
        while(p2){
            Attach(p1->coef * p2->coef, p1->expon + p2->expon, &r);
            p2 = p2->next;
        }

        p1 = p1->next;
        while(p1){
            p2 = L2; r = L;
            while(p2){
                c = p1->coef * p2->coef;
                e = p1->expon + p2->expon;

                while(r->next && r->next->expon > e){//要找到某项的指数刚好大于相乘过后该项的指数
                    r = r->next;                     //在P2循环中后面插入的位置肯定在前面插入位置的后面，所以在此循环中r不需要赋值为L
                }

                if(r->next && r->next->expon == e){//指数相等
                    if(r->next->coef + c){
                        r->next->coef = r->next->coef + c;
                    }else{
                        temp = r->next;
                        r->next = temp->next;
                        free(temp);
                    }
                }else{//指数小于
                    pre = (List)malloc(sizeof(struct Node));
                    pre->coef = c; pre->expon = e;
                    pre->next = r->next;
                    r->next = pre;
                }
                p2 = p2->next;
            }
            p1 = p1->next;
        }
    }
    temp = L; L = L->next; free(temp);
    return L;
}



void Attach(int c, int e, List* r)
{
    List pre = (List)malloc(sizeof(struct Node));
    pre->coef = c;
    pre->expon = e;
    pre->next = NULL;
    (*r)->next = pre;
    *r = pre;
}

int Compare(int e1, int e2)
{
    if(e1 > e2){
        return 1;
    }else if(e1 < e2){
        return -1;
    }else{
        return 0;
    }
}


void Print(List L)
{
    List p = L;
    int flag = 0;

    if(!p) printf("0 0\n");
    while(p){
        if(!flag){
            printf("%d %d", p->coef, p->expon);
            flag = 1;
        }else{
            printf(" %d %d", p->coef, p->expon);
        }
        p = p->next;
    }
}