按照升幂排列的一元多项式P n ​ (x)=p 1 ​ x+p 2 ​ x 2 +⋯+p n ​ x n 可以用线性表来表示P=(p 1 ​ ,p 2 ​ ,…,p n ​ )，对于一元多项式各种操作，实际上可以利用线性表来处理。若多项式的非零项指数很高并且非零项很少称之为稀疏多项式，此时使用链式存储结构较为方便。设计一个程序，实现一元稀疏多项式简单计算器。 基本要求 稀疏多项式简单计算器的基本功能是： （1）输入并建立多项式； （2）输出多项式，输出形式为整数序列：n,p 1 ​ ,e 1 ​ ,p 2 ​ ,e 2 ​ …,p n ​ ,e n ​ ，其中n是多项式的项数，p i ​ 和e i ​ 分别是第i项的系数和指数，序列按指数升幂排列； （3） 多项式a和b相加，建立多项式a+b； （4） 多项式a和c相减，建立多项式a-b； （5） 计算多项式在x处的值。 测试数据 （1）(x+x 2 +x 3 )+(x+x 2 )=(2x+2x 2 +x 3 ) （2） 当x=1，多项式(2x+2x 2 +x 3 )=5 （3）计算完成后销毁多项式

好的，我会尽力回答你的问题。这是一个基于链式存储结构的一元稀疏多项式简单计算器程序的设计，主要包括输入并建立多项式、输出多项式、多项式相加、多项式相减和计算多项式在x处的值等功能。

（1）输入并建立多项式

首先，我们需要定义一个多项式结构体，用于表示一元稀疏多项式。

typedef struct node {
    int coef;  // 系数
    int exp;   // 指数
    struct node* next; // 下一项
} PolyNode, *PolyPtr;

然后，我们可以通过输入系数和指数来建立多项式。

PolyPtr CreatePoly(int n) {
    PolyPtr head = (PolyPtr)malloc(sizeof(PolyNode));
    head->next = NULL;
    PolyPtr tail = head;
    for (int i = 1; i <= n; i++) {
        int coef, exp;
        scanf("%d %d", &coef, &exp);
        PolyPtr node = (PolyPtr)malloc(sizeof(PolyNode));
        node->coef = coef;
        node->exp = exp;
        node->next = NULL;
        tail->next = node;
        tail = node;
    }
    return head;
}

这个函数会返回一个多项式的头结点指针。

（2）输出多项式

为了输出多项式，我们需要将多项式中的每一项按照指数升幂排列。因此，我们需要先实现一个插入函数，将一项插入到多项式中的正确位置。

void InsertTerm(PolyPtr head, int coef, int exp) {
    PolyPtr node = (PolyPtr)malloc(sizeof(PolyNode));
    node->coef = coef;
    node->exp = exp;
    node->next = NULL;
    PolyPtr prev = head;
    PolyPtr curr = prev->next;
    while (curr != NULL && curr->exp < exp) {
        prev = curr;
        curr = curr->next;
    }
    if (curr != NULL && curr->exp == exp) {
        curr->coef += coef;
        if (curr->coef == 0) {
            prev->next = curr->next;
            free(curr);
        }
    } else {
        node->next = curr;
        prev->next = node;
    }
}

然后，我们可以遍历多项式中的每一项，调用插入函数将其插入到正确的位置。

void PrintPoly(PolyPtr head) {
    PolyPtr curr = head->next;
    int n = 0;
    while (curr != NULL) {
        InsertTerm(head, curr->coef, curr->exp);
        n++;
        curr = curr->next;
    }
    printf("%d", n);
    curr = head->next;
    while (curr != NULL) {
        printf(" %d %d", curr->coef, curr->exp);
        curr = curr->next;
    }
    printf("\n");
}

这个函数会输出多项式的整数序列，按照指数升幂排列。

（3）多项式相加

多项式相加的方法很简单，我们只需要遍历两个多项式，将相同指数的项相加，然后插入到一个新的多项式中。

PolyPtr AddPoly(PolyPtr a, PolyPtr b) {
    PolyPtr c = (PolyPtr)malloc(sizeof(PolyNode));
    c->next = NULL;
    PolyPtr tail = c;
    PolyPtr pa = a->next;
    PolyPtr pb = b->next;
    while (pa != NULL && pb != NULL) {
        if (pa->exp < pb->exp) {
            tail->next = pa;
            tail = pa;
            pa = pa->next;
        } else if (pa->exp > pb->exp) {
            tail->next = pb;
            tail = pb;
            pb = pb->next;
        } else {
            int coef = pa->coef + pb->coef;
            if (coef != 0) {
                PolyPtr node = (PolyPtr)malloc(sizeof(PolyNode));
                node->coef = coef;
                node->exp = pa->exp;
                node->next = NULL;
                tail->next = node;
                tail = node;
            }
            pa = pa->next;
            pb = pb->next;
        }
    }
    while (pa != NULL) {
        tail->next = pa;
        tail = pa;
        pa = pa->next;
    }
    while (pb != NULL) {
        tail->next = pb;
        tail = pb;
        pb = pb->next;
    }
    return c;
}

这个函数会返回一个新的多项式，表示a+b。

（4）多项式相减

多项式相减的方法和多项式相加类似，只需要将b中每一项的系数取相反数，然后再调用多项式相加的函数。

PolyPtr SubPoly(PolyPtr a, PolyPtr b) {
    PolyPtr c = (PolyPtr)malloc(sizeof(PolyNode));
    c->next = NULL;
    PolyPtr pb = b->next;
    while (pb != NULL) {
        pb->coef = -pb->coef;
        pb = pb->next;
    }
    c = AddPoly(a, b);
    pb = b->next;
    while (pb != NULL) {
        pb->coef = -pb->coef;
        pb = pb->next;
    }
    return c;
}

这个函数会返回一个新的多项式，表示a-b。

（5）计算多项式在x处的值

计算多项式在x处的值的方法很简单，只需要遍历多项式，根据每一项的系数和指数计算出对应的值，然后累加即可。

int CalcPoly(PolyPtr head, int x) {
    int sum = 0;
    PolyPtr curr = head->next;
    while (curr != NULL) {
        sum += curr->coef * pow(x, curr->exp);
        curr = curr->next;
    }
    return sum;
}

这个函数会返回多项式在x处的值。

最后，我们需要在程序中调用这些函数，实现多项式的输入、输出、相加、相减和计算值等操作。

int main() {
    int n, m, x;
    scanf("%d", &n);
    PolyPtr a = CreatePoly(n);
    PrintPoly(a);
    scanf("%d", &m);
    PolyPtr b = CreatePoly(m);
    PrintPoly(b);
    PolyPtr c = AddPoly(a, b);
    PrintPoly(c);
    PolyPtr d = SubPoly(a, b);
    PrintPoly(d);
    scanf("%d", &x);
    printf("%d\n", CalcPoly(a, x));
    printf("%d\n", CalcPoly(b, x));
    printf("%d\n", CalcPoly(c, x));
    printf("%d\n", CalcPoly(d, x));
    return 0;
}

这样，我们就完成了一元稀疏多项式简单计算器的设计。