void insert(PolyNode **head, int coef, int expon) { Term *new_node = (PolyNode*)malloc(sizeof(PolyNode)); new_node->coef = coef; new_node->expon = expon; new_node->next = *head; *head = new_node; } void print_poly(PolyNode *head) { PolyNode *p = head; while (p != NULL) { if (p->coef > 0) { printf("+"); } printf("%dx^%d", p->coef, p->expon); p = p->next; } } void print_poly_desc(PolyNode *head) { PolyNode *p = head; int count = 0; while (p != NULL) { count++; p = p->next; } PolyNode *arr[count]; p = head; int i = 0; while (p != NULL) { arr[i] = p; p = p->next; i++; } for (int j = 0; j < count; j++) { for (int k = j + 1; k < count; k++) { if (arr[j]->expon < arr[k]->expon) { PolyNode *temp = arr[j]; arr[j] = arr[k]; arr[k] = temp; } } if (arr[j]->coef > 0) { printf("+"); } printf("%dx^%d", arr[j]->coef, arr[j]->expon); } }

这段代码定义了两个函数，`insert` 和 `print_poly_desc`，分别用于向多项式中插入一项和按指数从大到小输出多项式。

函数 `insert` 的参数是一个二级指针 `head`，表示多项式的头指针。函数中创建一个新的多项式节点，并将其插入到链表的头部。

函数 `print_poly` 的参数是一个一级指针 `head`，表示多项式的头指针。函数中遍历多项式链表，按照一定的格式输出多项式每一项的系数和指数。

函数 `print_poly_desc` 的参数也是一个一级指针 `head`，表示多项式的头指针。函数中首先遍历多项式链表，计算链表中节点的个数，并将所有节点保存到一个数组中。然后，按照指数从大到小的顺序对数组进行排序，并输出多项式每一项的系数和指数。

需要注意的是，函数 `print_poly` 和 `print_poly_desc` 都使用了 `if (p->coef > 0) { printf("+"); }` 这行代码，是为了在系数为正数时输出加号。

相关问题

/*主函数模块*/ int main() { H=AddPolylist(); ComputePolylist(H); OutputPolylist(H); DestroyPolylist(H); return 0; } /* 请在这里填写答案 */ /*单链表模块*/ void InitPolylist(Polylist *L) { } Polylist CreatePolylist()/*输入多项式的系数和指数,用尾插法建立一元多项式的链表*/ { } int LengthPolylist(Polylist L) { } void OutputPolylist(Polylist L) { } Polylist AddPolylist()/*创建两个多项式并相加，完成后显示序列*/ { } void ComputePolylist(Polylist L)/*计算多项式在x=%d的值*/ { } void DestroyPolylist(Polylist L) { }

/*主函数模块*/
int main() {
Polylist H;
H = AddPolylist();
ComputePolylist(H);
OutputPolylist(H);
DestroyPolylist(H);
return 0;
}

/*单链表模块*/
void InitPolylist(Polylist *L) {
*L = (Polylist)malloc(sizeof(struct PolyNode));
(*L)->next = NULL;
}

Polylist CreatePolylist()/*输入多项式的系数和指数,用尾插法建立一元多项式的链表*/ {
Polylist L, rear, t;
int c, e;

InitPolylist(&L);
rear = L;
scanf("%d", &c);
scanf("%d", &e);
while(e != -1) {
t = (Polylist)malloc(sizeof(struct PolyNode));
t->coef = c;
t->expon = e;
t->next = NULL;
rear->next = t;
rear = t;

scanf("%d", &c);
scanf("%d", &e);
}

return L;
}

int LengthPolylist(Polylist L) {
int len = 0;
while(L->next) {
len++;
L = L->next;
}
return len;
}

void OutputPolylist(Polylist L) {
int len = LengthPolylist(L);
printf("%d ", len);
L = L->next;
while(L) {
printf("%d %d ", L->coef, L->expon);
L = L->next;
}
printf("\n");
}

Polylist AddPolylist()/*创建两个多项式并相加，完成后显示序列*/ {
Polylist A, B, C, rear;
int lenA, lenB, sum;

A = CreatePolylist();
B = CreatePolylist();
InitPolylist(&C);
rear = C;

while(A->next && B->next) {
if(A->next->expon > B->next->expon) {
rear->next = A->next;
A = A->next;
} else if(A->next->expon < B->next->expon) {
rear->next = B->next;
B = B->next;
} else {
sum = A->next->coef + B->next->coef;
if(sum) {
A->next->coef = sum;
rear->next = A->next;
A = A->next;
B = B->next;
} else {
A = A->next;
B = B->next;
}
}
rear = rear->next;
}

while(A->next) {
rear->next = A->next;
A = A->next;
rear = rear->next;
}
while(B->next) {
rear->next = B->next;
B = B->next;
rear = rear->next;
}

return C;
}

void ComputePolylist(Polylist L)/*计算多项式在x=%d的值*/ {
int x, sum = 0;
scanf("%d", &x);
while(L->next) {
sum += L->next->coef * pow(x, L->next->expon);
L = L->next;
}
printf("%d\n", sum);
}

void DestroyPolylist(Polylist L) {
Polylist temp;
while(L) {
temp = L;
L = L->next;
free(temp);
}
}

按照升幂排列的一元多项式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） 计算多项式在x处的值。使用C语言

实现一个一元稀疏多项式简单计算器的程序可以分为以下几个步骤：

1. 定义结构体表示多项式的每一项，并定义链式存储结构。

typedef struct PolyNode *PtrToNode;
struct PolyNode {
    int coef; // 系数
    int expon; // 指数
    PtrToNode next; // 指向下一项的指针
};
typedef PtrToNode Polynomial;

2. 实现函数输入并建立多项式。可以使用链表的插入操作，按照指数从小到大的顺序插入每一项。

Polynomial ReadPoly() {
    Polynomial P, rear, t;
    int c, e;

    P = (Polynomial)malloc(sizeof(struct PolyNode));
    P->next = NULL;
    rear = P;

    scanf("%d", &c);
    scanf("%d", &e);
    while(e != -1) {
        t = (Polynomial)malloc(sizeof(struct PolyNode));
        t->coef = c;
        t->expon = e;
        t->next = NULL;
        rear->next = t;
        rear = t;

        scanf("%d", &c);
        scanf("%d", &e);
    }

    return P;
}

3. 实现函数输出多项式，在链表中遍历每一项，按照指数从小到大的顺序输出系数和指数。

void PrintPoly(Polynomial P) {
    if(!P->next) {
        printf("0 0\n");
        return;
    }

    printf("%d ", Length(P));
    P = P->next;
    while(P) {
        printf("%d %d", P->coef, P->expon);
        P = P->next;
        if(P) printf(" ");
    }
    printf("\n");
}

4. 实现函数多项式相加，可以使用链表的归并操作，按照指数从小到大的顺序合并两个多项式。

Polynomial Add(Polynomial P1, Polynomial P2) {
    Polynomial front, rear, temp;
    int sum;

    front = (Polynomial)malloc(sizeof(struct PolyNode));
    rear = front;

    while(P1 && P2) {
        if(P1->expon > P2->expon) {
            rear->next = P1;
            rear = P1;
            P1 = P1->next;
        } else if(P1->expon < P2->expon) {
            rear->next = P2;
            rear = P2;
            P2 = P2->next;
        } else {
            sum = P1->coef + P2->coef;
            if(sum) {
                temp = (Polynomial)malloc(sizeof(struct PolyNode));
                temp->coef = sum;
                temp->expon = P1->expon;
                rear->next = temp;
                rear = temp;
            }
            P1 = P1->next;
            P2 = P2->next;
        }
    }

    for(; P1; P1 = P1->next) {
        rear->next = P1;
        rear = P1;
    }
    for(; P2; P2 = P2->next) {
        rear->next = P2;
        rear = P2;
    }

    rear->next = NULL;
    temp = front;
    front = front->next;
    free(temp);
    return front;
}

5. 实现函数计算多项式在x处的值，使用指数与系数的积累加即可。

int Calc(Polynomial P, int x) {
    int sum = 0;
    while(P) {
        sum += P->coef * pow(x, P->expon);
        P = P->next;
    }
    return sum;
}

完整代码如下：