用线性表链表存储结构实现把任意给定的俩个一元多项式P（x），Q（x）输入计算机，计算他们的和并输出就算结果

好的，我可以提供一个基于线性表链表存储结构的实现思路，具体步骤如下：

1. 定义多项式的单项式结构体。每个单项式包含两个成员变量：系数和指数。

struct Term {
    double coef;  // 系数
    int exp;      // 指数
};

2. 定义链表节点结构体。每个节点包含一个单项式和一个指向下一个节点的指针。

struct Node {
    Term term;    // 单项式
    Node* next;   // 指向下一个节点的指针
};

3. 定义多项式链表类。该类包含两个链表头指针，分别对应两个多项式。

class PolyList {
public:
    PolyList() { head1 = head2 = nullptr; }
    void createList(Node*& head);   // 创建链表
    void printList(Node* head);     // 打印链表
    void addPoly(PolyList& Q);      // 多项式相加
private:
    Node *head1, *head2;            // 两个多项式的链表头指针
};

4. 实现创建链表的函数。该函数可以从输入中读取系数和指数，构造单项式并插入链表。

void PolyList::createList(Node*& head) {
    int coef, exp;
    Node* tail = nullptr;
    while (true) {
        cin >> coef >> exp;
        if (coef == 0 && exp == 0) { // 输入结束标志
            break;
        }
        Node* p = new Node;
        p->term.coef = coef;
        p->term.exp = exp;
        p->next = nullptr;
        if (head == nullptr) {
            head = tail = p;
        } else {
            tail->next = p;
            tail = p;
        }
    }
}

5. 实现打印链表的函数。该函数可以遍历链表，输出每个单项式的系数和指数。

void PolyList::printList(Node* head) {
    if (head == nullptr) {
        cout << "0 0" << endl;
        return;
    }
    while (head != nullptr) {
        cout << head->term.coef << " " << head->term.exp << " ";
        head = head->next;
    }
    cout << endl;
}

6. 实现多项式相加的函数。该函数可以遍历两个链表，将相同指数的单项式系数相加，构造新的链表。

void PolyList::addPoly(PolyList& Q) {
    Node *p = head1, *q = head2, *r = nullptr, *tail = nullptr;
    while (p != nullptr && q != nullptr) {
        Node* s = new Node;
        s->next = nullptr;
        if (p->term.exp < q->term.exp) {
            s->term.coef = p->term.coef;
            s->term.exp = p->term.exp;
            p = p->next;
        } else if (p->term.exp > q->term.exp) {
            s->term.coef = q->term.coef;
            s->term.exp = q->term.exp;
            q = q->next;
        } else {
            s->term.coef = p->term.coef + q->term.coef;
            s->term.exp = p->term.exp;
            p = p->next;
            q = q->next;
        }
        if (r == nullptr) {
            r = tail = s;
        } else {
            tail->next = s;
            tail = s;
        }
    }
    while (p != nullptr) {
        Node* s = new Node;
        s->term.coef = p->term.coef;
        s->term.exp = p->term.exp;
        s->next = nullptr;
        tail->next = s;
        tail = s;
        p = p->next;
    }
    while (q != nullptr) {
        Node* s = new Node;
        s->term.coef = q->term.coef;
        s->term.exp = q->term.exp;
        s->next = nullptr;
        tail->next = s;
        tail = s;
        q = q->next;
    }
    printList(r);
}

7. 在主函数中调用上述函数，读入两个多项式，调用相加函数计算它们的和并输出。

int main() {
    PolyList P, Q;
    P.createList(P.head1);
    Q.createList(Q.head1);
    P.addPoly(Q);
    return 0;
}

以上就是一个基于线性表链表存储结构的实现思路，可以实现把任意给定的俩个一元多项式P（x），Q（x）输入计算机，计算他们的和并输出就算结果。