多项式ADT加法乘法——单链表实现

/*
  多项式ADT——单链表实现
*/

/*接口头文件*/
#include <stdbool.h>
typedef int ElementType;

#ifndef _POLYNOMIAL_H
#define _POLYNOMIAL_H

struct Node;
typedef struct Node * PtrToNode;
typedef PtrToNode Polynomial;
typedef PtrToNode Position;

/*操作集*/
Polynomial MakeEmpty( Polynomial Poly );
bool IsEmpty( Polynomial Poly );
bool IsLast( Position P );
Position First( Polynomial Poly );
Position Header( Polynomial Poly );void DeleteList( Polynomial Poly );
void Insert( ElementType Coeff, ElementType Expon, Position P );
Position Advance( Position P );void PrintfList( Polynomial Poly );
void ListInsertSort( Polynomial Head );
Polynomial AddPolynomial( const Polynomial Poly1, const Polynomial Poly2, Polynomial PolySum );
Polynomial MulPolynomial( const Polynomial Poly1, const Polynomial Poly2, Polynomial PolyProd );

#endif

/*接口实现*/ 
#include <stdio.h>
#include <stdlib.h>
#include "polynomial.h"

/*特定结构声明*/
struct Node
{
    ElementType Coefficient;
    ElementType Exponent;
    Position Next;
};

/*合并同类项*/
Polynomial CombSimPolynomial( Polynomial Poly ); 

Polynomial MakeEmpty( Polynomial Poly )
{
    if ( Poly != NULL )
       DeleteList( Poly );
       
    Poly = ( Polynomial )malloc( sizeof( struct Node ) );
    if (Poly == NULL )
    {
       printf( "No Space,quit!\n" );
       exit( 1 );
    }
    Poly->Next = NULL;
    
    return Poly;
}

bool IsEmpty( Polynomial Poly )
{
    return Poly->Next == NULL;
}

bool IsLast( Position P )
{
    return P->Next == NULL;
}

Position First( Polynomial Poly )
{
    return Poly->Next;
}

Position Header( Polynomial Poly )
{
    return Poly;
}

void DeleteList( Polynomial Poly )
{
    Position P;
    Position Temp;
    
    P = First( Poly );
    while ( P != NULL )
    {
        Temp = Advance( P );
        free( P );
        P = Temp;
    }
}

void Insert( ElementType Coeff, ElementType Expon, Position P )
{
    Position Temp;
    
    Temp = ( Polynomial )malloc( sizeof ( struct Node ) );
    if ( Temp == NULL )
    {
       printf( "No Space,quit!\n" );
       exit( 1 );
    }
    Temp->Coefficient = Coeff;
    Temp->Exponent = Expon;
    Temp->Next = P->Next;
    
    P->Next = Temp;
}

Position Advance( Position P )
{
    return P->Next;
}

void PrintfList( Polynomial Poly )
{
    Position P;
    
    if ( IsEmpty( Poly ) )
       printf( "No Data\n" );
    else
    {
       P = First( Poly );
       while ( P != NULL )
       {
            /*当系数为0时，不输出*/ 
            if ( P->Coefficient != 0)
            {
                /*指数为0时，只显示常数*/ 
                if ( P->Exponent == 0 )
                  printf( "%d", P->Coefficient );
                /*当位置P不是尾部且下个P不为负数，结果显示+号*/  
                else if ( P->Next != NULL && P->Next->Coefficient > 0 )
                   printf( "%d^%d+", P->Coefficient, P->Exponent );
                 /*当位置P是尾部或下个P为负数，结果不显示+号*/  
                else
                   printf( "%d^%d", P->Coefficient, P->Exponent );
            }
            P = Advance( P );
       }
       printf( "\n" );
    }
}

/*
   链表插入排序
   策略：
             将原链表Head拆分链表Head和链表Head1。其中链表Head只有一个元素。
             不断从Head1中拿出一个元素插入Head中，直到Head1中没有元素为止。
*/
void ListInsertSort( Polynomial Head )
{
    Polynomial Head1;
    Position P;
    Position Q;
    Position Temp;

    /*空表或者只有一个元素则不排序*/
    if ( Head->Next == NULL || Head->Next->Next == NULL )
       return;
    else
    {
       /*第一次拆分*/
       Head1 = Head->Next->Next;
       Head->Next->Next = NULL;
    
       while ( Head1 != NULL )
       {
           /*降序排列*/
           for ( P = First( Head ), Q = Header( Head ); P != NULL && Head1->Exponent < P->Exponent; Q = P, P = P->Next) 
                 continue;
            
            Temp = Head1;                 //待插入元素
            Head1 = Head1->Next;  
            /*插入元素*/
            Q->Next = Temp;
            Temp->Next = P;
       }
       
    }
}

/*类似链表并集，核心是归并操作*/
Polynomial AddPolynomial( const Polynomial Poly1, const Polynomial Poly2, Polynomial PolySum )
{
    Position P;
    Position Ptr1;
    Position Ptr2;
    
    Ptr1 = First( Poly1 );
    Ptr2 = First( Poly2 );
    PolySum = MakeEmpty( NULL );
    P = Header( PolySum );
    while ( Ptr1 != NULL && Ptr2 != NULL )
    {
        if ( Ptr1->Exponent  < Ptr2->Exponent )
        {
           Insert( Ptr2->Coefficient, Ptr2->Exponent, P );
           Ptr2 = Advance( Ptr2 );
        }
        else if ( Ptr1->Exponent > Ptr2->Exponent )
        {
           Insert( Ptr1->Coefficient, Ptr1->Exponent, P );
           Ptr1 = Advance( Ptr1 );
        }
        else
        {
           Insert( Ptr1->Coefficient + Ptr2->Coefficient, Ptr1->Exponent, P );
           Ptr1 = Advance( Ptr1 );
           Ptr2 = Advance( Ptr2 );
        }
        P = Advance( P );
    }
    
    while ( Ptr1 != NULL )
    {
        Insert( Ptr1->Coefficient, Ptr1->Exponent, P );
        P = Advance( P );
        Ptr1 = Advance( Ptr1 );
    }
    
    while ( Ptr2 != NULL )
    {
        Insert( Ptr2->Coefficient, Ptr2->Exponent, P );
        P = Advance( P );
        Ptr2 = Advance( Ptr2 );
    }
    
    return PolySum;
}

Polynomial MulPolynomial( const Polynomial Poly1, const Polynomial Poly2, Polynomial PolyProd )
{
    Position P;
    Position Ptr1;
    Position Ptr2;
    
    PolyProd = MakeEmpty( NULL );
    P = Header( PolyProd );
    Ptr1 = First( Poly1 );
    Ptr2 = First( Poly2 );
    
    while ( Ptr1 != NULL )
    {
        while ( Ptr2 != NULL )
        {
            Insert( ( Ptr1->Coefficient ) * ( Ptr2->Coefficient ), Ptr1->Exponent + Ptr2->Exponent, P );
            P = Advance( P );
            Ptr2 = Advance( Ptr2 ); 
        }
        Ptr1 = Advance( Ptr1 );
        Ptr2 = First( Poly2 );
    }
    /*结果排序*/
    ListInsertSort( PolyProd );
    /*合并同类项*/
    PolyProd = CombSimPolynomial( PolyProd );
    
    return PolyProd;  
}

Polynomial CombSimPolynomial( Polynomial Poly )
{
    Polynomial Result;
    Position P;
    Position Q;
    
    
    if ( Poly == NULL || Poly->Next->Next == NULL )
       return Poly;
    else
    {
       P = Poly->Next;
       Q = P->Next;
       while ( Q != NULL )
       {
           if ( P->Exponent == Q->Exponent )
           {
              P->Coefficient += Q->Coefficient;
              P->Next = Q->Next;
              Q = Q->Next;
           }
           else
           {
              P = P->Next;
              Q = Q->Next;
           }
       }
       return Poly;
    }
}