用c写一个一元稀疏多项式简单的计算器

好的，我可以回答这个问题。你可以使用链表来存储一元稀疏多项式，每个节点包含系数和指数。然后，你可以按照指数从小到大的顺序在链表中遍历多项式，进行加减乘法等操作。在用户输入多项式时，你可以使用 scanf 函数来解析输入，然后将结果存储到链表中。最后，你可以使用 printf 函数来输出计算结果。希望这个回答可以帮到你！

相关问题

一元稀疏多项式计算器c语言xdoj

一元稀疏多项式计算器是一个使用C语言编写的程序，用于进行一元稀疏多项式的计算。

该计算器的输入是一个一元稀疏多项式，包含多个项，每个项由系数和幂次组成。在C语言中，可以使用结构体来表示每个项，例如定义一个结构体PolynomialTerm，包含两个成员变量：coeff用于表示系数，exponent用于表示幂次。

计算器通过以下步骤来进行计算：

1. 首先，程序会要求用户输入一元稀疏多项式的项数n。
2. 然后，程序会使用一个循环，让用户逐个输入每个项的系数和幂次，并将这些数据保存到一个数组或链表中。在循环中，使用scanf函数读取用户输入的数据，并将数据存储到PolynomialTerm结构体的成员变量中。
3. 输入完所有项后，程序会根据用户的选择进行相应的操作，例如计算多项式的和、差、积等。可以使用一个switch语句来根据用户的选择执行相应的操作。
4. 在计算和、差、积等操作时，程序将遍历保存多项式数据的数组或链表，并根据每个项的系数和幂次，进行相应的计算。可以使用for循环来遍历数组或链表中的每一个项。
5. 最后，程序会输出计算结果，并询问用户是否要继续进行其他计算。可以使用printf函数来输出结果，使用scanf函数来接收用户的选择。

总的来说，一元稀疏多项式计算器是通过用户输入一元稀疏多项式的项数和每个项的系数和幂次，进行相应的计算并输出结果的程序。它使用C语言编写，运用了结构体、循环和条件语句等基本编程概念来实现功能。

按照升幂排列的一元多项式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;
}

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