Fazer uma função que copia uma lista L1 em outra L2, eliminando os elementos repetidos.
Passo 1
O enunciado pede para criar uma função que, dadas duas listas ligadas L1 e L2, copia todos os elementos de L1 para L2 eliminando os duplicados. O conteúdo envolve manipulação de lista ligada (inserção, pesquisa) e lógica para evitar repetir valores.
Passo 2
Primeiro vamos precisar de uma função que verifique se um valor já está presente em uma lista. Ela percorre a lista ligada e compara cada nó com o valor buscado. Se encontrar, retorna verdadeiro; senão, falso.
Passo 3
Em seguida, precisamos de uma função para inserir um novo nó ao final da lista. Essa rotina recebe um ponteiro para o ponteiro do início da lista e o valor a inserir, cria o nó e o anexa no final.
Passo 4
Agora podemos implementar a função de cópia sem repetidos. Ela recebe um ponteiro para L1 e um ponteiro para ponteiro de L2 (para inicializar L2 dentro da função).
Dentro dessa função, inicializamos L2 como vazia. Depois, percorremos cada nó de L1, e para cada valor verificamos se ele já pertence a L2. Se não pertencer, chamamos a rotina de inserção ao final de L2.
Quando terminar o laço de L1, L2 estará preenchida com todos os valores de L1, mas sem repetições. Pronto: a cópia com eliminação de duplicados foi feita.
Dentro dessa função, inicializamos L2 como vazia. Depois, percorremos cada nó de L1, e para cada valor verificamos se ele já pertence a L2. Se não pertencer, chamamos a rotina de inserção ao final de L2.
Quando terminar o laço de L1, L2 estará preenchida com todos os valores de L1, mas sem repetições. Pronto: a cópia com eliminação de duplicados foi feita.
Passo 5
Como resultado final, temos três funções auxiliares e a função principal de cópia. A L2 é construída dinamicamente sem elementos duplicados.
Resposta
// Definição do nó da lista
typedef struct Node {
int info;
struct Node *next;
} Node;
typedef struct Node {
int info;
struct Node *next;
} Node;
// Verifica se x pertence à lista L. Retorna 1 se pertence, 0 caso contrário.
int pertence(Node *L, int x) {
Node *p = L;
while (p != NULL) {
if (p->info == x)
return 1;
p = p->next;
}
return 0;
}
int pertence(Node *L, int x) {
Node *p = L;
while (p != NULL) {
if (p->info == x)
return 1;
p = p->next;
}
return 0;
}
// Insere um novo nó com valor x ao final da lista apontada por Lref.
void insere_fim(Node **Lref, int x) {
Node *novo = malloc(sizeof(Node));
novo->info = x;
novo->next = NULL;
if (*Lref == NULL) {
*Lref = novo;
} else {
Node *p = *Lref;
while (p->next != NULL)
p = p->next;
p->next = novo;
}
}
void insere_fim(Node **Lref, int x) {
Node *novo = malloc(sizeof(Node));
novo->info = x;
novo->next = NULL;
if (*Lref == NULL) {
*Lref = novo;
} else {
Node *p = *Lref;
while (p->next != NULL)
p = p->next;
p->next = novo;
}
}
// Copia todos os elementos de L1 para L2 eliminando duplicados.
// L2 deve ser um ponteiro para ponteiro e ficará inicializada dentro da função.
void copiar_sem_repetidos(Node *L1, Node **L2) {
*L2 = NULL; // inicializa L2 vazia
Node *p = L1;
while (p != NULL) {
if (!pertence(*L2, p->info)) {
insere_fim(L2, p->info);
}
p = p->next;
}
}
// L2 deve ser um ponteiro para ponteiro e ficará inicializada dentro da função.
void copiar_sem_repetidos(Node *L1, Node **L2) {
*L2 = NULL; // inicializa L2 vazia
Node *p = L1;
while (p != NULL) {
if (!pertence(*L2, p->info)) {
insere_fim(L2, p->info);
}
p = p->next;
}
}