设计一种单链表存储结构，每个结点存储一项的系数和指数，类型都是整型，编写完成产生多项式的函数、多项式相加及输出多项式的函数。

### 回答1：
单链表存储结构可以定义如下：

struct Node {
int coef; // 系数
int exp; // 指数
Node* next; // 指向下一个结点的指针
};

产生多项式的函数可以按照指数从高到低的顺序插入结点，代码如下：

Node* createPolynomial() {
Node* head = new Node(); // 头结点
head->next = nullptr;
int coef, exp;
while (true) {
cout << "请输入系数和指数（输入 结束）：";
cin >> coef >> exp;
if (coef == && exp == ) {
break;
}
Node* p = head;
while (p->next != nullptr && p->next->exp > exp) {
p = p->next;
}
Node* q = new Node();
q->coef = coef;
q->exp = exp;
q->next = p->next;
p->next = q;
}
return head;
}

多项式相加可以遍历两个多项式的结点，按照指数从高到低的顺序合并，代码如下：

Node* addPolynomial(Node* p1, Node* p2) {
Node* head = new Node(); // 头结点
head->next = nullptr;
Node* p = head;
while (p1->next != nullptr && p2->next != nullptr) {
if (p1->next->exp > p2->next->exp) {
Node* q = new Node();
q->coef = p1->next->coef;
q->exp = p1->next->exp;
q->next = p->next;
p->next = q;
p1 = p1->next;
} else if (p1->next->exp < p2->next->exp) {
Node* q = new Node();
q->coef = p2->next->coef;
q->exp = p2->next->exp;
q->next = p->next;
p->next = q;
p2 = p2->next;
} else {
Node* q = new Node();
q->coef = p1->next->coef + p2->next->coef;
q->exp = p1->next->exp;
q->next = p->next;
p->next = q;
p1 = p1->next;
p2 = p2->next;
}
p = p->next;
}
while (p1->next != nullptr) {
Node* q = new Node();
q->coef = p1->next->coef;
q->exp = p1->next->exp;
q->next = p->next;
p->next = q;
p1 = p1->next;
p = p->next;
}
while (p2->next != nullptr) {
Node* q = new Node();
q->coef = p2->next->coef;
q->exp = p2->next->exp;
q->next = p->next;
p->next = q;
p2 = p2->next;
p = p->next;
}
return head;
}

输出多项式的函数可以遍历链表输出每一项，代码如下：

void printPolynomial(Node* head) {
Node* p = head->next;
while (p != nullptr) {
cout << p->coef << "x^" << p->exp;
if (p->next != nullptr) {
cout << " + ";
}
p = p->next;
}
cout << endl;
}

完整代码如下：

### 回答2：
单链表是一种常用的线性数据结构，其由一系列节点组成，每个节点包含两个部分，即数据域和指针域。在设计一种单链表存储结构，用于存储多项式时，每个节点需要存储一项的系数和指数。

一个多项式可以表示为a0x^b0 + a1x^b1 + a2x^b2 + ... + anx^bn。将其存储在单链表中，则可以将每一项的系数和指数存储在节点的数据域中，使用next指针连接不同项。

下面是单链表存储多项式的结构体定义：

typedef struct node {
    int coef; // 系数
    int expo; // 指数
    struct node* next;
} Node, *pNode;

其中coef代表系数，expo代表指数，next是指向下一个节点的指针。

产生多项式的函数可以采用用户输入的方式，每次输入一项的系数和指数，然后加入到单链表中。代码如下：

pNode CreateList(int n) {
    pNode head = (pNode)malloc(sizeof(Node)); // 头节点
    pNode tail = head;
    printf("请依次输入多项式的系数、指数：\n");
    for(int i=0;i<n;i++) {
        pNode p = (pNode)malloc(sizeof(Node));
        scanf("%d %d", &p->coef, &p->expo);
        tail->next = p;
        tail = p;
    }
    tail->next = NULL; // 链表尾部指针置为NULL
    return head;
}

多项式相加可以采用归并排序的思想，将两个有序的单链表合并成一个有序的单链表。代码如下：

pNode Add(pNode p1, pNode p2) {
    pNode head = (pNode)malloc(sizeof(Node)); // 头节点
    pNode tail = head;
    pNode tmp;
    while(p1 && p2) {
        if(p1->expo < p2->expo) {
            tmp = (pNode)malloc(sizeof(Node));
            tmp->coef = p1->coef;
            tmp->expo = p1->expo;
            p1 = p1->next;
        } else if(p1->expo > p2->expo) {
            tmp = (pNode)malloc(sizeof(Node));
            tmp->coef = p2->coef;
            tmp->expo = p2->expo;
            p2 = p2->next;
        } else {
            tmp = (pNode)malloc(sizeof(Node));
            tmp->coef = p1->coef + p2->coef;
            tmp->expo = p1->expo;
            p1 = p1->next;
            p2 = p2->next;
        }
        if(tmp->coef != 0) { // 系数为0的项不加入链表
            tail->next = tmp;
            tail = tmp;
        } else {
            free(tmp); // 系数为0的项需要释放内存
        }
    }
    tail->next = p1 ? p1 : p2; // 将剩余项连接到链表末尾
    return head;
}

输出多项式的函数可以遍历链表，将每一项的系数和指数输出。代码如下：

void Print(pNode head) {
    pNode p = head->next;
    while(p) {
        printf("%d", p->coef);
        if(p->expo != 0) {
            printf("x^%d", p->expo);
        }
        if(p->next) {
            printf(" + ");
        }
        p = p->next;
    }
    printf("\n");
}

综合起来，可以编写一个可以产生多项式、多项式相加、输出多项式的程序如下：

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

typedef struct node {
    int coef;
    int expo;
    struct node* next;
} Node, *pNode;

pNode CreateList(int n) {
    pNode head = (pNode)malloc(sizeof(Node));
    pNode tail = head;
    printf("请依次输入多项式的系数、指数：\n");
    for(int i=0;i<n;i++) {
        pNode p = (pNode)malloc(sizeof(Node));
        scanf("%d %d", &p->coef, &p->expo);
        tail->next = p;
        tail = p;
    }
    tail->next = NULL;
    return head;
}

pNode Add(pNode p1, pNode p2) {
    pNode head = (pNode)malloc(sizeof(Node));
    pNode tail = head;
    pNode tmp;
    while(p1 && p2) {
        if(p1->expo < p2->expo) {
            tmp = (pNode)malloc(sizeof(Node));
            tmp->coef = p1->coef;
            tmp->expo = p1->expo;
            p1 = p1->next;
        } else if(p1->expo > p2->expo) {
            tmp = (pNode)malloc(sizeof(Node));
            tmp->coef = p2->coef;
            tmp->expo = p2->expo;
            p2 = p2->next;
        } else {
            tmp = (pNode)malloc(sizeof(Node));
            tmp->coef = p1->coef + p2->coef;
            tmp->expo = p1->expo;
            p1 = p1->next;
            p2 = p2->next;
        }
        if(tmp->coef != 0) {
            tail->next = tmp;
            tail = tmp;
        } else {
            free(tmp);
        }
    }
    tail->next = p1 ? p1 : p2;
    return head;
}

void Print(pNode head) {
    pNode p = head->next;
    while(p) {
        printf("%d", p->coef);
        if(p->expo != 0) {
            printf("x^%d", p->expo);
        }
        if(p->next) {
            printf(" + ");
        }
        p = p->next;
    }
    printf("\n");
}

int main() {
    int n1, n2;
    printf("请依次输入第一个多项式的项数和第二个多项式的项数：\n");
    scanf("%d %d", &n1, &n2);
    pNode p1 = CreateList(n1);
    pNode p2 = CreateList(n2);
    printf("第一个多项式为：");
    Print(p1);
    printf("第二个多项式为：");
    Print(p2);
    pNode p = Add(p1, p2);
    printf("相加后的多项式为：");
    Print(p);
    return 0;
}

### 回答3：
单链表是一种线性表结构，节点由两个部分组成：节点数据和指向下一个节点的指针。在多项式运算中，我们可以使用单链表来存储每一项的系数和指数。节点中的数据类型都是整型，用来存储多项式的系数和指数。单链表是一种动态数据结构，可以在运行中动态地增加、删除节点。

设计单链表存储结构如下：

struct Node{
int coef; //系数
int expn; //指数
struct Node *next; //指向下一个节点的指针
};

产生多项式的函数：可以根据用户输入的系数和指数来动态地产生多项式。函数返回一个指针，指向单链表的头节点。代码如下：

Node *create(){
Node *head, *p, *q;
head = new Node;
p = head;
int coef, expn;
cout<<"请输入多项式的系数和指数（系数为0时停止输入）："<<endl;
cin>>coef>>expn;
while(coef!=0){
q = new Node;
q->coef = coef;
q->expn = expn;
p->next = q;
p = q;
cin>>coef>>expn;
}
p->next = NULL;
return head;
}

多项式相加：可以将两个多项式相加，将节点插入到一个新的单链表中。函数返回一个指针，指向相加后多项式的头节点。代码如下：

Node *add(Node *head1, Node *head2){
Node *p1, *p2, *q, *head;
p1 = head1->next;
p2 = head2->next;
head = new Node;
q = head;
while(p1!=NULL && p2!=NULL){
if(p1->expn > p2->expn){
q->next = new Node;
q = q->next;
q->coef = p1->coef;
q->expn = p1->expn;
p1 = p1->next;
}
else if(p1->expn < p2->expn){
q->next = new Node;
q = q->next;
q->coef = p2->coef;
q->expn = p2->expn;
p2 = p2->next;
}
else{
q->next = new Node;
q = q->next;
q->coef = p1->coef + p2->coef;
q->expn = p1->expn;
p1 = p1->next;
p2 = p2->next;
}
}
while(p1!=NULL){
q->next = new Node;
q = q->next;
q->coef = p1->coef;
q->expn = p1->expn;
p1 = p1->next;
}
while(p2!=NULL){
q->next = new Node;
q = q->next;
q->coef = p2->coef;
q->expn = p2->expn;
p2 = p2->next;
}
q->next = NULL;
return head;
}

输出多项式的函数：可以遍历单链表，输出多项式。代码如下：

void print(Node *head){
Node *p = head->next;
while(p!=NULL){
cout<<p->coef<<"x^"<<p->expn;
p = p->next;
if(p!=NULL) cout<<"+";
}
cout<<endl;
}

综合所有函数，可以实现多项式的存储、相加和输出。下面是完整的代码：