编写一个单链表存储多项式 并实现两个一元多项式A与B相加的函数。A与B刚开始是无序的，A与B之和按降序排列

好的，我来为您解答这个问题。

首先，我们需要定义一个单链表结构体来存储多项式。每个节点中包含两个数据成员，一个是系数 coefficient，一个是指数 exponent。我们可以这样定义：

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

接下来，我们可以编写一个函数来创建一个多项式链表。输入参数是一个数组，数组中的元素依次表示多项式的各项系数，从常数项开始，直到最高次项。例如，输入数组 {1, 2, 3} 表示多项式 3x^2 + 2x + 1。

Node* create_polynomial(int* coeffs, int n) {
    Node* head = new Node;
    head->coefficient = coeffs[0];
    head->exponent = n - 1;
    head->next = nullptr;

    Node* p = head;
    for (int i = 1; i < n; i++) {
        Node* q = new Node;
        q->coefficient = coeffs[i];
        q->exponent = n - i - 1;
        q->next = nullptr;

        p->next = q;
        p = q;
    }

    return head;
}

接下来，我们可以编写一个函数来将两个多项式相加。我们可以先将两个多项式拼接成一个链表，然后对这个链表按照指数从大到小排序，最后再合并同类项。

Node* merge(Node* A, Node* B) {
    if (A == nullptr) {
        return B;
    }
    if (B == nullptr) {
        return A;
    }

    Node* C;
    if (A->exponent >= B->exponent) {
        C = A;
        C->next = merge(A->next, B);
    } else {
        C = B;
        C->next = merge(A, B->next);
    }

    return C;
}

Node* sort(Node* head) {
    if (head == nullptr || head->next == nullptr) {
        return head;
    }

    Node* p = head;
    Node* q = head->next;
    head->next = nullptr;

    while (q != nullptr) {
        Node* r = q->next;
        if (q->exponent > head->exponent) {
            q->next = head;
            head = q;
        } else {
            p = head;
            while (p->next != nullptr && p->next->exponent > q->exponent) {
                p = p->next;
            }
            q->next = p->next;
            p->next = q;
        }
        q = r;
    }

    return head;
}

Node* add_polynomial(Node* A, Node* B) {
    Node* C = merge(A, B);
    C = sort(C);

    Node* p = C;
    while (p != nullptr && p->next != nullptr) {
        if (p->exponent == p->next->exponent) {
            p->coefficient += p->next->coefficient;
            Node* q = p->next;
            p->next = q->next;
            delete q;
        } else {
            p = p->next;
        }
    }

    return C;
}

最后，我们可以编写一个函数来打印一个多项式。

void print_polynomial(Node* head) {
    if (head == nullptr) {
        cout << "0" << endl;
        return;
    }

    Node* p = head;
    while (p != nullptr) {
        if (p->coefficient > 0 && p != head) {
            cout << "+";
        }
        cout << p->coefficient;
        if (p->exponent > 0) {
            cout << "x";
            if (p->exponent > 1) {
                cout << "^" << p->exponent;
            }
        }
        p = p->next;
    }
    cout << endl;
}

这样，我们就完成了单链表存储多项式，并实现了两个一元多项式相加的函数。