手把手教你用C/C++实现多项式操作

引言

多项式操作是计算机科学和数学领域中的一个重要主题。在计算机科学中，多项式操作常用于代数表达式求解、图形绘制和优化算法等众多领域。本篇博客将分析一个用C++编写的多项式操作代码，该代码实现了多项式的创建、相加和相乘等基本操作。我们将逐步解释这段代码，帮助您理解多项式操作的基本原理以及如何在C++中实现这些操作。

下方获取完整源码

头文件和结构体定义

#include <iostream>
#include <cstdlib>
#include <cmath>

struct term {
    float coef;
    int expn; // 指数
};

struct Lnode {
    term data;
    Lnode* next;
};

typedef Lnode* Link;
typedef Link Linklist;

这部分代码首先包含了必要的头文件，然后定义了两个结构体，term 表示多项式的每一项，包括系数（coef）和指数（expn）。Lnode 表示链表的节点，其中包含了一个 term 数据和一个指向下一个节点的指针。接着定义了 Link 和 Linklist 类型的别名，这是链表的节点和链表本身的别名。

函数实现

比较函数 comp

int comp(...  ...) {
    if (a.expn == b.expn)
        return 0;
    else
        return (a.expn < b.expn) ? -1 : 1;
}

这个函数 comp 用于比较两个 term 结构体，根据指数来判断它们的大小关系。如果 a 和 b 的指数相等，返回0；如果 a 的指数小于 b，返回-1；否则返回1。

插入排序函数 Orderinsert

void Orderinsert(...  ...) {
    Link o, p, q;
    q = L;
    p = q->next;
    while (p && comp(p->data, e) < 0) {
        q = p;
        p = p->next;
    }
    o = new Lnode;
    o->data = e;
    q->next = o;
    o->next = p;
}

这个函数用于将一个 term 结构体按照指数大小插入到链表 L 中的正确位置。它首先从链表头节点开始遍历，找到正确的插入位置，然后创建一个新节点 o，将 e 的数据赋值给 o，再将 o 插入到链表 L 中的正确位置。

查找元素函数 LocateElem

int LocateElem(...) {
    Link p;
    s = L;
    p = s->next;
    while (p && comp(p->data, e) != 0) {
        s = p;
        p = p->next;
    }
    if (!p) {
        s = q = nullptr;
        return 0;
    }
    else {
        q = p;
        return 1;
    }
}

这个函数用于在链表 L 中查找指定的 term 元素 e，并返回查找结果。s 是查找到的元素的前一个节点，q 是查找到的元素的节点。如果找到了元素，返回1；如果没有找到，返回0。

删除下一个元素函数 Delnext

void Delnext(Linklist& L, Link s) {
    Link q = s->next;
    s->next = q->next;
    delete q;
}

这个函数用于删除链表 L 中节点 s 后面的节点，即删除 s->next，然后释放内存。

插入或合并函数 Orderinsertmerge

void Orderinsertmerge(...) {
    Link q, s;
    if (LocateElem(L, e, s, q, comp)) {
        q->data.coef += e.coef;
        if (q->data.coef == 0) {
            Delnext(L, s);
        }
    }
    else
        Orderinsert(L, e, comp);
}

这个函数用于将一个 term 结构体插入或合并到链表 L 中。如果 e 的指数在链表中已存在，则将两者的系数相加，如果系数为0，则删除该节点；否则，将 e 插入到链表 L 中。

创建多项式函数 Creatpolyn

void Creatpolyn(...  ...  ...) {
    term e;
    int i;
    p = new Lnode;
    p->next = nullptr;
    std::cout << "\n请输入" << m << "个系数和指数用空格符间隔: \n";
    for (i = 1; i <= m; i++) {
        std::cin >> e.coef >> e.expn;
        if (e.coef == 0) {
            e.expn = 0;
        }
        Orderinsertmerge(p, e, comp);
    }
}

这个函数用于创建一个多项式，用户需要输入多项式的项数 m 以及每一项的系数和指数。然后根据用户输入，调用 Orderinsertmerge 函数将每一项插入到多项式链表 p 中。

多项式相加函数 add

void add(...  ...  ...) {
    Lc = new Lnode;
    Lc->next = nullptr;
    Link qa, qb;
    term b;
    qb = Lb->next;

    while (qb) {
        b = qb->data;
        Orderinsertmerge(La, b, comp);
        qb = qb->next;
    }
    qa = La->next;
    while (qa) {
        b = qa->data;
        Orderinsertmerge(Lc, b, comp);
        qa = qa->next;
    }
    delete[] Lb;
    if (!Lc->next)
        std::cout << "0";
}

这个函数实现了多项式的相加操作，将链表 La 和 Lb 中的多项式相加，结果存储在链表 Lc 中。具体实现是遍历 Lb 中的项，分别插入到 La 中，然后将结果存储在 Lc 中。最后，删除链表 Lb，如果结果为空则输出 “0”。

多项式相乘函数 multiplication

void multiplication(...  ...  ...) {
    Lc = new Lnode;
    Lc->next = nullptr;
    term e;
    Link p1, p2;
    p1 = La->next;
    p2 = Lb->next;
    while (p1) {
        while (p2) {
            e.coef = (p1->data.coef) * (p2->data.coef);
            e.expn = (p1->data.expn) + (p2->data.expn);
            Orderinsertmerge(Lc, e, comp);
            p2 = p2->next;
        }
        p2 = Lb->next;
        p1 = p1->next;
    }
}

这个函数实现了多项式的相乘操作，将链表 La 和 Lb 中的多项式相乘，结果存储在链表 Lc 中。具体实现是使用两个嵌套循环，遍历 La 和 Lb 中的项，将每一项的系数相乘，指数相加，然后将结果插入到链表 Lc 中。

打印多项式函数 printpolyn

void printpolyn(......) {
    Link v = p->next;

    if (!v) {
        std::cout << "0\n";
        return;
    }

    bool firstTerm = true;

    while (v) {
        if (v->data.coef != 0) {
            if (!firstTerm) {
                if (v->data.coef > 0)
                    std::cout << " + ";
                else
                    std::cout << " - ";
            }
            firstTerm = false;

            if (v->data.expn == 0) {
                std::cout << std::abs(v->data.coef);
            }
            else {
                if (std::abs(v->data.coef) != 1)
                    std::cout << std::abs(v->data.coef);
                if (v->data.expn == 1) {
                    std::cout << "x";
                }
                if (v->data.expn == 0) {
                    std::cout << "";
                }
                else {
                    std::cout << "x^" << v->data.expn;
                }
            }
        }
        v = v->next;
    }

    std::cout << "\n";
}

这个函数用于打印多项式链表 p 中的内容。它遍历链表中的每一项，根据系数和指数的情况输出对应的多项式表达式，包括正负号、系数、指数、和 “x” 符号。如果链表为空，则输出 “0”。

源码获取：官方渠道需要花费积分下载，
公众号：每日推荐系列，回复【多项式】即可免费获取

多项式操作在计算机科学、数学和工程领域都有广泛的应用，例如在信号处理、优化、数据拟合等方面。掌握多项式操作的基本原理对于理解这些领域的应用是非常重要的。希望本文的解析能够帮助您更好地理解多项式操作，并激发您对计算机科学和数学的兴趣。