0Pricing
C Academy · Lección

Listas enlazadas simples

Nodos y punteros

Listas enlazadas simples es una lección gratuita de C Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C Academy incluye 4 lecciones en total.

¿Qué es una lista enlazada?

Una lista enlazada es una cadena de pequeñas estructuras llamadas nodos. Cada nodo contiene un valor y un puntero al nodo siguiente.

A diferencia de los arrays, los elementos no tienen que ser contiguos en memoria, y la lista puede crecer o reducirse fácilmente.

#include <stdio.h>

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

int main(void) {
    printf("A node holds a value and a next pointer\n");
    return 0;
}

Definir un nodo

La estructura del nodo contiene los datos y un struct Node *next que apunta al nodo siguiente.

El tipo de puntero hace referencia a la misma estructura, que es lo que permite enlazar la cadena.

#include <stdio.h>

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

int main(void) {
    struct Node n;
    n.value = 42;
    n.next = NULL;
    printf("value=%d, next is NULL: %d\n", n.value, n.next == NULL);
    return 0;
}

El puntero head

Una lista se identifica mediante un único puntero a su primer nodo, llamado head.

Una lista vacía es simplemente un head igual a NULL.

#include <stdio.h>

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

int main(void) {
    struct Node *head = NULL;
    printf("List is empty: %d\n", head == NULL);
    return 0;
}

Asignar un nodo

Los nodos suelen crearse en el heap con malloc para que sobrevivan a la función que los crea.

Compruebe siempre el valor devuelto y recuerde liberar los nodos más adelante.

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

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

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

Operador flecha

Cuando tenga un puntero a una estructura, use -> para acceder a sus miembros. n->value significa lo mismo que (*n).value.

Usará constantemente el operador flecha con las listas enlazadas.

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

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

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

Enlazar dos nodos

Para conectar nodos, haga que el next del primero apunte al segundo. El next del último nodo permanece en NULL para marcar el final.

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

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

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

Una función auxiliar para crear nodos

Asignar memoria repetidamente resulta tedioso, así que encapsúlelo en una función auxiliar que asigne memoria, inicialice y devuelva un nodo nuevo.

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

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

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

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

Crear una lista pequeña

Con la función auxiliar, cree una lista de tres nodos 1 -> 2 -> 3 encadenando los punteros next.

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

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

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

Imprimir la lista

Para imprimir todos los valores, empiece por el head y siga los punteros next hasta llegar a NULL.

Este patrón de recorrido es la base de casi todas las operaciones con listas.

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

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

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

Arrays frente a listas enlazadas

Los arrays ofrecen acceso rápido mediante índices, pero tienen un tamaño fijo. Las listas enlazadas facilitan la inserción y la eliminación, pero ofrecen un acceso más lento (debe recorrerlas para llegar a un elemento).

Elija según las operaciones que predominen en su programa.

#include <stdio.h>

int main(void) {
    printf("Array: O(1) index, costly resize\n");
    printf("List:  O(n) index, cheap insert/delete\n");
    return 0;
}

Liberar toda la lista

Debe liberarse cada nodo reservado con malloc. Recorra la lista, pero guarde el puntero next antes de liberar cada nodo; de lo contrario, perderá el resto de la cadena.

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

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

int main(void) {
    struct Node *head = make(1);
    head->next = make(2);
    struct Node *p = head;
    while (p) {
        struct Node *nxt = p->next;
        free(p);
        p = nxt;
    }
    printf("freed all nodes\n");
    return 0;
}

Comprobación rápida

Compruebe su comprensión de la estructura de las listas enlazadas.

Resumen

Ha aprendido los conceptos básicos de las listas simplemente enlazadas:

  • Un nodo contiene un valor y un puntero next; el head apunta al primer nodo.
  • Reserve nodos con malloc y acceda a sus miembros con ->.
  • El next del último nodo es NULL; recorra la lista siguiendo los punteros.
  • Siempre debe hacer free de todos los nodos y guardar next antes de liberarlos.

Preguntas frecuentes

¿La lección «Listas enlazadas simples» es gratis?

Sí — el texto completo de «Listas enlazadas simples» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C Academy, actualiza a CoddyKit PRO. El curso de C Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Listas enlazadas simples»?

Nodos y punteros Practicas C Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar C Academy?

No se requiere experiencia previa. C Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «Listas enlazadas simples»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de C Academy?

Sí. Cada lección de C Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Listas enlazadas simples
  2. Inserción y eliminación
  3. Recorrido y búsqueda
  4. Listas doblemente enlazadas
← Volver a C Academy