数据结构课程设计：顺序结构、动态链表结构下的一元多项式的加法、减法、乘法的实现

原来做的数据结构课程设计，今天整理资料时偶然发现了，自己留着没啥意思，共享一下吧，互相交流学习

要求 

 设有一元多项式Am(x)和Bn(x).

  Am(x)=A0+A1x1+A2x2+A3x3+… +Amxm

  Bn(x)=B0+B1x1+B2x2+B3x3+… +Bnxn

 请实现求M(x)= Am(x)+Bn(x)、M(x)= Am(x)-Bn(x)和M(x)= Am(x)×Bn(x)。

    要求：

1)首先判定多项式是否稀疏

2)分别采用顺序和动态存储结构实现；

3)结果M(x)中无重复阶项和无零系数项；

4)要求输出结果的升幂和降幂两种排列情况

算法分析：

以后再写。 

代码实现： 

#include<stdio.h>

#include<malloc.h>

#include<stdlib.h>

struct data{

    int xishu;

    int zhishu;

};

struct node{

    data dat;

    node *next;

};

int cmp(const void *a,const void *b)

{

    return ((data*)a)->zhishu-((data*)b)->zhishu;

}

void output(node *head)

{

    node *p;

    node *shengxu;

    shengxu=new node;

    shengxu->next=NULL;

    printf("升序排列\n");

    p=head->next;

    while(p)

    {

        if(p->dat.xishu<0)

            printf("\b");

        if(p->dat.xishu!=0)

        {

            if(p->dat.xishu==1)

                printf("X^%d+",p->dat.zhishu);

            else if(p->dat.xishu==-1)

                printf("-X^%d+",p->dat.zhishu);

            else

                printf("%dX^%d+",p->dat.xishu,p->dat.zhishu);

        }

        node *q;

        q=new node;

        q->dat.zhishu=p->dat.zhishu;

        q->dat.xishu=p->dat.xishu;

        q->next=shengxu->next;

        shengxu->next=q;

        p=p->next;

    }

    printf("\b \n");

    printf("降序排列\n");

    p=shengxu->next;

    while(p)

    {

        if(p->dat.xishu<0)

            printf("\b");

        if(p->dat.xishu!=0)

        {

            if(p->dat.xishu==1)

                printf("X^%d+",p->dat.zhishu);

            else if(p->dat.xishu==-1)

                printf("-X^%d+",p->dat.zhishu);

            else

                printf("%dX^%d+",p->dat.xishu,p->dat.zhishu);

        }

        p=p->next;

    }

    printf("\b \n");

}

int main()

{

    int sum1,sum2;

    data *d1,*d2;

    int zhishu_max1=-1,zhishu_max2=-1;

    int i,j;

    int *biaodashi1,*biaodashi2;

    node *he,*cha;

    node *head1,*head2,*tail1,*tail2;

    head1=(node *)malloc(sizeof(node));

    head2=(node *)malloc(sizeof(node));

    head1->next=NULL;

    head2->next=NULL;

    tail1=head1;

    tail2=head2;

    //输入第一个表达式

    printf("请输入第一个多项式的项数：");

    scanf("%d",&sum1);

    d1=(data*)malloc(sum1*sizeof(data));

    printf("请依次输入每项多项式的系数和指数:\n");

    for(i=0;i<sum1;i++)

    {

        scanf("%d%d",&d1[i].xishu,&d1[i].zhishu);

    }

    //输入第二个表达式

    printf("请输入第二个多项式的项数：");

    scanf("%d",&sum2);

    d2=(data*)malloc(sum2*sizeof(data));

    printf("请依次输入每项多项式的系数和指数:\n");

    for(i=0;i<sum2;i++)

    {

        scanf("%d%d",&d2[i].xishu,&d2[i].zhishu);

    }

    //排序

    qsort(d1,sum1,sizeof(data),cmp);

    qsort(d2,sum2,sizeof(data),cmp);

    zhishu_max1=d1[sum1-1].zhishu;

    zhishu_max2=d2[sum2-1].zhishu;

    for(i=0;i<30;i++)

        printf("==");

    printf("\n");

    //输出第一个表达式

    printf("第一个表达式为：\n");

    for(i=0;i<sum1;i++)

    {

        if(d1[i].xishu!=0)

        {

            if(d1[i].xishu==1)

                printf("X^%d",d1[i].zhishu);

            else if(d1[i].xishu==-1)

                printf("-X^%d",d1[i].zhishu);

            else

                printf("%dX^%d",d1[i].xishu,d1[i].zhishu);

        }

        if(i<sum1-1)

            printf("+");

    }

    printf("\n");

    //判断是否稀疏

    if(zhishu_max1-d1[0].zhishu>(sum1*sizeof(node)))

    {

        printf("第一个表达式稀疏\n\n");

        for(i=0;i<sum1;i++)

        {

            node *p;

            p=(node*)malloc(sizeof(node));

            p->dat.zhishu=d1[i].zhishu;

            p->dat.xishu=d1[i].xishu;

            tail1->next=p;

            p->next=NULL;

            tail1=p;

        }

    }

    else

    {

        printf("第一个表达式稠密!\n\n");

        biaodashi1=(int*)malloc(zhishu_max1*sizeof(int));

        j=0;

        for(i=0;i<=zhishu_max1;i++)

        {

            if(i==d1[j].zhishu){

                biaodashi1[i] =d1[j].xishu;

                j++;

            }

            else

                biaodashi1[i]=0;

        }

    }

    //输出第二个表达式

    printf("第二个表达式为：\n");

    for(i=0;i<sum2;i++)

    {

        if(d2[i].xishu!=0)

        {

            if(d2[i].xishu==1)

                printf("X^%d",d2[i].zhishu);

            else if(d2[i].xishu==-1)

                printf("X^%d",d2[i].zhishu);

            else

                printf("%dX^%d",d2[i].xishu,d2[i].zhishu);

        }

        if(i<sum2-1)

            printf("+");

    }

    printf("\n");

    //判断是否稀疏

    if(zhishu_max2-d2[0].zhishu>(sum2*sizeof(node)))

    {

        printf("第一个表达式稀疏\n\n");

        for(i=0;i<sum2;i++)

        {

            node *p;

            p=(node*)malloc(sizeof(node));

            p->dat.zhishu=d2[i].zhishu;

            p->dat.xishu=d2[i].xishu;

            tail2->next=p;

            p->next=NULL;

            tail2=p;

        }

    }

    else

    {

        printf("第二个表达式稠密!\n\n");

        biaodashi2=(int*)malloc(zhishu_max2*sizeof(int));

        j=0;

        for(i=0;i<=zhishu_max2;i++)

        {

            if(i==d2[j].zhishu){

                biaodashi2[i]=d2[j].xishu;

                j++;

            }

            else

                biaodashi2[i]=0;

        }

    }

    //求两个多项式的和和差

    he=new node;

    cha=new node;

    he->next=NULL;

    cha->next=NULL;

    node *cha_tail,*he_tail;

    he_tail=he;

    cha_tail=cha;

    for(i=0,j=0;i<sum1&&j<sum2;)

    {

        node *p,*p2;

        p=new node;

        p2=new node;

        if(d1[i].zhishu<d2[j].zhishu)

        {

            p->dat.zhishu=d1[i].zhishu;

            p->dat.xishu=d1[i].xishu;

            p2->dat.zhishu=d1[i].zhishu;

            p2->dat.xishu=d1[i].xishu;

            i++;

        }

        else if(d1[i].zhishu>d2[j].zhishu)

        {

            p->dat.zhishu=d2[j].zhishu;

            p->dat.xishu=d2[j].xishu;

            p2->dat.zhishu=d2[j].zhishu;

            p2->dat.xishu=-d2[j].xishu;

            j++;

        }

        else

        {

            p->dat.zhishu=d1[i].zhishu;

            p->dat.xishu=d1[i].xishu+d2[j].xishu;

            p2->dat.zhishu=d1[i].zhishu;

            p2->dat.xishu=d1[i].xishu-d2[j].xishu;

            i++;

            j++;

        }

        he_tail->next=p;

        p->next=NULL;

        he_tail=p;

        cha_tail->next=p2;

        p2->next=NULL;

        cha_tail=p2;

    }

    //将剩余的项加到表达式中

    if(sum1<sum2)

    {

        for(;j<sum2;j++)

        {

            node *p,*p2;

            p=new node;

            p2=new node;

            p->dat.zhishu=d2[j].zhishu;

            p->dat.xishu=d2[j].xishu;

            p2->dat.zhishu=d2[j].zhishu;

            p2->dat.xishu=-d2[j].xishu;

            he_tail->next=p;

            p->next=NULL;

            he_tail=p;

            cha_tail->next=p2;

            p2->next=NULL;

            cha_tail=p2;

        }

    }

    else if(sum1>sum2)

    {

        j=i;

        for(;j<sum1;j++)

        {

            node *p,*p2;

            p=new node;

            p2=new node;

            p->dat.zhishu=d2[j].zhishu;

            p->dat.xishu=d2[j].xishu;

            p2->dat.zhishu=d2[j].zhishu;

            p2->dat.xishu=d2[j].xishu;

            he_tail->next=p;

            p->next=NULL;

            he_tail=p;

            cha_tail->next=p2;

            p2->next=NULL;

            cha_tail=p2;

        }

    }

    //输出两个表达式的和

    printf("两个表达式的和为：\n");

    output(he);

    //输出两个表达式的差

    printf("\n两个表达式的差为：\n");

    output(cha);

    //表达式乘法

    node *chengfa;

    chengfa = new node;

    chengfa -> next = NULL;

    for(i=0;i<sum1;i++)

    {

        for(j=0;j<sum2;j++)

        {

            node *p;

            p = new node;

            p -> dat.zhishu = d1[i].zhishu + d2[j].zhishu;

            p -> dat.xishu = d1[i].xishu * d2[j].xishu;

            p->next=NULL;

            node *q;

            q = chengfa;

            while(q->next)

            {

                if(q->next->dat.zhishu>p->dat.zhishu)

                {

                    p->next=q->next;

                    q->next=p;

                    break;

                }

                else if(q->next->dat.zhishu==p->dat.zhishu)

                {

                    q->next->dat.xishu+=p->dat.xishu;

                    break;

                }

                q=q->next;

            }

            if(q->next==NULL)

            {

                p->next=q->next;

                q->next=p;

            }

        }

    }

    printf("\n两个表达式的乘积为：\n");

    output(chengfa);

    for(i=0;i<30;i++)

        printf("==");

}