C语言链表实现一个程序，程序内置始终存有一个多项式p，初始值为0；多项式输入功能可以将p改变为输入的多项式多项式计算操作需要输入一个新多项式p’，将p与p’的运算结果赋予p多项式输出操作可以将p降次幂输

以下是一个基于C语言链表实现多项式计算的程序：

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

typedef struct node {
    int coef;  // 系数
    int exp;   // 指数
    struct node* next;
} node;

node* create_node(int coef, int exp) {
    node* new_node = (node*)malloc(sizeof(node));
    new_node->coef = coef;
    new_node->exp = exp;
    new_node->next = NULL;
    return new_node;
}

node* add_term(node* head, int coef, int exp) {
    if (head == NULL) {
        return create_node(coef, exp);
    }
    node* curr = head;
    while (curr->next != NULL) {
        curr = curr->next;
    }
    curr->next = create_node(coef, exp);
    return head;
}

node* input_poly() {
    int n, coef, exp;
    node* poly = NULL;
    printf("请输入多项式的项数：");
    scanf("%d", &n);
    for (int i = 0; i < n; i++) {
        printf("请输入第 %d 项的系数和指数：", i + 1);
        scanf("%d%d", &coef, &exp);
        poly = add_term(poly, coef, exp);
    }
    return poly;
}

void print_poly(node* poly) {
    if (poly == NULL) {
        printf("0\n");
        return;
    }
    node* curr = poly;
    while (curr != NULL) {
        printf("%d", curr->coef);
        if (curr->exp > 0) {
            printf("x^%d", curr->exp);
        }
        if (curr->next != NULL && curr->next->coef >= 0) {
            printf("+");
        }
        curr = curr->next;
    }
    printf("\n");
}

node* add_poly(node* poly1, node* poly2) {
    node* res = NULL;
    node* curr1 = poly1;
    node* curr2 = poly2;
    while (curr1 != NULL && curr2 != NULL) {
        if (curr1->exp > curr2->exp) {
            res = add_term(res, curr1->coef, curr1->exp);
            curr1 = curr1->next;
        } else if (curr1->exp < curr2->exp) {
            res = add_term(res, curr2->coef, curr2->exp);
            curr2 = curr2->next;
        } else {
            res = add_term(res, curr1->coef + curr2->coef, curr1->exp);
            curr1 = curr1->next;
            curr2 = curr2->next;
        }
    }
    while (curr1 != NULL) {
        res = add_term(res, curr1->coef, curr1->exp);
        curr1 = curr1->next;
    }
    while (curr2 != NULL) {
        res = add_term(res, curr2->coef, curr2->exp);
        curr2 = curr2->next;
    }
    return res;
}

node* sub_poly(node* poly1, node* poly2) {
    node* res = NULL;
    node* curr1 = poly1;
    node* curr2 = poly2;
    while (curr1 != NULL && curr2 != NULL) {
        if (curr1->exp > curr2->exp) {
            res = add_term(res, curr1->coef, curr1->exp);
            curr1 = curr1->next;
        } else if (curr1->exp < curr2->exp) {
            res = add_term(res, -curr2->coef, curr2->exp);
            curr2 = curr2->next;
        } else {
            res = add_term(res, curr1->coef - curr2->coef, curr1->exp);
            curr1 = curr1->next;
            curr2 = curr2->next;
        }
    }
    while (curr1 != NULL) {
        res = add_term(res, curr1->coef, curr1->exp);
        curr1 = curr1->next;
    }
    while (curr2 != NULL) {
        res = add_term(res, -curr2->coef, curr2->exp);
        curr2 = curr2->next;
    }
    return res;
}

node* mul_poly(node* poly1, node* poly2) {
    node* res = NULL;
    node* curr1 = poly1;
    while (curr1 != NULL) {
        node* curr2 = poly2;
        while (curr2 != NULL) {
            int coef = curr1->coef * curr2->coef;
            int exp = curr1->exp + curr2->exp;
            res = add_term(res, coef, exp);
            curr2 = curr2->next;
        }
        curr1 = curr1->next;
    }
    return res;
}

node* pow_poly(node* poly, int n) {
    node* res = create_node(1, 0);
    for (int i = 0; i < n; i++) {
        res = mul_poly(res, poly);
    }
    return res;
}

void free_poly(node* poly) {
    node* curr = poly;
    while (curr != NULL) {
        node* temp = curr;
        curr = curr->next;
        free(temp);
    }
}

int main() {
    node* p = create_node(0, 0);
    int choice;
    do {
        printf("1. 输入多项式\n");
        printf("2. 输出多项式\n");
        printf("3. 加法运算\n");
        printf("4. 减法运算\n");
        printf("5. 乘法运算\n");
        printf("6. 次幂运算\n");
        printf("0. 退出程序\n");
        printf("请输入您的选择：");
        scanf("%d", &choice);
        switch (choice) {
            case 1: {
                printf("请输入多项式 p：\n");
                free_poly(p);
                p = input_poly();
                break;
            }
            case 2: {
                printf("多项式 p：");
                print_poly(p);
                break;
            }
            case 3: {
                printf("请输入多项式 p'：\n");
                node* p1 = input_poly();
                node* sum = add_poly(p, p1);
                printf("p + p' = ");
                print_poly(sum);
                free_poly(p1);
                free_poly(sum);
                break;
            }
            case 4: {
                printf("请输入多项式 p'：\n");
                node* p1 = input_poly();
                node* diff = sub_poly(p, p1);
                printf("p - p' = ");
                print_poly(diff);
                free_poly(p1);
                free_poly(diff);
                break;
            }
            case 5: {
                printf("请输入多项式 p'：\n");
                node* p1 = input_poly();
                node* prod = mul_poly(p, p1);
                printf("p * p' = ");
                print_poly(prod);
                free_poly(p1);
                free_poly(prod);
                break;
            }
            case 6: {
                int n;
                printf("请输入次幂 n：");
                scanf("%d", &n);
                node* pow = pow_poly(p, n);
                printf("p ^ %d = ", n);
                print_poly(pow);
                free_poly(pow);
                break;
            }
            case 0: {
                free_poly(p);
                break;
            }
            default: {
                printf("无效选择！\n");
                break;
            }
        }
    } while (choice != 0);
    return 0;
}

该程序可以实现以下功能：

1. 输入多项式
2. 输出多项式
3. 多项式加法
4. 多项式减法
5. 多项式乘法
6. 多项式次幂运算

其中，多项式采用链表实现，每个节点代表多项式的一项，包括系数和指数。输入多项式时，先输入多项式的项数，然后逐项输入系数和指数。多项式加法、减法、乘法的实现都比较简单，主要是遍历两个多项式的链表，根据指数的大小关系进行相应的操作。多项式次幂运算采用了暴力的方法，即将多项式连乘 n 次。