一元多项式的加减 c语言链表实现

一元多项式的加减 c语言链表实现

1.题目
实现一元多项式的加减法运算，要求多项式采用链表存储结构。
2.测试用例
（1）a(x)=3x^1000 +7x^3-2x+1
b(x)=x^99 -x^3+2x+8
加法运算结果：
c(x)=9.00 +6.00x^3 +1.00x^99 +3.00x^1000
减法运算结果：
d(x)=-7.00 -4.00x+8.00x^3 -1.00x^99+3.00x1000
(2)a(x)= 3x^5 +7x^3+1
b(x)=9x^6 -7x^3+4x2+5x-1
加法运算结果：
c(x)= 5.00x+4.00x^2 +3.00x^5 +9.00x^6
减法运算结果：
d(x)=2.00 -5.00x-4.00x^2 +14.00x^3 +3.00x^5 -9.00x^6
(3)a(x)= 3x^5 +7x^3+1
b(x)=-3x^5 -7x^3-1
加法运算结果：
c(x)=0
减法运算结果：
d(x)=2.00 +14.00x^3 +6.00x^5
(4)a(x)=0
b(x)=1
加法运算结果：
c(x)=1.00
减法运算结果：
d(x)=-1.00
(5)a(x)=x^4 +x^2+1
b(x)=x^5 +x^3 -x^2+1
加法运算结果：
c(x)=2.00 +1.00x^3 +1.00x^4 +1.00x^5
减法运算结果：
d(x)=2.00x^2 -1.00x^3 +1.00x^4 -1.00x^5
3算法描述
（1）一元多项式的存储
采用链表来储存多项式。考虑到多项式习惯用降幂排列，因此建立多项式时，进行一个排序。
（2）一元多项式的建立
建立一元多项式，分别输入每一项的系数和指数。
（3）一元多项式的加减法
两个多项式进行加减法运算时，建立一个新的链表，把结果存在里面要注意当系数之和或之差为0时，将结点删除。
4验证算法对测试用例的操作步骤
以a(x)=x^4 +x^2 +1、b(x)=x^5 +x^3- x^2+1的加法为例，说明算法操作的步骤。
1）建立链表，将多项式储存，链表中储存多项式系数和指数。
2）对多项式进行排序，按照升幂的次序将多项式中每一项进行排序。
3）分别输出两个多项式。
4）对两个多项式分别进行加法和减法运算。进行加减法运算时，若指数想相同，则将系数相加减，若指数不同，则新建立节点，储存数据，注意：当系数为0时，将该节点删除，即该项为0。
5）输出两个多项式加减法的运算结果。
建立第一个链表储存a(x)，
系数（ratio） 指数（index） 地址（next）
1 4
1 2
1 0 NULL

建立第二个链表储存b(x)，
系数（ratio） 指数（index） 地址（next）
1 5
1 3
-1 2
1 0 NULL

利用排序函数将两链表进行排序
排序结果如下
系数（ratio） 指数（index） 地址（next）
1 0
1 2
1 4 NULL
多项式a(x):
多项式b(x):
系数（ratio） 指数（index） 地址（next）
1 0
-1 2
1 3
1 5 NULL

对两多项式进行加减法运算：
加法运算的结果如下：
系数（ratio） 指数（index） 地址（next）
2 0
0 2
1 3
1 4
1 5 NULL

对于系数为0的项，要将其删除，结果如下：
系数（ratio） 指数（index） 地址（next）
2 0
1 3
1 4
1 5 NULL

减法运算的结果如下：
系数（ratio） 指数（index） 地址（next）
0 0
2 2
-1 3
1 4
-1 5 NULL

对于系数为0的项，要将其删除，结果如下:
系数（ratio） 指数（index） 地址（next）
2 2
-1 3
1 4
-1 5 NULL
得到加减法运算的结果，输出运算结果即可。

#include 
#include 
static struct poly *head1,*head2;
struct poly
{
    int index;
    float ratio;
    struct poly *next;
};//建立链表，index储存指数，ratio储存系数
struct poly *creat()
{
    struct poly *temp,*head,*rear,*t;
    int index;
    float ratio;
    int flag=0;
    head=rear=malloc(sizeof(struct poly));
    rear->next=NULL;
    printf("请输入多项式的各项的系数与指数，以空格隔开，输入0 0代表输入结束\n");
    while(1)
    {

        scanf("%f %d",&ratio,&index);
        if(ratio==0&&index==0)
            return head;
        if(head->next==NULL)
        {
            temp=malloc(sizeof(struct poly));
            rear->next=temp;
            rear=temp;
            rear->next=NULL;
            rear->index=index;
            rear->ratio=ratio;
            continue;
        }
        for(t=head->next; t!=NULL; t=t->next)
        {
            if(t->index==index)
            {
                flag=1;
                t->ratio=t->ratio+ratio;
                break;
            }
        }
        if(flag==0)
        {
            temp=malloc(sizeof(struct poly));
            rear->next=temp;
            rear=temp;
            rear->next=NULL;
            rear->index=index;
            rear->ratio=ratio;

        }

    }
    return head;
};//输入数据，在输入时，可能存在输入两次相同系数的数据，此时将两组数据合并
struct poly sort(struct poly *head)
{
    struct poly *temp1,*temp2;
    temp1=head->next;
    temp2=NULL;
    while(temp1!=temp2)
    {
        while(temp1->next!=temp2)
        {
            if(temp1->index>temp1->next->index)
            {
                temp1->index=temp1->index+temp1->next->index;
                temp1->next->index=temp1->index-temp1->next->index;
                temp1->index=temp1->index-temp1->next->index;
                temp1->ratio=temp1->ratio+temp1->next->ratio;
                temp1->next->ratio=temp1->ratio-temp1->next->ratio;
                temp1->ratio=temp1->ratio-temp1->next->ratio;

            }
            temp1=temp1->next;
        }
        temp2=temp1;
        temp1=head->next;
    }
};//将多项式进行排序，以符合我们通常状态下升幂的次序
struct poly add(struct poly *head1,struct poly *head2)
{
    struct poly *head,*rear,*temp1,*p,*q;
    head=rear=malloc(sizeof (struct poly));
    rear->next=NULL;
    p=head1->next;
    q=head2->next;
    while(p!=NULL||q!=NULL)
    {


        if(p==NULL||q==NULL)
        {
            if(p==NULL)
            {
                while(q!=NULL)
                {
                    temp1=malloc(sizeof(struct poly));
                    rear->next=temp1;
                    temp1->next=NULL;
                    temp1->index=q->index;
                    temp1->ratio=q->ratio;
                    rear=temp1;
                    q=q->next;
                }
            }//求和时，若head1为空，则直接将head2复制到新结果中去
            else if(q==NULL)
            {
                while(p!=NULL)
                {
                    temp1=malloc(sizeof(struct poly));
                    rear->next=temp1;
                    temp1->next=NULL;
                    temp1->index=p->index;
                    temp1->ratio=p->ratio;
                    rear=temp1;
                    p=p->next;
                }
            }//若head2为空，则将head1复制到结果中去
        }
        else
        {
            if(p->index<q->index)
            {
                temp1=malloc(sizeof(struct poly));
                temp1->index=p->index;
                temp1->ratio=p->ratio;
                rear->next=temp1;
                rear=temp1;
                rear->next=NULL;
                p=p->next;
            }
            else if(p->index>q->index)
            {
                temp1=malloc(sizeof(struct poly));
                temp1->index=q->index;
                temp1->ratio=q->ratio;
                rear->next=temp1;
                rear=temp1;
                rear->next=NULL;
                q=q->next;
            }
            else
            {
                temp1=malloc(sizeof(struct poly));
                temp1->index=p->index;
                temp1->ratio=q->ratio+p->ratio;
                if(temp1->ratio!=0)
                {
                    rear->next=temp1;
                    rear=temp1;
                    rear->next=NULL;
                    p=p->next;
                    q=q->next;
                }
                else
                {
                    p=p->next;
                    q=q->next;
                }
            }

        }//若head1和head2都不为空，则按照升幂的次序将其排序相加，系数为0的项不需要，注意，一定要按照次序来，少使用排序函数
    }
    print(head);
};//对两多项式进行求和，求和结果储存在另一个结构体中
struct poly sub(struct poly *head1,struct poly *head2)
{
    struct poly *head,*rear,*temp1,*temp2,*p,*q;
    head=rear=malloc(sizeof (struct poly));
    head->next=rear->next=NULL;
    p=head1->next;
    q=head2->next;

    while(p!=NULL||q!=NULL)
    {
        if(p==NULL||q==NULL)
        {
            if(p==NULL)
            {
                while(q!=NULL)
                {
                    temp1=malloc(sizeof(struct poly));
                    rear->next=temp1;
                    temp1->next=NULL;
                    temp1->index=q->index;
                    temp1->ratio=-q->ratio;
                    rear=temp1;
                    q=q->next;
                }
            }
            else if(q==NULL)
            {
                while(p!=NULL)
                {
                    temp1=malloc(sizeof(struct poly));
                    rear->next=temp1;
                    temp1->next=NULL;
                    temp1->index=p->index;
                    temp1->ratio=p->ratio;
                    rear=temp1;
                    p=p->next;
                }
            }
        }
        else
        {
            if(p->index<q->index)
            {
                temp1=malloc(sizeof(struct poly));
                temp1->index=p->index;
                temp1->ratio=p->ratio;
                rear->next=temp1;
                rear=temp1;
                rear->next=NULL;
                p=p->next;
            }
            else if(p->index>q->index)
            {
                temp1=malloc(sizeof(struct poly));
                temp1->index=q->index;
                temp1->ratio=-q->ratio;
                rear->next=temp1;
                rear=temp1;
                rear->next=NULL;
                q=q->next;
            }
            else
            {
                temp1=malloc(sizeof(struct poly));
                temp1->index=p->index;
                temp1->ratio=p->ratio-q->ratio;
                if(temp1->ratio!=0)
                {
                    rear->next=temp1;
                    rear=temp1;
                    rear->next=NULL;
                    p=p->next;
                    q=q->next;
                }
                else
                {
                    p=p->next;
                    q=q->next;
                }
            }

        }
    }
    print(head);
};//多项式求差，与求和同理
void print(struct poly *head)
{
    struct poly *temp;
    temp=head->next;
    if(temp==NULL)
    {
        printf("0\n");
        return;
    }//多项式的输出，若多项式为NULL则直接输出0
    while(temp!=NULL)
    {
        if(temp==head->next)
        {
            printf(" %.2f",temp->ratio);
            if(temp->index!=0)
            {
                if(temp->index==1)
                    printf("x");
                else
                    printf("x^%d",temp->index);
            }
            else
                printf(" ");
        }//在输出第一项时，系数为正，直接输出，系数为负，也直接输出
        else
        {
            if(temp->ratio>0)
            {
                printf("+%.2f",temp->ratio);
                if(temp->index!=0)
                {
                    if(temp->index==1)
                        printf("x");
                    else
                        printf("x^%d",temp->index);
                }

                else
                    printf(" ");
            }
            else
            {
                printf("%.2f",temp->ratio);
                if(temp->index!=0)
                {
                    if(temp->index==1)
                        printf("x");
                    else
                        printf("x^%d",temp->index);
                }

                else
                    printf(" ");
            }//之后的每一项中，系数为正，则加上正号，即加号，系数为负，可直接输出
        }
        temp=temp->next;
    }
    printf("\n");

};

int main()
{
    head1=creat();
    head2=creat();
    sort(head1);
    sort(head2);
    printf("\n多项式a(x)为：\n");
    print(head1);
    printf("\n多项式b(x)为：\n");
    print(head2);
    printf("\n两多项式之和为：\n");
    add(head1,head2);
    printf("\n两多项式之差为：\n");
    sub(head1,head2);
    struct poly *temp;
    temp=head1;
    while(temp!=NULL)
    {
        free(temp);
        temp=temp->next;
    }
    temp=head2;
    while(temp!=NULL)
    {
        free(temp);
        temp=temp->next;
    }
    //释放空间
    return 0;
}

这是我自己写出来的代码，我也是正在学习的学生，供大家参考，若有什么问题，希望可以给我指出，谢谢！