Polynomial multiplication and addition to realize

Polynomial representations can use the array can also use the list

• Array representation is simple, convenient debugging. But we need to determine in advance the size of the array.
• Up list represents the dynamic and strong, but the programming of complex, difficult to debug.

In order to improve the operation of the linked list, the program, described later, are used to complete the chain.

Note: The following list is not the head node

//多项式的加法和乘法
#define  _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>

struct PolyNode 
{
    int Coef;
    int Expon;
    struct PolyNode* Next;  //指向下一个节点
};

void Attach(int coef,int expon,struct PolyNode** PtrRear)
{
    struct PolyNode* p;
    p = (struct PolyNode*)malloc(sizeof(struct PolyNode));
    p->Coef = coef;
    p->Expon = expon;
    p->Next = NULL;
    (*PtrRear)->Next = p;
    (*PtrRear) = p;  //修改PtrRear的值
}

struct PolyNode* ReadPoly()
{
    int N;  //存储多项式的项数
    int c;  //多项式的系数
    int e;  //多项式的指数
    struct PolyNode* p;  //表头
    struct PolyNode* Rear;
    struct PolyNode* t;
    p = (struct PolyNode*)malloc(sizeof(struct PolyNode));
    p->Next = NULL;
    Rear = p;
    scanf("%d",&N);
    while (N--)
    {
        scanf("%d %d",&c,&e);
        Attach(c,e,&Rear);
    }
    t = p;
    p = p->Next;
    free(t);  //删除临时生成的头节点
    return p;
}
//作用：比较两个指数的大小
//返回值： e1 > e2 返回 1
//         e1 < e2 返回 -1
//         e1 = e2 返回 0
int Compare(int e1,int e2)
{
    if (e1 > e2)
    {
        return 1;
    }
    else if (e1 < e2)
    {
        return -1;
    }
    else
    {
        return 0;
    }
}

//将两个多项式相加
struct PolyNode* PolyAdd(struct PolyNode* P1, struct PolyNode* P2)
{
    struct PolyNode* rear;
    struct PolyNode* front;
    struct PolyNode* temp;
    int sum;

    //为方便表头插入，先产生一个临时空节点作为结果多项式链表头
    rear = (struct PolyNode*)malloc(sizeof(struct PolyNode));
    front = rear;

    while (P1 && P2)  //当两个多项式都有非零项待处理时
    {
        switch (Compare(P1->Expon, P2->Expon))
        {
        case 1:
            Attach(P1->Coef,P1->Expon,&rear);
            P1 = P1->Next;
            break;
        case -1:
            Attach(P2->Coef, P2->Expon, &rear);
            P2 = P2->Next;
            break;
        case 0:
            sum = P1->Coef + P2->Coef;
            if (sum)
            {
                Attach(sum,P1->Expon,&rear);
            }
            P1 = P1->Next;
            P2 = P2->Next;
            break;
        }
    }
    //将未处理完的另一个多项式的所有节点依次复制到结果多项式中去
    for (;P1;P1 = P1->Next)
    {
        Attach(P1->Coef,P1->Expon,&rear);
    }
    for (; P2; P2 = P2->Next)
    {
        Attach(P2->Coef, P2->Expon, &rear);
    }
    rear->Next = NULL;
    temp = front;
    front = front->Next; //令front指向结果多项式第一个非零项
    free(temp);
    return front;
}
//将两个多项式相乘
struct PolyNode* PolyMult(struct PolyNode* P1, struct PolyNode* P2)
{
    struct PolyNode* rear;
    struct PolyNode* P;
    struct PolyNode* t1 = P1;
    struct PolyNode* t2 = P2;
    struct PolyNode* t;
    int sumc;
    int sume;

    if (NULL == P1 || NULL == P2)
    {
        return NULL;
    }
    //产生一个临时空节点作为结果多项式链表头
    P = (struct PolyNode*)malloc(sizeof(struct PolyNode));
    rear = P;
    while (t2)
    {
        //先用P1的第一项乘以P2得到P
        Attach(t1->Coef * t2->Coef,t1->Expon + t2->Expon,&rear);
        t2 = t2->Next;
    }
    t1 = t1->Next;

    while (t1)
    {
        rear = P;
        t2 = P2;
        while (t2)
        {
            sumc = t1->Coef * t2->Coef;  //系数相乘
            sume = t1->Expon + t2->Expon;  //指数相加
            while (rear->Next && rear->Next->Expon > sume)
            {
                rear = rear->Next;
            }
            if (rear->Next && rear->Next->Expon == sume)
            {
                if (rear->Next->Coef + sumc)
                {
                    //rear->Next->Coef + sumc != 0
                    rear->Next->Coef = rear->Next->Coef + sumc;
                }
                else
                {
                    //rear->Next->Coef + sumc = 0
                    //删除一个节点
                    t = rear->Next;
                    rear->Next = t->Next;
                    free(t);
                }
            }
            else //rear->Next->Expon < sume
            {
                //向链表中插入新的节点
                t = (struct PolyNode*)malloc(sizeof(struct PolyNode));
                t->Coef = sumc;
                t->Expon = sume;
                t->Next = NULL;
                t->Next = rear->Next;
                rear->Next = t;

                rear = rear->Next;
            }
            t2 = t2->Next;
        }
        t1 = t1->Next;
    }
    t2 = P;
    P = P->Next;
    free(t2);
    return P;
}
//将多项式输出
void PrintPoly(struct PolyNode* P)
{
    int flag = 0;
    if (NULL == P)
    {
        printf("0 0\n");
        return 0;
    }
    while (P)
    {
        if (!flag)
        {
            flag = 1;
        }
        else
        {
            printf(" ");
        }
        printf("%d %d", P->Coef, P->Expon);
        P = P->Next;
    }
    printf("\n");
}

int main()
{
    struct PolyNode* P1;
    struct PolyNode* P2;
    struct PolyNode* PP;
    struct PolyNode* PS;

    P1 = ReadPoly();
    P2 = ReadPoly();
    PP = PolyAdd(P1, P2);
    printf("两多项式相加的结果为：\n");
    PrintPoly(PP);
    printf("两个多项式相乘的结果为:\n");
    PS = PolyMult(P1,P2);
    PrintPoly(PS);
    system("pause");
    return 0;
}

References:
1 "data structure" edited by Chen Yue
2 Mu class network "data structure" Chen Yue teacher, what Qinming speaker teachers