单链表应用之稀疏多项式求和（C语言）

采用归并思想计算两个多项幂式之和，这里有两个化简好的关于x的多项幂式：A(x)=7+3x+9x^8+5x^17+2x^20；B(x)=8x+22x^7-9x^8-4x^17，用C语言实现两多项式数据的存储，并求两者的和Y(x)。之所以称之为稀疏多项式，是因为多项式中各项x的指数部分不连续，且相差较大，故编程实现该类多项式存储时可考虑链式存储，提升空间利用率。完整代码如下：

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

/**
* 含头节点单链表应用之稀疏多项式相加： 
* A(x)=7+3x+9x^8+5x^17+2x^20 
* B(x)=8x+22x^7-9x^8-4x^17
* 求：Y(x)=A(x)+B(x) 
*/

//基本操作函数用到的状态码 
#define TRUE 1;
#define FALSE 0;
#define OK 1;
#define ERROR 0;


//Status是新定义的一种函数返回值类型，其值为int型
typedef int Status; 

//数据元素类型
typedef struct {
    int coe;  //系数 
    int exp;  //指数 
} ElemType;

//单链表定义 
typedef struct Lnode {
    ElemType data;        //数据域
    struct Lnode *next;    //指针域
} Lnode, *LinkList;


//基本操作1：单链表初始化 
Status InitList(LinkList *list) {
    (*list)=(LinkList)malloc(sizeof(Lnode));
    (*list)->next=NULL;
    return OK;
}

//基本操作11：头插法建立链表，数据已保存在ElemType类型的数组中
Status CreateList_H(LinkList *list,ElemType arrData[],int length) {
    int j;
    for(j=length-1;j>=0;j--){
        //新建结点 
        Lnode *node;
        node=(Lnode*)malloc(sizeof(Lnode));
        node->data=arrData[j];
        node->next=NULL;
        //插入为1号结点 
        node->next=(*list)->next;
        (*list)->next=node;
    }
    return OK;
}

//基本操作13：链表元素遍历输出  
Status ListTraverse(LinkList list) {
    Lnode *p;
    p=list;
    int j=0;
    printf("序号：     系数：    指数：\n");
    while(p->next){
        j++;
        p=p->next;
        printf("(%d)      %d      %d\n",j,(p->data).coe,(p->data).exp);
    }
    printf("\n");
    return OK;
}

//多项式求和, pa、pb、pc分别指向listA、listB、合并后新链表 的当前结点 
Status GetPolynthicSum(LinkList *listA,LinkList *listB){
    Lnode *pa,*pb,*pc;
    pa=(*listA)->next;
    pb=(*listB)->next;
    pc=(*listA);
    while(pa&&pb){
        if(pa->data.exp==pb->data.exp) {
            Lnode *waitInsert=pa;
            pa->data.coe+=pb->data.coe;  //系数相加
            if(pa->data.coe==0) {   //系数和为零
                pa=pa->next;
                free(waitInsert);  //释放系数和为零的结点 
            } else {
                pa=pa->next;
                //表尾加入新结点，并更新为该新结点 
                pc->next=waitInsert;
                pc=pc->next;
            }
            Lnode *needDelete=pb;
            pb=pb->next;
            free(needDelete);  //释放listB中的结点 
        } else if(pa->data.exp<pb->data.exp) {
            Lnode *waitInsert=pa;
            pa=pa->next;
            //表尾加入新结点，并更新为该新结点 
            pc->next=waitInsert;
            pc=pc->next;
        } else {
            Lnode *waitInsert=pb;
            pb=pb->next;
            //表尾加入新结点，并更新为该新结点 
            pc->next=waitInsert;
            pc=pc->next;
        }        
    }
    
    //连接剩余结点 
    if(pa) {  //表listA长于listB 
        pc->next=pa;
    } else {
        pc->next=pb;
    }
    //释放list_B表头 
    free(*listB);
    return OK;
}


int main(void){
    //产生多项式相关数据，A(x)、B(x)的项按幂增排列 
    ElemType waitInserted_A[] = {
        { 7, 0 },
        { 3, 1 },
        { 9, 8 },
        { 5,17 },
        { 2, 20 }
    };
    ElemType waitInserted_B[] = {
        { 8, 1 },
        { 22, 7 },
        { -9, 8 },
        { -4, 17 }
    };
    
    //获得数组长度 
    int arrLength_A=sizeof(waitInserted_A)/sizeof(waitInserted_A[0]);
    int arrLength_B=sizeof(waitInserted_B)/sizeof(waitInserted_B[0]);
    
    //头插法建立链表list_A和list_B分别保存A(x)、B(x)两个多项式的数据 
    LinkList list_A,list_B;
    InitList(&list_A);
    InitList(&list_B);
    CreateList_H(&list_A,waitInserted_A,arrLength_A); 
    CreateList_H(&list_B,waitInserted_B,arrLength_B); 
    
    
    printf("多项式A(x)的数据：\n"); 
    ListTraverse(list_A);  //遍历测试 
    printf("多项式B(x)的数据：\n"); 
    ListTraverse(list_B);  //遍历测试 
    
    //计算Y(x)=A(x)+B(x)；结果数据放入list_A; 
    GetPolynthicSum(&list_A,&list_B); 
    printf("多项式Y(x)=A(x)+B(x)的数据：\n"); 
    ListTraverse(list_A);  //遍历测试 
    
    printf("\nEND!");
    return 0;
}