0Pricing
C Academy · Lezione

Liste doppiamente concatenate

Collegamenti bidirezionali

Liste doppiamente concatenate è una lezione C Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento C Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso C Academy include 4 lezioni in totale.

Collegamenti bidirezionali

Una lista doppiamente concatenata assegna a ogni nodo due puntatori: uno al nodo next e uno al nodo prev (precedente).

Questo consente di attraversare la lista in entrambe le direzioni e semplifica la rimozione.

#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;
}

Definire il nodo

La struct aggiunge un puntatore prev accanto a next. Entrambi sono NULL alle estremità della 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;
}

Un helper per la creazione

Come prima, un helper centralizza l'allocazione. Imposta sia prev sia next su 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;
}

Collegare i nodi in entrambe le direzioni

Quando collega due nodi, deve aggiornare entrambe le direzioni: il next del primo nodo e il prev del secondo.

#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;
}

Inserire all'inizio

Per inserire un nodo all'inizio: il next del nuovo nodo è la vecchia testa, il prev della vecchia testa è il nuovo nodo, quindi la testa viene spostata sul nuovo nodo.

#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;
}

Attraversamento in avanti

L'attraversamento in avanti è identico a quello di una lista semplicemente concatenata: segua next fino a 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;
}

Attraversamento all'indietro

Il vantaggio principale è che da qualsiasi nodo può procedere all'indietro seguendo i puntatori prev fino a raggiungere la testa.

#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;
}

La rimozione è più semplice

Poiché ogni nodo conosce il proprio predecessore, può eliminarlo senza cercare il nodo precedente.

È sufficiente collegare node->prev a node->next in entrambe le direzioni.

#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;
}

Aggiornare entrambi i vicini

Quando rimuove un nodo, corregga sempre il next del nodo precedente e il prev del nodo successivo.

Controlli che non sia NULL a ciascuna estremità, così non dereferenzi un vicino inesistente.

#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;
}

Mantenere un puntatore alla coda

Molte liste doppiamente concatenate memorizzano anche un puntatore tail all'ultimo nodo, consentendo aggiunte in coda O(1) e l'attraversamento all'indietro dalla fine.

#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;
}

Compromessi

Le liste doppiamente concatenate richiedono memoria aggiuntiva, ovvero un puntatore in più per nodo, e impongono di aggiornare due collegamenti a ogni modifica.

In cambio, offrono l'attraversamento bidirezionale e la rimozione O(1) di un nodo noto. Scelga in base alle Sue esigenze.

#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 rapida

Verifichi la Sua comprensione delle liste doppiamente concatenate.

Riepilogo

Ha appreso le liste doppiamente concatenate:

  • Ogni nodo ha puntatori prev e next.
  • Per collegare i nodi è necessario aggiornare entrambe le direzioni.
  • È possibile attraversare la lista in avanti e all'indietro e rimuovere un nodo noto in O(1).
  • Il costo consiste nella memoria aggiuntiva e in un numero maggiore di aggiornamenti dei puntatori; un puntatore tail consente aggiunte in coda O(1).

Domande Frequenti

La lezione «Liste doppiamente concatenate» è gratuita?

Sì — il testo completo di «Liste doppiamente concatenate» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso C Academy, passa a CoddyKit PRO. Il corso C Academy include 4 lezioni in totale.

Cosa imparerò in «Liste doppiamente concatenate»?

Collegamenti bidirezionali Eserciti C Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare C Academy?

Non è richiesta alcuna esperienza precedente. C Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Liste doppiamente concatenate»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione C Academy?

Sì. Ogni lezione C Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Liste concatenate semplici
  2. Inserimento e cancellazione
  3. Attraversamento e ricerca
  4. Liste doppiamente concatenate
← Torna a C Academy