0Pricing
C Academy · Aula

Listas duplamente encadeadas

Ligações nos dois sentidos.

Listas duplamente encadeadas é uma aula grátis de C Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C Academy inclui 4 aulas no total.

Ligações nos dois sentidos

Uma lista duplamente encadeada fornece a cada nó dois ponteiros: um para o nó next e outro para o nó prev (anterior).

Isso permite percorrer a lista nos dois sentidos e simplifica a remoção.

#include <stdio.h>

struct Node {
    int value;
    struct Node *prev;
    struct Node *next;
};

int main(void) {
    printf("Each node links forward and backward\n");
    return 0;
}

Definindo o nó

A estrutura adiciona um ponteiro prev ao lado de next. Ambos são NULL nas extremidades da lista.

#include <stdio.h>
#include <stdlib.h>

struct Node { int value; struct Node *prev; struct Node *next; };

int main(void) {
    struct Node *n = malloc(sizeof(struct Node));
    n->value = 1; n->prev = NULL; n->next = NULL;
    printf("%d\n", n->value);
    free(n);
    return 0;
}

Um auxiliar de criação

Como antes, uma função auxiliar centraliza a alocação. Ela define prev e next como NULL.

#include <stdio.h>
#include <stdlib.h>

struct Node { int value; struct Node *prev; struct Node *next; };

struct Node *make(int v) {
    struct Node *n = malloc(sizeof(struct Node));
    n->value = v; n->prev = NULL; n->next = NULL;
    return n;
}

int main(void) {
    struct Node *n = make(42);
    printf("%d\n", n->value);
    free(n);
    return 0;
}

Conectando nós nos dois sentidos

Ao conectar dois nós, você precisa atualizar ambos os sentidos: o next do primeiro nó e o prev do segundo.

#include <stdio.h>
#include <stdlib.h>

struct Node { int value; struct Node *prev; struct Node *next; };
struct Node *make(int v){struct Node*n=malloc(sizeof*n);n->value=v;n->prev=NULL;n->next=NULL;return n;}

int main(void) {
    struct Node *a = make(1), *b = make(2);
    a->next = b;
    b->prev = a;
    printf("forward %d, back %d\n", a->next->value, b->prev->value);
    free(a); free(b);
    return 0;
}

Inserir no início

Ao inserir no início, o next do novo nó recebe a cabeça antiga, o prev da cabeça antiga recebe o novo nó e, então, a cabeça passa a apontar para o novo nó.

#include <stdio.h>
#include <stdlib.h>

struct Node { int value; struct Node *prev; struct Node *next; };
struct Node *make(int v){struct Node*n=malloc(sizeof*n);n->value=v;n->prev=NULL;n->next=NULL;return n;}

void push(struct Node **head, int v) {
    struct Node *n = make(v);
    n->next = *head;
    if (*head) (*head)->prev = n;
    *head = n;
}

int main(void) {
    struct Node *head = NULL;
    push(&head, 2); push(&head, 1);
    printf("%d %d\n", head->value, head->next->value);
    return 0;
}

Percurso para a frente

Percorrer para a frente é idêntico ao caso de uma lista simplesmente encadeada: siga next até NULL.

#include <stdio.h>
#include <stdlib.h>

struct Node { int value; struct Node *prev; struct Node *next; };
struct Node *make(int v){struct Node*n=malloc(sizeof*n);n->value=v;n->prev=NULL;n->next=NULL;return n;}

int main(void) {
    struct Node *a = make(1), *b = make(2);
    a->next = b; b->prev = a;
    for (struct Node *p = a; p; p = p->next) printf("%d ", p->value);
    printf("\n");
    free(a); free(b);
    return 0;
}

Percurso para trás

A grande vantagem é que, a partir de qualquer nó, você pode percorrer para trás seguindo os ponteiros prev até chegar à cabeça.

#include <stdio.h>
#include <stdlib.h>

struct Node { int value; struct Node *prev; struct Node *next; };
struct Node *make(int v){struct Node*n=malloc(sizeof*n);n->value=v;n->prev=NULL;n->next=NULL;return n;}

int main(void) {
    struct Node *a = make(1), *b = make(2), *c = make(3);
    a->next = b; b->prev = a; b->next = c; c->prev = b;
    for (struct Node *p = c; p; p = p->prev) printf("%d ", p->value);
    printf("\n");
    free(a); free(b); free(c);
    return 0;
}

A remoção é mais simples

Como cada nó conhece seu predecessor, você pode removê-lo sem procurar o nó anterior.

Basta conectar node->prev a node->next nos dois sentidos.

#include <stdio.h>
#include <stdlib.h>

struct Node { int value; struct Node *prev; struct Node *next; };
struct Node *make(int v){struct Node*n=malloc(sizeof*n);n->value=v;n->prev=NULL;n->next=NULL;return n;}

void del(struct Node **head, struct Node *n) {
    if (n->prev) n->prev->next = n->next; else *head = n->next;
    if (n->next) n->next->prev = n->prev;
    free(n);
}

int main(void) {
    struct Node *a = make(1), *b = make(2), *c = make(3);
    a->next=b; b->prev=a; b->next=c; c->prev=b;
    struct Node *head = a;
    del(&head, b);
    printf("%d %d\n", head->value, head->next->value);
    return 0;
}

Atualizar os dois vizinhos

Ao remover um nó, sempre corrija o next do nó anterior e o prev do nó seguinte.

Verifique se há NULL em cada extremidade para não desreferenciar um vizinho inexistente.

#include <stdio.h>
#include <stdlib.h>

struct Node { int value; struct Node *prev; struct Node *next; };
struct Node *make(int v){struct Node*n=malloc(sizeof*n);n->value=v;n->prev=NULL;n->next=NULL;return n;}

int main(void) {
    struct Node *a = make(1), *b = make(2);
    a->next = b; b->prev = a;
    a->next = NULL;
    free(b);
    printf("now only %d remains\n", a->value);
    free(a);
    return 0;
}

Mantendo um ponteiro para a cauda

Muitas listas duplamente encadeadas também armazenam um ponteiro para a cauda, que aponta para o último nó, permitindo adicionar elementos ao final em O(1) e percorrer a lista para trás a partir do fim.

#include <stdio.h>
#include <stdlib.h>

struct Node { int value; struct Node *prev; struct Node *next; };
struct Node *make(int v){struct Node*n=malloc(sizeof*n);n->value=v;n->prev=NULL;n->next=NULL;return n;}

int main(void) {
    struct Node *head = make(1), *tail = head;
    struct Node *n = make(2);
    tail->next = n; n->prev = tail; tail = n;
    printf("tail = %d\n", tail->value);
    free(head); free(n);
    return 0;
}

Compromissos

Listas duplamente encadeadas custam mais memória (um ponteiro adicional por nó) e exigem a atualização de duas ligações a cada alteração.

Em troca, você obtém percurso nos dois sentidos e remoção em O(1) de um nó conhecido. Escolha de acordo com suas necessidades.

#include <stdio.h>

int main(void) {
    printf("Singly: less memory, one-way\n");
    printf("Doubly: more memory, two-way + easy delete\n");
    return 0;
}

Verificação rápida

Teste sua compreensão das listas duplamente encadeadas.

Recapitulação

Você aprendeu sobre listas duplamente encadeadas:

  • Cada nó tem ponteiros prev e next.
  • Conectar nós exige atualizar ambos os sentidos.
  • Você pode percorrer a lista para a frente e para trás e excluir um nó conhecido em O(1).
  • O custo é mais memória e mais atualizações de ponteiros; um ponteiro para a cauda permite adicionar elementos ao final em O(1).

Perguntas Frequentes

A aula “Listas duplamente encadeadas” é grátis?

Sim — o texto completo de “Listas duplamente encadeadas” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C Academy, atualize para CoddyKit PRO. O curso de C Academy inclui 4 aulas no total.

O que vou aprender em “Listas duplamente encadeadas”?

Ligações nos dois sentidos. Você pratica C Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar C Academy?

Nenhuma experiência prévia é necessária. C Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Listas duplamente encadeadas”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de C Academy?

Sim. Cada aula de C Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Listas simplesmente encadeadas
  2. Inserção e exclusão
  3. Percurso e busca
  4. Listas duplamente encadeadas
← Voltar para C Academy