一元多项式计算器 ：加、减、乘运算

原文链接 ：https://blog.csdn.net/weixin_44119881/article/details/103717231 

注意 ：此套代码，有所缺陷 ：

实验目的 ： 

完整代码 ： 

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <string.h>
#include <iostream>
#include <cmath>

using namespace std; //调用命名空间std内定义的所有标识符

typedef struct polyn //2个polyn
{
    double coef;        //系数---小数运算
    int expn;           //指数
    struct polyn *next; //指向下一个节点的指针-next存地址
} PolyNode, *PLinkList; //*PLinkList是PolyNode结构体类型的指针 typedef struct polyn *PLinkList;

// typedef struct polyn    //2个polyn
// {
//     double coef;        //系数---小数运算
//     int expn;           //指数
//     struct polyn *next; //指向下一个节点的指针-next存地址
// } PolyNode; //*PLinkList是PolyNode结构体类型的指针
// typedef struct polyn *PLinkList;

PLinkList CreatePolyn(int n);                        //创建一元多项式，使一元多项式呈指数递减
void PrintPolyn(PLinkList head);                     //输出一元多项式
PLinkList Addition(PLinkList L1, PLinkList L2);      //多项式的加法
PLinkList Subtraction(PLinkList L1, PLinkList L2);   //多项式的减法
PLinkList Reverse(PLinkList head);                   //将生成的链表逆置，使一元多项式呈指数递增形式
PLinkList MultiplyPolyn(PLinkList L1, PLinkList L2); //多项式的乘法
void Destory(PLinkList L);                           //销毁多项式---释放空间

//创建一元多项式，使一元多项式呈指数递减
PLinkList CreatePolyn(int n) //n是项数,在main()中输入
{
    PolyNode *p, *q, *s; //结构体指针
    PolyNode *head = NULL;
    double coef2;                               //系数
    int expn2;                                  //指数
    head = (PLinkList)malloc(sizeof(PolyNode)); //动态生成头结点
    if (!head)
    {
        exit(-2); //非正常退出; exit(0)-正常退出
    }

    //初始化
    head->coef = 0.0;
    head->expn = 0;
    head->next = NULL; //下一项为空

    cout << "依次输入多项式的系数和指数: " << endl;
    while (n--)
    {
        cin >> coef2;                            //系数
        cin >> expn2;                            //指数
        s = (PLinkList)malloc(sizeof(PolyNode)); //申请新结点
        if (!s)
        {
            exit(-2);
        }
        s->coef = coef2; //系数
        s->expn = expn2; //指数
        q = head->next;
        p = head;
        while (q && expn2 < q->expn) //expn2为0, q指向head的下一个节点
        {
            p = q;       //p指针后移
            q = q->next; //然后, q指针再后移
        }
        if (q == NULL || expn2 > q->expn)
        {
            p->next = s;
            s->next = q;
        }
        else
        {
            q->coef += coef2;
        }
    }
    return head; //返回头节点---表达式创建完毕
}

//输出一元多项式
void PrintPolyn(PLinkList head)
{
    PolyNode *p = head->next;
    while (p)
    {
        // if(p->coef)
        // {
        // }
        // else
        // {
        //     cout << 0;
        // }
        // printf("%01d",p->coef);
        cout << p->coef; //系数
        //printf("%1.1f",p->coef);
        if (p->expn) //指数
        {
            cout << " * X^" << p->expn << " ";
            //printf("*x^%d",p->expn);
        }
        if (p->next && p->next->coef > 0)
        {
            cout << " + ";
        }
        p = p->next;
    }
}

//相加
PolyNode *Addition(PLinkList L1, PLinkList L2)
{
    PolyNode *head;
    head = (PLinkList)malloc(sizeof(PolyNode)); //作为返回链
    if (!head)
    {
        exit(-2);
    }
    head->next = NULL;

    PLinkList p = L1->next, q = L2->next, r = head;
    while (p != NULL && q != NULL)
    {
        //利用base对返回链进行赋值
        PLinkList base = (PLinkList)malloc(sizeof(PolyNode));
        if (!base)
        {
            exit(-2);
        }
        base->next = NULL;

        r->next = base;        //r->next 返回链
        if (p->expn > q->expn) //判断A\B---谁的指数大【p-L1, q-L2】
        {
            base->coef = p->coef;
            base->expn = p->expn;
            p = p->next;
        }
        else if (p->expn < q->expn)
        {
            base->coef = q->coef;
            base->expn = q->expn;
            q = q->next;
        }
        else
        {
            if (p->coef + q->coef != 0)
            {
                base->coef = p->coef + q->coef;
                base->expn = p->expn;
            }
            else //A\B链 指数相加为0
            {
                r->next = NULL;
                free(base);
            }
            p = p->next;
            q = q->next;
        }
        if (r->next != NULL)
        {
            r = r->next;
        }
    }
    while (p != NULL)
    {
        PLinkList base = (PLinkList)malloc(sizeof(PolyNode));
        if (!base)
        {
            exit(-2);
        }
        base->next = NULL;
        r->next = base;
        base->coef = p->coef;
        base->expn = p->expn;
        r = r->next;
        p = p->next;
    }
    while (q != NULL)
    {
        PLinkList base = (PLinkList)malloc(sizeof(PolyNode));
        if (!base)
        {
            exit(-2);
        }
        base->next = NULL;
        r->next = base;
        base->coef = q->coef;
        base->expn = q->expn;
        r = r->next;
        q = q->next;
    }
    return head;
}

//相减
PolyNode *Subtraction(PLinkList L1, PLinkList L2)
{
    PolyNode *head;
    head = (PLinkList)malloc(sizeof(PolyNode)); //作为返回链
    if (!head)
    {
        exit(-2);
    }
    head->next = NULL;

    PLinkList p = L1->next, q = L2->next, r = head;
    while (p != NULL && q != NULL)
    {
        PLinkList base = (PLinkList)malloc(sizeof(PolyNode));
        if (!base)
        {
            exit(-2);
        }
        base->next = NULL;
        r->next = base;
        if (p->expn > q->expn)
        {
            base->coef = p->coef;
            base->expn = p->expn;
            p = p->next;
        }
        else if (p->expn < q->expn)
        {
            base->coef = -q->coef; /*相减*/
            base->expn = q->expn;
            q = q->next;
        }
        else
        {
            if (p->coef != q->coef) /*相减*/
            {
                base->coef = p->coef - q->coef; /*相减*/
                base->expn = p->expn;
            }
            else
            {
                r->next = NULL;
                free(base);
            }
            p = p->next;
            q = q->next;
        }
        if (r->next != NULL)
        {
            r = r->next;
        }
    }
    while (p != NULL)
    {
        PLinkList base = (PLinkList)malloc(sizeof(PolyNode));
        if (!base)
        {
            exit(-2);
        }
        base->next = NULL;
        r->next = base;
        base->coef = p->coef;
        base->expn = p->expn;
        r = r->next;
        p = p->next;
    }
    while (q != NULL)
    {
        PLinkList base = (PLinkList)malloc(sizeof(PolyNode));
        if (!base)
        {
            exit(-2);
        }
        base->next = NULL;
        r->next = base;
        base->coef = -q->coef; /*相减*/
        base->expn = q->expn;
        r = r->next;
        q = q->next;
    }
    return head;
}

//置逆
PolyNode *Reverse(PLinkList head)
{ //将生成的链表逆置，使一元多项式呈指数递增形式
    PolyNode *q, *r, *p = NULL;
    q = head->next;
    while (q)
    {
        r = q->next;
        q->next = p;
        p = q;
        q = r;
    }
    head->next = p;
    return head;
}

//相乘
PolyNode *MultiplyPolyn(PLinkList L1, PLinkList L2)
{
    PolyNode *pa, *pb, *pc, *u, *head;
    int k, maxExp;
    double coef;
    head = (PLinkList)malloc(sizeof(PolyNode));
    if (!head)
    {
        return NULL;
    }
    head->coef = 0.0;
    head->expn = 0;
    head->next = NULL;

    if (L1->next != NULL && L2->next != NULL) //确定循环次数
    {
        maxExp = L1->next->expn + L2->next->expn;
    }
    else
    {
        return head;
    }

    pc = head;

    L2 = Reverse(L2);
    
    for (k = maxExp; k >= 0; k--)
    {
        pa = L1->next;
        while (pa != NULL && pa->expn > k)
        {
            pa = pa->next;
        }

        pb = L2->next;
        while (pb != NULL && pa != NULL && pa->expn + pb->expn < k)
        {
            pb = pb->next;
        }

        coef = 0.0; //对系数进行初始化

        while (pa != NULL && pb != NULL)
        {
            if (pa->expn + pb->expn == k)
            {
                coef += pa->coef * pb->coef;//和值==max---系数相加
                pa = pa->next;
                pb = pb->next;
            }
            else if (pa->expn + pb->expn > k)//遍历L1链
            {
                pa = pa->next;
            }
            else//遍历L2链
            {
                pb = pb->next;
            }
        }
        if (coef != 0.0)//利用指针u对返回链进行操作
        {
            u = (PLinkList)malloc(sizeof(PolyNode));
            u->coef = coef;
            u->expn = k;

            u->next = pc->next;//pc指向head
            pc->next = u;
            pc = u;
        }
    }
    //L2 = Reverse(L2);
    return head;
}

void Destory(PLinkList L)
{
    for (PLinkList base = L->next; L != NULL; base = base->next)
    {
        free(L);
        L = base;
    }
    return;
}

int main()
{
    PLinkList A, B, C, D, E;
    int n;

    //构造多项式A
    cout << "输出多项式A的项数: ";
    cin >> n;
    A = CreatePolyn(n);
    cout << "A(x) = ";
    // PrintPolyn(A); //多项式为0时, 输出为空！
    if (A)
    {
        PrintPolyn(A);
    }
    else
    {
        cout << 0;
    }
    cout << endl << endl;

    //构造多项式B
    cout << "输出多项式B的项数: ";
    cin >> n;
    B = CreatePolyn(n);
    cout << "B(x) = ";
    // PrintPolyn(B); //多项式为0时, 输出为空！
    if (B)
    {
        PrintPolyn(B);
    }
    else
    {
        cout << 0;
    }
    cout << endl << endl;

    cout << "-----------多项式运算-----------\n";

    //相加
    C = Addition(A, B);
    cout << "A(x) + B(x) = ";
    // PrintPolyn(C); 多项式为0时, 输出为空！
    if (C)
    {
        PrintPolyn(C);
    }
    else
    {
        cout << 0;
    }
    cout << endl << endl;

    //相减
    D = Subtraction(A, B);
    cout << "A(x) - B(x) = ";
    // PrintPolyn(D); 多项式为0时, 输出为空！
    if (D)
    {
        PrintPolyn(D);
    }
    else
    {
        cout << 0;
    }
    cout << endl << endl;

    //相乘
    E = MultiplyPolyn(A, B);
    cout << "A(x) * B(x) = ";
    // PrintPolyn(E); 多项式为0时, 输出为空！
    if (E)
    {
        PrintPolyn(E);
    }
    else
    {
        cout << 0;
    }
    cout << endl << endl;

    Destory(A);
    Destory(B);
    Destory(C); // +
    Destory(D); // -
    Destory(E); // *

    return 0;
}

运行截图 ：