按照升幂排列的一元多项式P n ​ (x)=p 1 ​ x+p 2 ​ x 2 +⋯+p n ​ x n 可以用线性表来表示P=(p 1 ​ ,p 2 ​ ,…,p n ​ )，对于一元多项式各种操作，实际上可以利用线性表来处理。若多项式的非零项指数很高并且非零项很少称之为稀疏多项式，此时使用链式存储结构较为方便。设计一个程序，实现一元稀疏多项式简单计算器。

好的，我可以帮你实现这个程序。这个简单计算器主要包含以下几个功能：

1. 多项式的创建和输入
2. 多项式的输出
3. 多项式的加法
4. 多项式的减法
5. 多项式的乘法

我们可以使用链表来存储多项式，每个节点包含三个属性：系数、指数和指向下一个节点的指针。下面是具体的实现过程：

首先，我们定义一个结构体来表示多项式的每一项：

struct PolyNode {
    double coef;
    int expo;
    PolyNode* next;
};

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

接下来，我们实现多项式的创建和输入函数：

PolyNode* createPoly() {
    PolyNode* head = new PolyNode();
    head->next = NULL;
    PolyNode* tail = head;
    int n;
    cout << "请输入多项式的项数：";
    cin >> n;
    for (int i = 0; i < n; i++) {
        double coef;
        int expo;
        cout << "请输入第" << i + 1 << "项的系数和指数：";
        cin >> coef >> expo;
        PolyNode* node = new PolyNode();
        node->coef = coef;
        node->expo = expo;
        node->next = NULL;
        tail->next = node;
        tail = node;
    }
    return head;
}

这个函数中，我们首先创建一个头节点，然后输入多项式的项数，接着循环输入每一项的系数和指数，创建一个节点并加入链表中，最后返回头节点。

接下来，我们实现多项式的输出函数：

void printPoly(PolyNode* poly) {
    PolyNode* p = poly->next;
    while (p) {
        cout << p->coef << "x^" << p->expo;
        if (p->next != NULL) {
            cout << " + ";
        }
        p = p->next;
    }
    cout << endl;
}

这个函数中，我们遍历链表中的每一个节点，输出节点的系数和指数，如果不是最后一项则输出“+”，最后换行。

接下来，我们实现多项式的加法函数：

PolyNode* addPoly(PolyNode* poly1, PolyNode* poly2) {
    PolyNode* head = new PolyNode();
    head->next = NULL;
    PolyNode* tail = head;
    PolyNode* p1 = poly1->next;
    PolyNode* p2 = poly2->next;
    while (p1 && p2) {
        if (p1->expo == p2->expo) {
            double coef = p1->coef + p2->coef;
            if (coef != 0) {
                PolyNode* node = new PolyNode();
                node->coef = coef;
                node->expo = p1->expo;
                node->next = NULL;
                tail->next = node;
                tail = node;
            }
            p1 = p1->next;
            p2 = p2->next;
        } else if (p1->expo > p2->expo) {
            PolyNode* node = new PolyNode();
            node->coef = p1->coef;
            node->expo = p1->expo;
            node->next = NULL;
            tail->next = node;
            tail = node;
            p1 = p1->next;
        } else {
            PolyNode* node = new PolyNode();
            node->coef = p2->coef;
            node->expo = p2->expo;
            node->next = NULL;
            tail->next = node;
            tail = node;
            p2 = p2->next;
        }
    }
    while (p1) {
        PolyNode* node = new PolyNode();
        node->coef = p1->coef;
        node->expo = p1->expo;
        node->next = NULL;
        tail->next = node;
        tail = node;
        p1 = p1->next;
    }
    while (p2) {
        PolyNode* node = new PolyNode();
        node->coef = p2->coef;
        node->expo = p2->expo;
        node->next = NULL;
        tail->next = node;
        tail = node;
        p2 = p2->next;
    }
    return head;
}

这个函数中，我们首先创建一个头节点，然后遍历两个多项式的链表，比较当前节点的指数大小，如果相等则将系数相加，如果不相等则将指数较小的节点加入链表。最后将剩余的节点加入链表中，返回头节点。

接下来，我们实现多项式的减法函数：

PolyNode* subPoly(PolyNode* poly1, PolyNode* poly2) {
    PolyNode* head = new PolyNode();
    head->next = NULL;
    PolyNode* tail = head;
    PolyNode* p1 = poly1->next;
    PolyNode* p2 = poly2->next;
    while (p1 && p2) {
        if (p1->expo == p2->expo) {
            double coef = p1->coef - p2->coef;
            if (coef != 0) {
                PolyNode* node = new PolyNode();
                node->coef = coef;
                node->expo = p1->expo;
                node->next = NULL;
                tail->next = node;
                tail = node;
            }
            p1 = p1->next;
            p2 = p2->next;
        } else if (p1->expo > p2->expo) {
            PolyNode* node = new PolyNode();
            node->coef = p1->coef;
            node->expo = p1->expo;
            node->next = NULL;
            tail->next = node;
            tail = node;
            p1 = p1->next;
        } else {
            PolyNode* node = new PolyNode();
            node->coef = -p2->coef;
            node->expo = p2->expo;
            node->next = NULL;
            tail->next = node;
            tail = node;
            p2 = p2->next;
        }
    }
    while (p1) {
        PolyNode* node = new PolyNode();
        node->coef = p1->coef;
        node->expo = p1->expo;
        node->next = NULL;
        tail->next = node;
        tail = node;
        p1 = p1->next;
    }
    while (p2) {
        PolyNode* node = new PolyNode();
        node->coef = -p2->coef;
        node->expo = p2->expo;
        node->next = NULL;
        tail->next = node;
        tail = node;
        p2 = p2->next;
    }
    return head;
}

这个函数和加法函数类似，只是将节点的系数相减，如果一个多项式已经遍历完了，那么把另一个多项式的剩余节点全部取相反数加入链表中。

最后，我们实现多项式的乘法函数：

PolyNode* mulPoly(PolyNode* poly1, PolyNode* poly2) {
    PolyNode* head = new PolyNode();
    head->next = NULL;
    PolyNode* tail = head;
    PolyNode* p1 = poly1->next;
    while (p1) {
        PolyNode* p2 = poly2->next;
        while (p2) {
            double coef = p1->coef * p2->coef;
            int expo = p1->expo + p2->expo;
            PolyNode* p = head->next;
            PolyNode* prev = head;
            while (p && p->expo > expo) {
                prev = p;
                p = p->next;
            }
            if (p && p->expo == expo) {
                p->coef += coef;
            } else {
                PolyNode* node = new PolyNode();
                node->coef = coef;
                node->expo = expo;
                node->next = p;
                prev->next = node;
            }
            p2 = p2->next;
        }
        p1 = p1->next;
    }
    return head;
}

这个函数中，我们首先创建一个头节点，然后遍历两个多项式的链表，分别取出每一项的系数和指数，计算它们的乘积，然后遍历结果链表，找到乘积的指数所在的位置，如果已经存在这个指数，则将系数相加，否则插入一个新节点。

至此，一元稀疏多项式简单计算器的实现就完成了。你可以将这些函数放在一个类中，并添加一个菜单功能，让用户选择要执行的操作。