c语言单链表实现多项式计算

多项式链表的结构和接口均参考严蔚敏老师的（c语言版）《数据结构》。

加法的实现：

假设指针pa，pb分别指向多项式A和B当前进行比较的某个结点，则比较这两个结点的指数项，有下列三种情况：

1. 指针pa所指结点的指数值 < 指针pb所指结点的指数值：则应摘取pa指针所指结点插入到“和多项式”链表中去
2. 指针pa所指结点的指数值 < 指针pb所指结点的指数值：则应摘取pb指针所指结点插入到“和多项式“链表中去
3. 指针pa所指结点的指数值 = 指针pb所指结点的指数值：则两个结点中的系数相加，若和数部位零，pa所指结点的系数值，同时释放pb所指的结点；反之，从多项式链表中删除相应的结点，同时释放pa和pb所指向的结点。

减法的实现：

简单的思路：先把减数多项式的系数一一取相反数，然后调用加法函数即可实现。

乘法的实现：

M ($x$)　＝　A($x$) x B($x$)　
　　　　＝　Ａ($x$) x [$b_1x^{e_1}+b_2x^{e_2}＋...+b_nx^{e_n}$]
　　　　=$\sum_{i=1}^n b_iA(x)x^{e_i}$

所以，乘法也可以转换成加法实现。

对于链表的操作有几点需要牢记：

1. 需要对链表进行有效性判断

2. 对于链表的操作过程中，首先要创建一个节点，并将头结点复制给新节点

3. 如果要构建新的链表是，表头需要单独保存；同时每个节点需要创建新节点，完成赋值、指针操作；组后需要一个游标节点，负责将各个节点串联起来。
4. 对于尾节点，最后一定要将其next指向NULL。
5. 若在对链表操作时不想改变链表的值，则需要使用malloc函数重新定义一个链表，并把 原链表的内容赋给新链表。此时切记，不要把原链表的指针赋给新生成的结点，否则，在使用的过程中依旧会改变原链表，这是因为指针的特性。

c语言代码实现

/* 接口声明和数据结构声明头文件 */

/* 项的表示 
 * 多项式的项作为单链表的数据元素
*/
typedef struct{
    /* 系数 */
    int coef;
    /* 指数 */
    int expn;
}datatype;

/* 线性单链表的存储结构 */
typedef struct l_node{
    /* 数据域表示多项式的项 */
    datatype data;
    /* 指针域 */
    struct l_node *next;
}l_node,*link_list;

/* 用带头结点的有序链表表示多项式 */
typedef link_list polynomial;

#define true 1
#define false 0

/* 定义ccompare函数的返回值 */
#define a_e_b 0  //a = b
#define a_g_b 1  //a > b
#define a_s_b -1 //a < b


/* 定义polyn_locate函数的返回值 */
#define prior -1  //要找元素值不存在且小于链表中的某些结点
#define curor 0   //要找元素存在
#define nextor 1  //要找元素值不存在且大于链表中的结点


/* -------------------基本操作的函数原型说明------------------- */



/* 比较两个类型为datatype的变量
 * 若a = b,返回a_e_b
 * 若a > b,返回a_g_b
 * 若a < b,返回a_s_b
*/
int compare(datatype a, datatype b);


/* 定义polyn_locate函数的返回类型 */
typedef struct{
    /* 指向某结点的指针 */
    polynomial p;
    /* 类型 */
    int type;
}locate;

/* 若有序链表中HEAD中存在与e满足判定函数compare()取值为a_e_b的元素
 则p为指向HEAD中第一个值为e的结点的指针,并返回curor

 *若有序链表中HEAD中存在与e满足判定函数compare()取值为a_g_b的元素
 则p为指向HEAD中最后一个结点的指针,并返回nextor

 *若有序链表中HEAD中存在与e满足判定函数compare()取值为a_s_b的元素
 则p为指向HEAD中第一个大于e的结点的指针,并返回prior
*/
locate polyn_locate(polynomial HEAD, datatype e, int(*compare)(datatype, datatype));

/* 按有序判定函数compare()的约定,将值为e的结点插入到有序链表的适当位置
*/
void polyn_order_insert(polynomial HEAD, datatype e, int(*compare)(datatype, datatype));

/* 输入m项的系数和指数,建立表示一元多项式的有序链表 
 * HEAD为链表的头指针
*/
void polyn_create(polynomial HEAD);

/* 销毁一元多项式 */
void polyn_destroy(polynomial HEAD);

/* 打印输出一个一元多项式 */
void polyn_print(polynomial HEAD);

/* 返回一元多项式的项数 */
int polyn_length(polynomial HEAD);

/* 完成多项式的相加
 * pa = pa + pb
 * 然后销毁一元多项式pb
*/
polynomial polyn_add(polynomial pa, polynomial pb);

/* 完成多项式的相减
 * pa = pa -pb
 * 并销毁一元多项式pb
*/
polynomial polyn_subtract(polynomial pa, polynomial pb);

/* 完成多项式的相乘
 * pa = pa * pb
 * 并销毁一元多项式pb
*/
polynomial polyn_multiply(polynomial pa, polynomial pb);



/* 复制一个单链表 */
polynomial polyn_clone(polynomial HEAD);




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




int compare(datatype a, datatype b)
{
    if(a.expn == b.expn)
        return a_e_b;
    if(a.expn > b.expn)
        return a_g_b;
    if(a.expn < b.expn)
        return a_s_b;
}


void polyn_print(polynomial HEAD)
{
    /* p指向第一个结点 */
    polynomial p = HEAD -> next;
    if(!p)
        printf("此链表为空\n");
    else
    {
        while(p -> next)
        {
            if (p -> next -> data.coef >= 0)
                printf("%dx^%d + ",p -> data.coef,p -> data.expn);
            else
                printf("%dx^%d ",p -> data.coef,p -> data.expn);   

            p = p -> next;
        }
        printf("%dx^%d\n",p -> data.coef,p -> data.expn);
    }

}


locate polyn_locate(polynomial HEAD, datatype e, int(*compare)(datatype, datatype))
{
    /* 初始化ptr指向头指针 */
    locate ptr; 
    ptr.p = HEAD;
    while((ptr.p) -> next)
    {
        if(compare( (ptr.p -> next -> data), e) == a_e_b)
        {
            ptr.p = ptr.p -> next;
            ptr.type = curor;
            return ptr;
        }
        if(compare( ptr.p -> next -> data, e) == a_g_b)
        {
            ptr.type = prior;
            return ptr;
        }
        if(compare( ptr.p -> next -> data, e) == a_s_b)
        {
            ptr.p = ptr.p -> next;
        }
    }
    ptr.type = nextor;
    return ptr;
}




void polyn_order_insert(polynomial HEAD, datatype e, int(*compare)(datatype, datatype))
{

    locate ptr = polyn_locate(HEAD, e, compare);
    if (ptr.type == nextor)
    {
        /* 新建结点 */
        polynomial new_node = (polynomial)malloc(sizeof(l_node));
        new_node -> data = e;
        /* 修改指针域 */
        ptr.p -> next = new_node;
        new_node -> next = NULL;
    }
    if (ptr.type == prior)
    {
        /* 新建结点 */
        polynomial new_node = (polynomial)malloc(sizeof(l_node));
        new_node -> data = e;
        /* 修改指针域 */
        new_node -> next = ptr.p -> next;
        ptr.p -> next = new_node;
    }
    /* 若该项已存在 */
    if (ptr.type == curor)
    {
        (ptr.p -> data).coef += e.coef;
    }
}


void polyn_create(polynomial HEAD)
{
    /* 初始化头指针 */
    HEAD -> next = NULL;
    datatype temp;
    scanf("%d %d",&(temp.coef), &(temp.expn));
    /* 系数为零,指数为任意值时退出 */
    while(temp.coef != 0)
    {
        /* 建立新结点 */
        polyn_order_insert(HEAD, temp, compare);
        scanf("%d %d",&(temp.coef), &(temp.expn));
    }
}

void polyn_destroy(polynomial HEAD)
{
    while(HEAD)
    {
        polynomial p = HEAD;
        HEAD = HEAD -> next;
        free(p);
    }
}


int polyn_length(polynomial HEAD)
{
    polynomial p = HEAD -> next;
    int i = 0;
    while(p)
    {
        i += 1;
        p = p -> next;
    }
    return i;

}

polynomial polyn_add(polynomial pa, polynomial pb)
{ 
    /* 和链表的头结点 */
    polynomial hc = pa;
    /* 指向和链表的最后一个结点 */
    polynomial pc = hc;
    /* hb为链表b的头结点 */
    polynomial hb = pb;
    /* 当前结点 */
    pb = pb -> next;
    /* 当前结点 */
    pa = pa -> next;
    int type;
    while(pa && pb)
    {
        type = compare(pa -> data, pb -> data);
        if (type == a_e_b)
        {
            /* 指数相同,系数相加 */
            (pa -> data).coef = (pa -> data).coef + (pb -> data).coef;
            if (pa -> data.coef == 0)
            {
                /* 删除pa的当前结点 */
                pc -> next = pa;
                pa = pa -> next;
                free(pc -> next);
                pc -> next = NULL;
                /* 删除pb的当前结点 */
                hb -> next = pb -> next;
                free(pb);
                pb = hb -> next;

            }
            else
            {
                /* 将结点存至和链 */
                pc -> next = pa;
                pc = pa;
                /* 改变b的头结点 */
                hb -> next  = pb -> next;
                /* 释放当前结点 */
                free(pb);
                /* 下一个结点 */
                pb = hb -> next; 
                /* 下一个结点 */
                pa = pa -> next;
            }
        }
        if (type == a_s_b)
        {
            /* 将结点存至和链 */
            pc -> next = pa;
            pc = pa;
            pa = pa -> next;
        }
        if (type == a_g_b)
        {
            /* 将b链的当前结点存至和链 */
            pc -> next = pb;
            pc = pb;
            pb = pb -> next;
            hb -> next = pb;
        }
    }

    if(pa == NULL)
    {
        if(pb == NULL)
            free(hb);
        else
        {
            pc -> next = pb;
            free(hb);
        }
    }
    else
    {
        free(hb);
        pc -> next = pa;
    }
    return hc;

}

polynomial polyn_subtract(polynomial pa, polynomial pb)
{
    /* 先把pb链(减数)取负,然后调用加法函数即可 */
    polynomial hb = pb -> next;
    while(hb)
    {
        hb -> data.coef = 0 - (hb -> data.coef);
        hb = hb -> next;     
    }
    polynomial pc = polyn_add(pa, pb);
    return pc;
}

polynomial polyn_multiply(polynomial pa, polynomial pb)
{
    /* 积的头结点 */
    polynomial p =(polynomial)malloc(sizeof(l_node));
    p -> next = NULL;
    /* 被乘数的当前结点 */
    polynomial pac = pa -> next;
    /* 乘数的当前结点 */
    polynomial pbc = pb -> next;
    while(pbc)
    {
        /* 中间链的头结点 */
        polynomial pc = polyn_clone(pa);
        /* 中间链的当前结点 */
        polynomial pcc = pc -> next;
        while(pac)
        {
            pcc -> data.coef = (pac -> data.coef) * (pbc -> data.coef);
            pcc -> data.expn = (pac -> data.expn) + (pbc -> data.expn);
            pcc = pcc -> next;
            pac = pac -> next;
        }
        pac = pa -> next;
        p = polyn_add(p, pc);
        pbc = pbc -> next;
    }
    polyn_destroy(pa);
    polyn_destroy(pb);
    return p;
}


polynomial polyn_clone(polynomial HEAD)
{
    /* 源链的当前结点 */
    polynomial pnode  = HEAD;
    /* 目的链的头结点和当前结点 */
    polynomial pclone_head,pclone_node;
    if(pnode != NULL)
    {
        pclone_head = (polynomial)malloc(sizeof(l_node));
        pclone_head -> data = pnode -> data;
        pclone_head -> next = NULL;
        pclone_node = pclone_head;
        pnode = pnode -> next;
    }
    while(pnode != NULL)
    {
        polynomial temp_node = (polynomial)malloc(sizeof(l_node));
        temp_node -> data = pnode -> data;
        temp_node -> next = NULL;
        pclone_node -> next = temp_node;
        pclone_node = pclone_node -> next;
        pnode = pnode -> next;
    }
    return pclone_head;
}

int main()
{
    /* 创建pa链表 */
    polynomial pa = (polynomial)malloc(sizeof(l_node));
    polyn_create(pa);
    /* 打印pa链表 */
    polyn_print(pa);
    /* 创建pb链表 */
    polynomial pb = (polynomial)malloc(sizeof(l_node));
    polyn_create(pb);
    /* 打印pb链表 */
    polyn_print(pb);
    /* 两个多项式相乘 */
    polynomial p = polyn_multiply(pa, pb);
    /* 打印结果 */
    polyn_print(p);
    /* 乘积的长度 */
    printf("length=%d\n", polyn_length(p));
    return 0;
}