onde cada elemento i da lista deve armazenar o n-ésimo termo do polinômio (diferente de 0). Cada item da lista deve conter o valor da potência de (inteiro) e o coeficiente correspondente (inteiro). Faça funções para
(a) Inicializar um polinômio.
(b) Inserir um novo termo no polinômio existente
© Imprimir
(d) Eliminar o termo associado à n-ésima potência
(e) Reinicializar um polinômio

Passo 1

Primeiro, vamos resumir o que o exercício pede: queremos representar um polinômio armazenando apenas os termos de coeficiente diferente de zero. Cada termo guarda dois inteiros – o expoente e o coeficiente – e todos os termos ficam ligados em uma lista encadeada. Precisamos de funções em C para (a) inicializar essa lista, (b) inserir um novo termo, © imprimir o polinômio, (d) eliminar o termo de um dado expoente e (e) reinicializar (limpar) todo o polinômio.

Passo 2

Para começar, definimos uma struct chamada PolyNode que representa um nó da lista. Cada nó tem um campo inteiro para o coeficiente, outro para o expoente e um ponteiro para o próximo nó. A inicialização do polinômio é simplesmente atribuir NULL ao ponteiro para o primeiro nó.

Passo 3

A inserção de termo envolve três casos principais: se já existir um nó com aquele expoente, somamos os coeficientes; se o coeficiente resultante for zero, removemos o nó; caso contrário, criamos um novo nó na posição ordenada por expoente (por convenção, podemos manter a lista em ordem decrescente de expoente).

Passo 4

Para imprimir, basta percorrer a lista do primeiro ao último nó e montar a forma textual clássica do polinômio, cuidando dos sinais.

Passo 5

Para eliminar um termo de expoente n, percorremos a lista, achamos o nó com expoente n e ligamos o anterior ao próximo, liberando o nó.

Passo 6

Reinicializar o polinômio significa percorrer toda a lista, liberando cada nó e, ao final, deixar o ponteiro de início em NULL.

Passo 7

Agora, o código completo das funções em C:

Resposta

#include <stdio.h>
#include <stdlib.h>
// Definição do nó da lista de termos
typedef struct PolyNode {
int coeff; // coeficiente
int power; // expoente
struct PolyNode *next;
} PolyNode;
// (a) Inicializar um polinômio: retorna ponteiro para lista vazia
PolyNode* initPolynomial() {
return NULL;
}
// (b) Inserir um novo termo no polinômio existente
PolyNode* insertTerm(PolyNode *head, int coeff, int power) {
if (coeff == 0) return head; // termos de coeficiente zero não entram
PolyNode *prev = NULL, *curr = head;
// procura posição: manter lista em ordem decrescente de expoente
while (curr != NULL && curr->power > power) {
    prev = curr;
    curr = curr->next;
}
// se achou termo com mesmo expoente, soma coeficientes
if (curr != NULL && curr->power == power) {
    curr->coeff += coeff;
    if (curr->coeff == 0) {
        // remove nó
        if (prev) prev->next = curr->next;
        else head = curr->next;
        free(curr);
    }
} else {
    // cria novo nó e insere
    PolyNode *node = (PolyNode*) malloc(sizeof(PolyNode));
    node->coeff = coeff;
    node->power = power;
    node->next = curr;
    if (prev) prev->next = node;
    else head = node;
}
return head;
}
// © Imprimir o polinômio no formato clássico
void printPolynomial(PolyNode *head) {
if (!head) {
printf(“0\n”);
return;
}
PolyNode *p = head;
int first = 1;
while § {
// sinal e coeficiente
if (!first) printf(p->coeff > 0 ? " + " : " - “);
else if (p->coeff < 0) printf(”-");
// valor absoluto do coeficiente
int absC = p->coeff < 0 ? -p->coeff : p->coeff;
// coeficiente 1 só aparece se power==0
if (absC != 1 || p->power == 0) printf("%d", absC);
if (p->power != 0) {
printf(“x”);
if (p->power != 1) printf("^%d", p->power);
}
first = 0;
p = p->next;
}
printf("\n");
}
// (d) Eliminar o termo associado ao expoente power
PolyNode* deleteTerm(PolyNode *head, int power) {
PolyNode *prev = NULL, *curr = head;
while (curr && curr->power != power) {
prev = curr;
curr = curr->next;
}
if (curr) {
if (prev) prev->next = curr->next;
else head = curr->next;
free(curr);
}
return head;
}
// (e) Reinicializar o polinômio: libera toda a lista e retorna NULL
PolyNode* resetPolynomial(PolyNode *head) {
PolyNode *curr = head;
while (curr) {
PolyNode *tmp = curr;
curr = curr->next;
free(tmp);
}
return NULL;
}
// Exemplo de uso
int main() {
PolyNode *poly = initPolynomial();
poly = insertTerm(poly, 3, 4); // 3x^4
poly = insertTerm(poly, -2, 2); // -2x^2
poly = insertTerm(poly, 5, 0); // +5
printPolynomial(poly); // imprime 3x^4 - 2x^2 + 5
poly = deleteTerm(poly, 2); // remove termo x^2
printPolynomial(poly); // imprime 3x^4 + 5
poly = resetPolynomial(poly); // limpa tudo
printPolynomial(poly); // imprime 0
return 0;
}

Exercícios relacionados