编写一个最基础的c语言程序用单链表储存一元多项式，并实现两个多项式相加的运算

好的，以下是一个基础的 C 语言程序，用单链表储存一元多项式，并实现两个多项式相加的运算。

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

// 定义单链表节点结构体
typedef struct node{
    int coef;  // 系数
    int expn;  // 指数
    struct node* next;  // 指向下一个节点的指针
}Node;

// 创建一个新节点
Node* createNode(int coef, int expn){
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->coef = coef;
    newNode->expn = expn;
    newNode->next = NULL;
    return newNode;
}

// 读取多项式
Node* readPoly(){
    Node* head = createNode(0, 0);  // 创建头节点
    Node* p = head;  // 指针p指向头节点
    int n;  // 多项式项数
    int coef, expn;  // 系数和指数
    printf("请输入多项式项数：");
    scanf("%d", &n);
    for(int i=0;i<n;i++){
        printf("请输入第%d项系数和指数：", i+1);
        scanf("%d%d", &coef, &expn);
        Node* newNode = createNode(coef, expn);  // 创建新节点
        p->next = newNode;  // 将新节点插入到p节点后面
        p = p->next;  // p指向下一个节点
    }
    return head;
}

// 输出多项式
void printPoly(Node* head){
    Node* p = head->next;
    while(p != NULL){
        if(p->coef != 0){
            printf("%dX^%d", p->coef, p->expn);
            if(p->next != NULL && p->next->coef > 0){
                printf("+");
            }
        }
        p = p->next;
    }
}

// 多项式相加
Node* addPoly(Node* poly1, Node* poly2){
    Node* head = createNode(0, 0);  // 创建头节点
    Node* p = head;  // 指针p指向头节点
    Node* p1 = poly1->next;  // 指针p1指向多项式1的第一个节点
    Node* p2 = poly2->next;  // 指针p2指向多项式2的第一个节点
    while(p1 != NULL && p2 != NULL){
        if(p1->expn < p2->expn){  // 如果多项式1的当前节点指数小于多项式2的当前节点指数
            Node* newNode = createNode(p1->coef, p1->expn);  // 创建新节点
            p->next = newNode;  // 将新节点插入到p节点后面
            p = p->next;  // p指向下一个节点
            p1 = p1->next;  // p1指向下一个节点
        }else if(p1->expn > p2->expn){  // 如果多项式1的当前节点指数大于多项式2的当前节点指数
            Node* newNode = createNode(p2->coef, p2->expn);  // 创建新节点
            p->next = newNode;  // 将新节点插入到p节点后面
            p = p->next;  // p指向下一个节点
            p2 = p2->next;  // p2指向下一个节点
        }else{  // 如果多项式1的当前节点指数等于多项式2的当前节点指数
            int coef = p1->coef + p2->coef;  // 系数相加
            if(coef != 0){  // 如果系数不为0
                Node* newNode = createNode(coef, p1->expn);  // 创建新节点
                p->next = newNode;  // 将新节点插入到p节点后面
                p = p->next;  // p指向下一个节点
            }
            p1 = p1->next;  // p1指向下一个节点
            p2 = p2->next;  // p2指向下一个节点
        }
    }
    // 将多项式1或多项式2剩余的节点插入到链表中
    while(p1 != NULL){
        Node* newNode = createNode(p1->coef, p1->expn);  // 创建新节点
        p->next = newNode;  // 将新节点插入到p节点后面
        p = p->next;  // p指向下一个节点
        p1 = p1->next;  // p1指向下一个节点
    }
    while(p2 != NULL){
        Node* newNode = createNode(p2->coef, p2->expn);  // 创建新节点
        p->next = newNode;  // 将新节点插入到p节点后面
        p = p->next;  // p指向下一个节点
        p2 = p2->next;  // p2指向下一个节点
    }
    return head;
}

int main(){
    printf("请输入第一个多项式：\n");
    Node* poly1 = readPoly();  // 读取第一个多项式
    printf("第一个多项式：");
    printPoly(poly1);  // 输出第一个多项式
    printf("\n请输入第二个多项式：\n");
    Node* poly2 = readPoly();  // 读取第二个多项式
    printf("第二个多项式：");
    printPoly(poly2);  // 输出第二个多项式
    Node* poly3 = addPoly(poly1, poly2);  // 多项式相加
    printf("\n多项式相加结果：");
    printPoly(poly3);  // 输出相加结果
    printf("\n");
    return 0;
}

程序流程如下：

1. 定义单链表节点结构体 `Node`，包括系数、指数和指向下一个节点的指针。
2. 定义函数 `createNode()`，用于创建一个新节点。
3. 定义函数 `readPoly()`，用于读取一个多项式，并返回多项式的单链表头节点。
4. 定义函数 `printPoly()`，用于输出一个多项式的字符串表示。
5. 定义函数 `addPoly()`，用于将两个多项式相加，并返回相加结果的单链表头节点。
6. 在 `main()` 函数中，先读取第一个多项式，然后输出它的字符串表示；接着读取第二个多项式，然后输出它的字符串表示；最后将两个多项式相加，并输出相加结果的字符串表示。

注意：这个程序是最基础的版本，没有进行任何优化，只是为了演示单链表存储多项式的基本思路和操作。在实际应用中，需要根据具体情况进行优化和完善。