链表的应用---多项式运算

多项式长成类似下面的样子

运算公式$F(X) =\sum_{i=0}^n A_i X^i$，其中$A_i$表示系数，$X^i$表示指数

本文主要介绍如何用链表去实现多项式的加法操作。

那为什么要用链表，而不用数组呢？试想一下，如果多项式有很多系数都是0，如下图

如果用数组去处理多项式，存储上，就存储了很多是没用的数据，因为很多都是系数为0的数，这些数据不需要去存储，多项式相加处理时，还需要计算上这些系数为0的数，耗时。而用链表可以很好的解决这两个问题，只存储系数不为0的数据，计算时，也只计算系数不为的0的数据。

下面就是用链表实现多项式加法操作

#include <stdio.h>
#include <stdlib.h>
#include <string.h>


typedef struct _NODE_T
{
    int coefficient;
    int exponent;
    struct _NODE_T *next;
}NODE_T;

typedef struct _NODE_T * Polynomial;

void polynomial_insert(Polynomial poly, int coefficient, int exponent)
{
    Polynomial temp = poly;

    while(temp->next)
    {
        temp = temp->next;
    }

    Polynomial polynomial = (Polynomial)malloc(sizeof(NODE_T));
    polynomial->coefficient = coefficient;
    polynomial->exponent = exponent;
    polynomial->next = NULL;

    temp->next = polynomial;
}

void polynomial_traverse(Polynomial poly)
{    
    while(poly)
    {
        printf("coefficient:%2d, exponent:%2d\n", poly->coefficient, poly->exponent);
        poly = poly->next;
    }
}

void polynomial_plus(Polynomial poly1, Polynomial poly2, Polynomial * retPoly)
{
    Polynomial tempA, tempB, retValue, head;
    tempA = poly1->next;
    tempB = poly2->next;

    head = (Polynomial)malloc(sizeof(NODE_T));
    memset(head, 0, sizeof(NODE_T));

    if(!tempA)
    {
        *retPoly = poly2;
        return;
    }

    if(!tempB)
    {
        *retPoly = poly1;
        return;
    }

    *retPoly = head;            // record the head

    while(tempA&&tempB)
    {
        //printf("A  :  coefficient:%2d, exponent:%2d\n", tempA->coefficient, tempA->exponent);
        //printf("B  :  coefficient:%2d, exponent:%2d\n", tempB->coefficient, tempB->exponent);

        retValue = (Polynomial)malloc(sizeof(NODE_T));
        memset(retValue, 0, sizeof(NODE_T));

        if(tempA->exponent > tempB->exponent)
        {  
            retValue->coefficient = tempA->coefficient;
            retValue->exponent = tempA->exponent;   
            tempA = tempA->next;       
        }
        else if(tempA->exponent == tempB->exponent)
        {
            retValue->coefficient = tempA->coefficient + tempB->coefficient;
            retValue->exponent = tempA->exponent;
            tempA = tempA->next;
            tempB = tempB->next;
        }
        else
        {
            retValue->coefficient = tempB->coefficient;
            retValue->exponent = tempB->exponent;  
            tempB = tempB->next;         
        }
        //printf("Sum : coefficient:%2d, exponent:%2d\n\n", retValue->coefficient, retValue->exponent);
        head->next = retValue;
        head = head->next;
    }

    while(tempA)
    {
        head->next = tempA;
        break;
    }

    while(tempB)
    {
        head->next = tempB;
        break;
    }

    printf("\n");
}


void polynomial_main_test(void)
{
#if 0       // case 1 
    Polynomial poly1 = (Polynomial)malloc(sizeof(NODE_T));
    memset(poly1, 0, sizeof(NODE_T));
    polynomial_insert(poly1, 10, 3); 
    polynomial_insert(poly1, 9, 2); 
    polynomial_insert(poly1, 9, 1); 

    Polynomial poly2 = (Polynomial)malloc(sizeof(NODE_T));
    memset(poly2, 0, sizeof(NODE_T));
    polynomial_insert(poly2, 4, 4); 
    polynomial_insert(poly2, 5, 3); 
    polynomial_insert(poly2, 6, 1); 
    polynomial_insert(poly2, 9, 0); 
#endif
#if 0       // case 2
    Polynomial poly1 = (Polynomial)malloc(sizeof(NODE_T));
    memset(poly1, 0, sizeof(NODE_T));
    polynomial_insert(poly1, 10, 4); 
    polynomial_insert(poly1, 9, 2); 
    polynomial_insert(poly1, 9, 1); 

    Polynomial poly2 = (Polynomial)malloc(sizeof(NODE_T));
    memset(poly2, 0, sizeof(NODE_T));
#endif     
    Polynomial poly1 = (Polynomial)malloc(sizeof(NODE_T));
    memset(poly1, 0, sizeof(NODE_T));
    polynomial_insert(poly1, 10, 4); 
    polynomial_insert(poly1, 9, 2); 
    polynomial_insert(poly1, 9, 1); 

    Polynomial poly2 = (Polynomial)malloc(sizeof(NODE_T));
    memset(poly2, 0, sizeof(NODE_T));
    polynomial_insert(poly2, 4, 4); 
    polynomial_insert(poly2, 9, 3); 
    polynomial_insert(poly2, 6, 1); 
    polynomial_insert(poly2, 9, 0); 


    Polynomial retValue = (Polynomial)malloc(sizeof(NODE_T));
    memset(retValue, 0, sizeof(NODE_T));

    printf("Polynomial A:\n");
    polynomial_traverse(poly1->next);
    printf("\nPolynomial B:\n");
    polynomial_traverse(poly2->next);

    polynomial_plus(poly1, poly2, &retValue);
    printf("\nPolynomial after plus :\n");
    polynomial_traverse(retValue->next);
}