C语言链表实现一元多项式的相加和相乘

一、设计思路：

1. 定义多项式结点的数据结构：

首先，需要定义一个多项式结点的数据结构，包含系数和指数，并且要有指向下一个结点的指针。这将作为链表的结点类型。

typedef struct Node {

    int coefficient;  // 系数

    int exponent;     // 指数

    struct Node* next; // 指向下一个结点的指针

} Node;

2. 创建多项式链表：

创建函数用于插入结点到多项式链表中。你可以定义一个函数 `insertNode`，该函数将根据指数的大小将结点插入到适当的位置，并合并具有相同指数的项。

3. 实现相加运算：

创建一个函数用于相加两个多项式链表。这个函数将遍历两个多项式链表，相同指数的项系数相加，然后将结果插入到新的链表中。

4. 实现相减运算：

类似相加运算，创建一个函数用于相减两个多项式链表。这个函数将遍历两个多项式链表，相同指数的项系数相减，然后将结果插入到新的链表中。

5. 验证运算的正确性：

在 `main` 函数中创建两个多项式，分别插入结点，然后调用相加和相减运算的函数，将结果打印出来，以验证运算的正确性。

6. 释放内存：

最后释放用于存储多项式的链表的内存，以避免内存泄漏。

二、示例代码：

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

// 定义多项式的结点
typedef struct Node {
    int coefficient;  // 系数
    int exponent;     // 指数
    struct Node* next; // 指向下一个结点的指针
} Node;

// 定义多项式链表
typedef struct Polynomial {
    Node* head; // 多项式链表的头结点
} Polynomial;

// 创建一个多项式结点
Node* createNode(int coefficient, int exponent) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    if (newNode != NULL) {
        newNode->coefficient = coefficient;
        newNode->exponent = exponent;
        newNode->next = NULL;
    }
    return newNode;
}

// 插入一个多项式结点到链表
void insertNode(Polynomial* polynomial, int coefficient, int exponent) {
    Node* newNode = createNode(coefficient, exponent);//创建一个新的多项式结点，使用 createNode 函数，将传入的系数和指数分配给新结点
    if (newNode == NULL) {
        printf("内存分配失败\n");
        exit(1);
    }

    Node* current = polynomial->head;//创建了一个指向链表头结点的指针 current，用于遍历链表
    Node* previous = NULL;//这是一个指向前一个结点的指针，初始化为 NULL，用于在插入新结点时维护链表的连接关系

    // 找到合适的位置插入结点
    while (current != NULL && current->exponent > exponent) {//确保按照指数的递减顺序插入结点
        previous = current;//每次迭代中，将 current 赋值给 previous，以便在下一次迭代时可以将新结点插入到正确的位置
        current = current->next;//将 current 指向下一个结点，以便在下一次迭代中继续查找
    }

    // 如果指数相同，合并系数
    if (current != NULL && current->exponent == exponent) {
        current->coefficient += coefficient;//如果找到了相同指数的项，将它们的系数相加
        free(newNode);//释放新结点的内存
    }
    else {
        newNode->next = current;//如果没有找到具有相同指数的项，将新结点的 next 指针指向 current，以连接到链表
        if (previous != NULL) {//如果 previous 不为 NULL，表示不是在链表的开头插入结点，将 previous 结点的 next 指针指向新结点 newNode。
            previous->next = newNode;
        } 
        else {//如果 previous 为 NULL，表示是在链表的开头插入结点，将多项式链表的 head 指针指向新结点 newNode
            polynomial->head = newNode;
        }
    }
}

// 打印多项式
void printPolynomial(Polynomial* polynomial) {
    Node* current = polynomial->head;
    if (current == NULL) {
        printf("多项式为空\n");
    } 
    else {
        while (current != NULL) {
            if (current->coefficient != 0) {
                printf("%dx^%d ", current->coefficient, current->exponent);
            }
            current = current->next;
        }
        printf("\n");
    }
}

// 相加两个多项式
Polynomial addPolynomials(Polynomial* poly1, Polynomial* poly2) {
    Polynomial result;
    result.head = NULL;

    Node* current1 = poly1->head;
    Node* current2 = poly2->head;

    while (current1 != NULL && current2 != NULL) {
        if (current1->exponent > current2->exponent) {
            insertNode(&result, current1->coefficient, current1->exponent);
            current1 = current1->next;
        } else if (current2->exponent > current1->exponent) {
            insertNode(&result, current2->coefficient, current2->exponent);
            current2 = current2->next;
        } else {
            int newCoefficient = current1->coefficient + current2->coefficient;
            if (newCoefficient != 0) {
                insertNode(&result, newCoefficient, current1->exponent);
            }
            current1 = current1->next;
            current2 = current2->next;
        }
    }

    // 处理多项式1或多项式2还有剩余的情况
    while (current1 != NULL) {
        insertNode(&result, current1->coefficient, current1->exponent);
        current1 = current1->next;
    }
    while (current2 != NULL) {
        insertNode(&result, current2->coefficient, current2->exponent);
        current2 = current2->next;
    }

    return result;
}

// 相乘两个多项式
Polynomial multiplyPolynomials(Polynomial* poly1, Polynomial* poly2) {
    Polynomial result;
    result.head = NULL;

    Node* current1 = poly1->head;
    while (current1 != NULL) {
        Node* current2 = poly2->head;
        while (current2 != NULL) {
            int newCoefficient = current1->coefficient * current2->coefficient;
            int newExponent = current1->exponent + current2->exponent;
            insertNode(&result, newCoefficient, newExponent);
            current2 = current2->next;
        }
        current1 = current1->next;
    }

    return result;
}

// 释放多项式链表的内存
void freePolynomial(Polynomial* polynomial) {
    Node* current = polynomial->head;
    while (current != NULL) {
        Node* temp = current;
        current = current->next;
        free(temp);
    }
    polynomial->head = NULL;
}

int main(void) {
    Polynomial poly1;
    poly1.head = NULL;
    Polynomial poly2;
    poly2.head = NULL;

    // 插入多项式1和多项式2的结点
    insertNode(&poly1, 3, 2);
    insertNode(&poly1, 5, 1);
    insertNode(&poly1, 2, 0);
    insertNode(&poly2, 2, 3);
    insertNode(&poly2, -4, 1);
    insertNode(&poly2, 1, 0);

    // 打印 poly1 和 poly2
    printf("多项式1: ");
    printPolynomial(&poly1);
    printf("多项式2: ");
    printPolynomial(&poly2);

    // 调用相加函数并打印结果
    Polynomial sum = addPolynomials(&poly1, &poly2);
    printf("相加结果: ");
    printPolynomial(&sum);

    // 调用相乘函数并打印结果
    Polynomial product = multiplyPolynomials(&poly1, &poly2);
    printf("相乘结果: ");
    printPolynomial(&product);

    // 释放内存
    freePolynomial(&poly1);
    freePolynomial(&poly2);
    freePolynomial(&sum);
    freePolynomial(&product);

    return 0;
}