用单链表存储一元多项式，并实现两个多项式的相乘运算

思路：

1. 定义单链表节点结构体，包含多项式的系数和指数。

2. 定义单链表结构体，包含头节点指针和链表长度。

3. 实现多项式的输入函数，通过循环输入系数和指数，并在单链表中插入新节点。

4. 实现多项式的输出函数，通过遍历单链表输出每一项的系数和指数。

5. 实现两个多项式相乘的函数，通过遍历两个多项式的单链表，分别取出每一项的系数和指数，相乘后插入新链表中。需要注意的是，相同指数的项需要合并系数。

6. 在主函数中调用输入函数输入两个多项式，输出函数输出两个多项式，相乘函数计算两个多项式的乘积并输出。

代码实现：

相关问题

单链表存储一元多项式，求两个多项式的加减乘法运算

一元多项式可以表示为：

$P(x) = a_nx^n + a_{n-1}x^{n-1} + ... + a_1x + a_0$

其中，$a_n, a_{n-1}, ..., a_1, a_0$ 为系数，$x$ 为未知数，$n$ 为次数。

我们可以用单链表来存储一元多项式，每个节点存储一个系数和次数。

接下来，分别介绍一下两个多项式的加减乘法运算。

## 多项式的加法

两个多项式相加，只需要将相同次数的系数相加即可。

具体步骤如下：

1. 分别遍历两个单链表，将相同次数的系数相加。
2. 如果某个链表已经遍历完，将另一个链表剩余的项添加到结果链表中。
3. 如果最高次数的系数为0，则删除该节点。

下面是 C++ 代码实现：

struct Node {
    int coef;  // 系数
    int exp;   // 次数
    Node* next;
};

Node* addPolynomial(Node* p1, Node* p2) {
    Node* result = new Node();
    Node* tail = result;
    while (p1 && p2) {
        if (p1->exp == p2->exp) {
            int sum = p1->coef + p2->coef;
            if (sum != 0) {
                Node* node = new Node();
                node->coef = sum;
                node->exp = p1->exp;
                tail->next = node;
                tail = node;
            }
            p1 = p1->next;
            p2 = p2->next;
        } else if (p1->exp > p2->exp) {
            Node* node = new Node();
            node->coef = p1->coef;
            node->exp = p1->exp;
            tail->next = node;
            tail = node;
            p1 = p1->next;
        } else {
            Node* node = new Node();
            node->coef = p2->coef;
            node->exp = p2->exp;
            tail->next = node;
            tail = node;
            p2 = p2->next;
        }
    }
    while (p1) {
        Node* node = new Node();
        node->coef = p1->coef;
        node->exp = p1->exp;
        tail->next = node;
        tail = node;
        p1 = p1->next;
    }
    while (p2) {
        Node* node = new Node();
        node->coef = p2->coef;
        node->exp = p2->exp;
        tail->next = node;
        tail = node;
        p2 = p2->next;
    }
    Node* temp = result;
    result = result->next;
    delete temp;
    return result;
}

## 多项式的减法

两个多项式相减，只需要将相同次数的系数相减即可。

具体步骤如下：

1. 分别遍历两个单链表，将相同次数的系数相减。
2. 如果某个链表已经遍历完，将另一个链表剩余的项添加到结果链表中。
3. 如果最高次数的系数为0，则删除该节点。

下面是 C++ 代码实现：

Node* subPolynomial(Node* p1, Node* p2) {
    Node* result = new Node();
    Node* tail = result;
    while (p1 && p2) {
        if (p1->exp == p2->exp) {
            int diff = p1->coef - p2->coef;
            if (diff != 0) {
                Node* node = new Node();
                node->coef = diff;
                node->exp = p1->exp;
                tail->next = node;
                tail = node;
            }
            p1 = p1->next;
            p2 = p2->next;
        } else if (p1->exp > p2->exp) {
            Node* node = new Node();
            node->coef = p1->coef;
            node->exp = p1->exp;
            tail->next = node;
            tail = node;
            p1 = p1->next;
        } else {
            Node* node = new Node();
            node->coef = -p2->coef;
            node->exp = p2->exp;
            tail->next = node;
            tail = node;
            p2 = p2->next;
        }
    }
    while (p1) {
        Node* node = new Node();
        node->coef = p1->coef;
        node->exp = p1->exp;
        tail->next = node;
        tail = node;
        p1 = p1->next;
    }
    while (p2) {
        Node* node = new Node();
        node->coef = -p2->coef;
        node->exp = p2->exp;
        tail->next = node;
        tail = node;
        p2 = p2->next;
    }
    Node* temp = result;
    result = result->next;
    delete temp;
    return result;
}

## 多项式的乘法

两个多项式相乘，需要将每一项都相乘，最后将所有结果相加。

具体步骤如下：

1. 遍历第一个链表，取出每一项。
2. 遍历第二个链表，取出每一项。
3. 将两个节点的系数和次数相乘，得到新的节点。
4. 将新的节点插入结果链表中。
5. 重复以上步骤，直到第一个链表遍历完。

下面是 C++ 代码实现：

Node* mulPolynomial(Node* p1, Node* p2) {
    if (!p1 || !p2) {
        return nullptr;
    }
    Node* result = new Node();
    while (p1) {
        Node* p = p2;
        Node* tail = result;
        while (p) {
            int coef = p1->coef * p->coef;
            int exp = p1->exp + p->exp;
            Node* node = new Node();
            node->coef = coef;
            node->exp = exp;
            while (tail->next && tail->next->exp > exp) {
                tail = tail->next;
            }
            if (tail->next && tail->next->exp == exp) {
                tail->next->coef += coef;
            } else {
                node->next = tail->next;
                tail->next = node;
            }
            p = p->next;
        }
        p1 = p1->next;
    }
    Node* temp = result;
    result = result->next;
    delete temp;
    return result;
}

以上就是单链表存储一元多项式，以及两个多项式的加减乘法运算的实现。

C语言编写一个程序实现两个一元多项式相乘。

实现两个一元多项式相乘的程序可以按照以下步骤进行:

1. 定义一个结构体表示多项式，包括系数和指数两个成员变量。

2. 定义一个函数用来输入多项式，输入格式如下：

   输入项数n，接下来n行每行输入一个系数和指数

3. 定义一个函数用来输出多项式，输出格式如下：

   输出项数n，接下来n行每行输出一个系数和指数

4. 定义一个函数用来实现两个多项式的相乘，具体步骤如下：

- 定义一个数组，用来存储相乘后的结果。
- 遍历第一个多项式的每一项，再遍历第二个多项式的每一项，将它们的系数相乘并将结果加到数组中相应的位置。
- 将数组中的结果组合成一个新的多项式并返回。

5. 在主函数中调用上述函数实现多项式相乘，并输出结果。

下面是示例代码：

#include <stdio.h>
#include <stdlib.h>

#define MAX_TERMS 100

// 定义结构体表示多项式
typedef struct {
    float coef; // 系数
    int exp; // 指数
} Polynomial;

// 输入多项式
void input(Polynomial poly[], int *n) {
    printf("请输入项数：");
    scanf("%d", n);
    printf("请输入每一项的系数和指数：\n");
    for (int i = 0; i < *n; i++) {
        scanf("%f %d", &poly[i].coef, &poly[i].exp);
    }
}

// 输出多项式
void output(Polynomial poly[], int n) {
    printf("多项式为：\n");
    printf("%d\n", n);
    for (int i = 0; i < n; i++) {
        printf("%.2f %d\n", poly[i].coef, poly[i].exp);
    }
}

// 实现两个多项式的相乘
Polynomial multiply(Polynomial poly1[], int n1, Polynomial poly2[], int n2) {
    Polynomial result[MAX_TERMS]; // 存储结果的数组
    int count = 0; // 记录结果中的项数
    for (int i = 0; i < n1; i++) {
        for (int j = 0; j < n2; j++) {
            result[count].coef = poly1[i].coef * poly2[j].coef;
            result[count].exp = poly1[i].exp + poly2[j].exp;
            count++;
        }
    }
    // 将数组中的结果组合成一个新的多项式并返回
    Polynomial res;
    for (int i = 0; i < count; i++) {
        if (result[i].coef == 0) {
            continue;
        }
        for (int j = i+1; j < count; j++) {
            if (result[j].coef == 0) {
                continue;
            }
            if (result[i].exp == result[j].exp) {
                result[i].coef += result[j].coef;
                result[j].coef = 0;
            }
        }
        res.coef = result[i].coef;
        res.exp = result[i].exp;
    }
    return res;
}

int main() {
    Polynomial poly1[MAX_TERMS], poly2[MAX_TERMS];
    int n1, n2;
    input(poly1, &n1);
    input(poly2, &n2);
    output(poly1, n1);
    output(poly2, n2);
    Polynomial res = multiply(poly1, n1, poly2, n2);
    output(&res, 1);
    return 0;
}

注意，本程序只是一个简单的实现，还有很多需要改进的地方。例如，需要对输入的多项式进行排序，以便进行相乘时可以减少运算量。