两个一元多项式的加法计算----单链表的应用

实验要求如下：

1. 实现两个一元多项式的加法运算。 要求：
   （1）设计函数 createPoly( )，建立一个以单链表形式表示的一元多项式，输
   入次序不限，但要求单链表中元素按指数递增次序排列（不能采用排序算法）。
   （2）设计函数 addPoly( )，实现任意两个多项 A 和 B 加法运算，相加结果
   在多项式 A 中。要求结果链表仍使用原来两个链表的存储空间，不另外占用其
   它的存储空间。
   （3）设计函数 output( )，输出多项式。
   演示示例
   可以不按序输入多项式的各项，但建立的单链表必须是按指数递增有序的。现给出一
   个演示用例如下。
   请输入多项式 A 的项数：3
   请输入多项式 A 各项的系数与指数：2 0 5 4 3 1
   输出多项式 A：
   2 * x^0 + 3 * x + 5 * x^ 4
   请示输入多项式 B 的项数：3
   请输入多项式 B 各项的系数与指数：-5 4 1 3 5 0
   输出多项式 B：
   5 * x^ 0 + 1 x ^ 3 + -5 * x^ 4(正负号不管，只写思路和大致的代码，数没加错和按指数升幂排列就🆗)
   输出两个多项式相加后的结果多项式 A：
   7x^ 0 + 3 * x^ 1 + 1 * x ^ 3
   思路如下:
   （我感觉主要时考察链表的遍历吧，这是本人大一上的寒假作业，只学了C语言）
   利用二重for循环：
   对B每个元素与A链表中每个节点的指数进行比较
   ①如果B当前节点的指数与A当前节点的指数相等
   那么我们就更新A当前节点的系数:prA->coef = prA->coef + prB->coef ;并且立即break（有用）
   特别地，如果更新后系数为0，那么立即删除A链表中该节点
   ②如果在A链表中找不到B节点的指数，那么这里的内层循环一定是走到了prA == NULL 的情况
   （因为找到了的话会立即break，就算是那么prA 也是不为NULL的，只是prA->next == NULL）
   所以只需在内层循环外面加一句
   if(prA == NULL)
   headA = cal(headA , prB->coef , prB->expn);/*在A表中找不到B的对应指数就直接给插入了/
   就可以直接插入B当前节点的系数到A链表中了
   
   具体代码如下：

// 例子已经在CB上运行过了，没毛病，能算，而且当两个二元多项式的项数不同时也能算出正确结果

#include<stdio.h>
#include<stdlib.h>
typedef struct PNode
{
    double coef ; // 系数
    int expn;   // 指数
    struct PNode *next;
}PNode;
PNode *createPoly(PNode *head , int n);/**刚刚开始时，输入系数和指数来建立多项式对应的链表的函数*/
PNode *addPoly(PNode *headA , PNode *headB);/**把两个多项式进行加法运算的函数*/
PNode *cal(PNode *headA , double coef , int expn);/**在A链表中找不到B节点对应的指数时直接插入B节点*/
PNode *deleteNode(PNode *headA , int expn);/***当节点的系数为0时直接删除A节点*/
void   Output(PNode *headA);/**输出A多项式*/
int main()
{
    PNode *headA = NULL , *headB = NULL ;
    int i = 0 , n = 0 ;
    printf("请输入多项式A的项数\n");
    scanf("%d",&n);
    headA = createPoly(headA , n);
    printf("请输入多项式B的项数\n");
    scanf("%d",&n);
    headB = createPoly(headB , n);
    headA = addPoly(headA , headB);
    Output(headA);
    return 0;
}
PNode *createPoly(PNode *head , int n)/**刚刚开始时，输入系数和指数来建立多项式对应的链表的函数*/
{
    PNode *p = head , *pr = head , *temp = NULL;
    int i = 0 ,expn = 0;
    double coef = 0.0 ;
    printf("请输入多项式各项的系数与指数\n");
    for(i = 1 ; i <= n ; i++)
    {
        pr = head ;
        p = (PNode*)malloc(sizeof(PNode));
        if( p == NULL)
        {
            printf("内存不足\n");
            exit(213);
        }
        scanf("%lf %d",&coef , &expn);
        p->next = NULL;
        p->coef = coef ;
        p->expn = expn ;
        if(head == NULL)
        {
             head = p;
        }
        else
        {
            while( pr->expn < expn && pr->next != NULL)
            {
                temp = pr ;
                pr = pr->next;
            }
            if(pr->expn >= expn)
            {
                 if(pr == head)
                {
                    p->next = head;
                    head = p;
                }
                else
                {
                    pr = temp ;
                    p->next = pr->next;
                    pr->next = p;
                }
            }
            else
            {
                pr->next = p;
            }
        }
    }
    for( pr = head ; pr != NULL ; pr = pr->next)
    {
        printf("%.2f * x^%d +" , pr->coef ,pr->expn);
    }
    printf("\n");
    return head;
}
PNode *addPoly(PNode *headA , PNode *headB)/**把两个多项式进行加法运算的函数*/
{
    PNode *prA = headA , *prB = headB , *t = NULL;
    if(headA == NULL || headB == NULL)
    {
        printf("A或B链表为空\n");
        exit(261);
    }
    for( prB = headB ; prB != NULL ; prB = prB->next)
    {
        for(prA = headA ; prA != NULL ; prA = prA->next)
        {

            if(prB->expn == prA->expn)/**能找到相等指数的项就相加*/
            {
                prA->coef = prA->coef + prB->coef ;
                if(prA->coef == 0.0 )
                {
                    t = deleteNode(headA , prA->expn);
                    if( t == NULL ) printf("删除失败异常\n");
                    break;
                }
                break;//加完后立即跳出来
            }
        }
        if(prA == NULL)
        headA = cal(headA , prB->coef , prB->expn);/**在A表中找不到B的对应指数就直接给插入了*/
    }
    return headA;
}
PNode *cal(PNode *headA , double coef , int expn)/**直接传入系数和指数来进行加法运算*/
{
    PNode *prA = headA , *p = (PNode *)malloc(sizeof(PNode)) , *temp = NULL;
    if( p == NULL )
    {
        printf("节点加入失败，内存不足\n");
        exit(21313);
    }
    p->next = NULL;
    p->coef = coef;
    p->expn = expn;
    if( headA == NULL )
    {
        headA = p;
    }
    else
    {
        while( prA->expn < p->expn && prA->next != NULL)
        {
            temp = prA ;
            prA = prA->next;
        }
        if( prA->expn >= p->expn )
        {
            if( prA == headA )
            {
                p->next = headA;
                headA = p;
            }
            else
            {
                prA = temp ;
                p->next = prA->next;
                prA->next = p ;
            }
        }
        else
        {
            prA->next = p;
        }
    }
    return headA;
}
PNode *deleteNode(PNode *headA , int expn)/**删除指定指数的项*/
{
    PNode *prA = headA , *temp = NULL ;
    while( prA->expn != expn && prA->next != NULL )
    {
        temp = prA;
        prA = prA->next;
    }
    if( prA->expn == expn )
    {
        if(prA == headA)
        {
            headA = prA->next;
        }
        else
        {
            temp->next = prA->next;
        }
        free(prA);
    }
    else
        return NULL;
}
void Output(PNode *headA)
{
    PNode *pr = headA;
    if( pr == NULL )
    {
        printf("输出表为空\n");
        exit(65646);
    }
    printf("相加结果为\n");
    while( pr != NULL )
    {
        printf("%.2f * x^%d + " , pr->coef ,pr->expn);
        pr = pr->next;
    }
}

/*
具体的例子
3
2 0 3 1 5 4
3
-5 4 1 3 5 0
*/