【数据结构与算法】多项式ADT

• 多项式ADT
  定义一种一元(具有非负次幂)多项式的抽象数据类型,

  $$F(X) = \sum_{i=0}^NA_iX^i$$
  1. 对于大部分系数为0的多项式,可以使用一个简单数组来储存这些系数.之后进行加减乘除等操作.

//数组实现声明
typedef struct{
    int CoeffArray[ NaxDegree + 1];
    int HighPower;
} *Polynomial;

//初始化为0
void ZeroPolynomial( Polynomial Poly){
    int i;
    for( i=0; i <= MaxDegree; i++)
        Poly->CoeffArray[ i] = 0;
    Poly->HighPower = 0;
}

//相加
void AddPolynomial( const Polynomial Poly1, const Polynomial Poly2,
                   Polynomial PolySum){
    int i;
    ZeroPolynomial( PolySum);
    PolySum->HighPower = Poly1->HighPower > Poly2->HighPower ? Poly1->HighPower : Poly2->HighPower;
    for( i = PolySum->HighPower; i >= 0; i--){
        PolySum->CoeffArray[i] = Poly1->CoeffArray[i] + Poly2->CoeffArray[i];
    }
}

//相乘
void MultPolynomial( const Polynomial Poly1, const Polynomial Poly2,
                   Polynomial PolyProd){
    int i, j;
    ZeroPolynomial( PolyProd);
    PolyProd->HighPower = Poly1->HighPower * Poly2->HighPower;
    if( PolyProd->HighPower > MaxDegree)
        Error("Exceeded array size");
    else 
        for( i = 0; i < Poly1->HighPower; i++)
            for( j = 0; j < Poly2->HighPower; j++)
                PolySum->CoeffArray[ i+j] = Poly1->CoeffArray[i] + Poly2->CoeffArray[j];
}

2 . 使用单链表表示,多项式的每一项包含于一个单元中,同时,这些单元以次数递减的顺序排序.如下图：

//链表实现声明
typedef struct Node *PtrToNode;

struct Node{
    int Coefficient;
    int ExPonent;
    PtrToNode Next;
};

typedef PtrToNode Polynomial;

void Attach( int c, int e, Polynomial *pRear){
    Polynomial P;
    P = ( Polynomial)malloc( sizeof( struct Node));
    P->Coef = c;
    P->Expon = e;
    *pRear -> Next = P;
    *pRear = P;
}

//相加
Polynomial PolyAdd( Polynomial P1, Polynomial P2){
    Polynomial front, rear, temp;
    int sum;
    rear = ( Polynomial)malloc( sizeof( struct Node));
    front = rear;   //front 指向表头
    while( P1 && P2){
        if( P1->Expon > P2->Expon){
            Attach( P1->Coef, P1->Expon, &rear);
            P1 = P1->Next;
        }
        else if( P1->Expon < P2->Expon){
            Attach( P2->Coef, P2->Expon, &rear);
            P2 = P2->Next;
        }
        else if( P1->Expon < P2->Expon){
            sum = P1->Coef + P2->Coef;
            if( sum)    //sum not equals 0
                Attach( sum, P1->Expon, &rear);
            P2 = P2->Next;
            P1 = P1->Next;
        }
    }
    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;
    free(temp);
    return fornt;
}

//相乘
Polynomial PolyMult( Polynomial P1, Polynomial P2){
    Polynomial P, Rear, t1, t2, t;
    int c, e;
    if( !P1 || !P2) return NULL; //存在空表时
    t1 = P1; t2 = P2;
    P = ( Polynomial)malloc( sizeof( struct Node));
    Rear = P;
    while( t2){ //先用P1的第一项乘P2
        Attach( t1->Coef * t2->Coef, t1->Expon + t2->Expon, &Rear);
        t2 = t2->Next;
    }
    t1 = t1->Next;
    while( t1){
        t2 = P2; Rear = P;
        while( t2){
            c = t1->Coef * t2->Coef;
            e = t1->Expon + t2->Expon;
            while( Rear->Next && Rear->Next->Expon > e)
                Rear = Rear->Next;
            if( Rear->Next && Rear->Next->Expon == e){
                if( Rear->Next->Coef + c)
                    Rear->Next->Coef += c;
                else{
                    t = Rear->Next;
                    Rear->Next = t->Next;
                    free(t);
                }
            }
            else{
                t = ( Polynomial)malloc( sizeof( struct Node));
                t->Coef = c; t->Expon = e;
                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;
}