数据结构之利用单向链表实现多项式加法和乘法

　　在《数据结构与算法分析--c语言描述》一书中，作者指出了使用单向链表作为实现多项式的方法。但是没有给出具体实现。下面自己对其进行实现。只考虑功能。对其他细节不暂时不考虑。程序完成两个功能，使用单向链表完成多项式的加法和乘法。首先看加法，解决加法问题的思想在于对表示进行操作的两个链表表示的多项式按照指数递减的结构排列，每个节点的数据域存储着多项式某一项的系数（Coefficient）和指数（Exponent），还有一个指向后继节点的指针。节点的实现如下：

typedef struct Node* PtrToNode;
struct Node
{
    int Coefficient;
    int Exponent;
    PtrToNode Next;
};

为多项式定义以下操作：

#ifndef POLY_H_
#define POLY_H_

typedef struct Node* PtrToNode;
typedef PtrToNode Polynomial;

Polynomial CreatePoly();
void Insert(int Coe,int Exp,Polynomial P);
Polynomial AddPoly(Polynomial P1,Polynomial P2);
Polynomial MultiPoly(Polynomial P1,Polynomial P2);
void PrintPoly(Polynomial P);

#endif

下面是每个函数的实现：

#include<stdlib.h>
#include<stdio.h>
typedef struct Node* PtrToNode;
struct Node
{
    int Coefficient;
    int Exponent;
    PtrToNode Next;
};

typedef PtrToNode Polynomial;


Polynomial CreatePoly()
{
    Polynomial P = malloc(sizeof(struct Node));
    P->Next = NULL;
    return P;
}

void Insert(int Coe,int Exp,Polynomial P)
{
    PtrToNode  Temp = malloc(sizeof(struct Node));
    Temp->Coefficient = Coe;
    Temp->Exponent = Exp;
    PtrToNode Pt = P;
    
    while(Pt->Next != NULL && Exp < Pt->Next->Exponent)
    {
        Pt= Pt->Next;
    }
    Temp->Next = Pt->Next;
    Pt->Next = Temp;
}

void PrintPoly(Polynomial P)
{
    PtrToNode Pt = P->Next;
    while(Pt!= NULL)
    {
        printf("Coe: %d,Exp: %d   ",Pt->Coefficient,Pt->Exponent);
        Pt = Pt->Next;
    }
}

Polynomial AddPoly(Polynomial P1,Polynomial P2)
{
    Polynomial Pt1,Pt2,PA,Pt;
    Pt1 = P1->Next;
    Pt2 = P2->Next;
    PA = CreatePoly();
    Pt = PA;
    while(Pt2 != NULL && Pt1 != NULL)
    {
        Polynomial Tmp = malloc(sizeof(struct Node));
        Tmp->Next = NULL;
        if(Pt1->Exponent > Pt2->Exponent)
        {
            Tmp->Coefficient = Pt1->Coefficient;
            Tmp->Exponent = Pt1->Exponent;
            Pt1 = Pt1->Next;
        }
        else if(Pt1->Exponent < Pt2->Exponent)
        {
            Tmp->Coefficient = Pt2->Coefficient;
            Tmp->Exponent = Pt2->Exponent;
            Pt2 = Pt2->Next;
        }
        else
        {
            Tmp->Coefficient = Pt1->Coefficient + Pt2->Coefficient;
            Tmp->Exponent = Pt2->Exponent;
            Pt1  = Pt1->Next;
            Pt2  = Pt2->Next;
        }
        Pt->Next = Tmp;
        Pt = Pt->Next;
    }
    
    if(Pt1 == NULL)
    {
        while(Pt2 != NULL)
        {
            Polynomial Tmp = malloc(sizeof(struct Node));
            Tmp->Coefficient = Pt2->Coefficient;
            Tmp->Exponent = Pt2->Exponent;
            Pt->Next = Tmp;
            Pt = Pt->Next;
            Pt->Next = NULL;
            Pt2 = Pt2->Next;
        }
    }
    
    if(Pt2 == NULL)
    {
        while(Pt1 != NULL)
        {
            Polynomial Tmp = malloc(sizeof(struct Node));
            Tmp->Coefficient = Pt1->Coefficient;
            Tmp->Exponent = Pt1->Exponent;
            Pt->Next = Tmp;
            Pt = Pt->Next;
            Pt->Next = NULL;
            Pt1 = Pt1->Next;
        }
    }
    
    return PA;
}


Polynomial MultiPoly(Polynomial P1,Polynomial P2)
{
    Polynomial Pt1,P;
    P = CreatePoly();
    Pt1 = P1->Next;
    while(Pt1 != NULL)
    {
        Polynomial  TmpList = CreatePoly();
        Polynomial  Tp = TmpList;
        Polynomial Pt2 = P2->Next;
        while(Pt2 != NULL)
        {
            Polynomial TmNode = malloc(sizeof(struct Node));
            TmNode->Exponent = (Pt1->Exponent) + (Pt2->Exponent);
            TmNode->Coefficient = (Pt1->Coefficient) * (Pt2->Coefficient);
            Tp->Next = TmNode;
            Tp = Tp->Next;
            Tp->Next = NULL;
            Pt2 = Pt2->Next;
        }
        
        P = AddPoly(P,TmpList);
        
        Pt1=Pt1->Next;
    }
    return P;
}

其中加法函数的计算思想是：用两个移动指针分别指向两个链表的第一个数据节点，比较两个节点中指数的大小，如果某个节点大，则将该节点复制出来，加入结果链表，如果相等，则对系数进行相加，指数不变进行复制，加入结果链表，如果某个链表先扫描完，将另一个没有扫描结束的链表复制到结果链表的后面。使用流程图表示：

以上即为加法运算的流程图。

乘法运算的流程是：使用嵌套的while循环，使链表1的每个节点都和链表2的每个节点相乘，指数相加，系数相乘，将结果保存在一个新节点中，在链表2的每次遍历中创建一个临时链表，将计算结果保存在临时链表中，内层每循环结束一次，将临时链表和要返回的链表相加一次，这样总共相加的次数是外层循环的次数。

某种程度上将乘法运算分解成了加法运算。