顺序结构、动态链表结构下的一元多项式的加法、减法等的实现

笔者做数据结构的课程设计选题，做完了，拿出来分享下
题目如下：
设有一元多项式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)要求输出结果的升幂和降幂两种排列情况

---

// KCSJ.cpp : 定义控制台应用程序的入口点
#include "stdafx.h"
#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("==");
        system("pause");
        return 0;
}

运行效果图如下

以上是部分代码片段。
具体的源码会以压缩包的形式上传到csdn