Tread softly
because you tread
on my dreams.

El nodo guarda dos cosas.

typedef struct Node {
    const char *value;  // el dato
    struct Node *next; // dirección del siguiente
} Node;

Node a = {"Eleven", NULL};
Node b = {"Maniac", NULL};
a.next = &b;
Node *head = &a;

&b obtiene la dirección de b. head guarda una dirección, no una copia de a. head->next equivale a (*head).next: desreferenciar el puntero y acceder al campo.

Dirección no es posición.

Un arreglo permite pedir el elemento i. En una lista simplemente enlazada empezás en head y seguís next, una referencia a la vez. Sus nodos pueden estar separados en memoria.

Un Node * señala un nodo. Un Node ** señala una variable que guarda ese puntero: sirve cuando una función necesita cambiar el head o top del llamador.

Las direcciones del tablero son etiquetas ficticias. No son direcciones reales de tus servidores ni resultados de malloc.

Insertar: el orden importa.

// A → B → C. Insertar D después de B.
fresh->next = prev->next; // D → C
prev->next = fresh;       // B → D
// A → B → D → C

Si primero hacés prev->next = fresh y luego copiás ese mismo enlace a fresh->next, D termina apuntándose a sí mismo. Perdiste desde la lista el camino hacia C. Guardar y conectar son pasos distintos.

Retirar no es lo mismo que liberar.

Node *victim = prev->next;
prev->next = victim->next;
free(victim);
victim = NULL;

Desenlazar modifica la estructura. free devuelve una reserva al allocator; no borra otras referencias al objeto. Este ejemplo requiere un nodo propio creado con malloc. No se usa con los nodos automáticos a y b del primer fragmento.

El dibujo: una lista circular.

Podés imaginar cada posición enlazada con la siguiente: 0 → 1 → 2 → 0. Una lista enlazada real guardaría referencias entre nodos. Aquí las flechas describen la relación circular, no punteros implementados.

El código: una lista de Python.

plan() ordena las posiciones de un diccionario, crea una secuencia y usa slices para rotarla. Luego devuelve un nuevo diccionario y las posiciones que cambiaron. No modifica el anillo de entrada.

Una pila enlazada, en C.

// push: fresh ya fue reservado.
fresh->next = *top;
*top = fresh;

// pop: comprobar antes que *top != NULL.
Node *old = *top;
*out = old->value;
*top = old->next;
free(old);

Entradas A, B, C → salidas C, B, A. Un extremo, un puntero al tope. Pasar &top permite que la función actualice la variable del llamador.

Una cola enlazada, en C.

// enqueue: fresh->next ya es NULL.
if (q->rear) q->rear->next = fresh;
else q->front = fresh;
q->rear = fresh;

// dequeue: comprobar front != NULL.
Node *old = q->front;
*out = old->value;
q->front = old->next;
if (!q->front) q->rear = NULL;
free(old);

Entradas A, B, C → salidas A, B, C. Agregás por el final y extraés por el frente. Al vaciarla, ambos punteros deben quedar en NULL.