Una lista enlazada es una estructura de datos dinámica que consiste en una serie de elementos llamados nodos, donde cada nodo contiene un dato y una referencia al siguiente nodo en la secuencia. A diferencia de un array, las listas enlazadas permiten un crecimiento dinámico sin un tamaño fijo y facilitan la inserción y eliminación de elementos, ya que solo requieren actualizar referencias.

Las listas enlazadas son útiles cuando necesitas manejar datos de forma flexible, ya que no se requiere reordenar todos los elementos cada vez que se agrega o elimina uno. Aquí exploraremos cómo funcionan las listas enlazadas y veremos ejemplos en varios lenguajes de programación.

Estructura de una Lista Enlazada

Cada nodo en una lista enlazada generalmente contiene dos partes:

Dato: El valor o información que queremos almacenar en ese nodo.
Referencia (enlace): Un puntero o referencia al siguiente nodo en la lista.
La lista enlazada tiene un nodo inicial (llamado "head") que apunta al primer elemento de la lista. Si llegamos a un nodo cuya referencia es null (o nullptr), significa que estamos al final de la lista.

Ejemplos de Listas Enlazadas en Diferentes Lenguajes

JavaScript

JavaScript no tiene listas enlazadas integradas, pero podemos crearlas utilizando clases para definir los nodos y la lista.

// clase para definir la estructura del nodo
class Nodo {
  constructor(dato) {
    this.dato = dato; // Valor almacenado en el nodo
    this.siguiente = null; // Puntero al siguiente nodo (inicialmente null)
  }
}

// clase que representara una lista enlazada simple
class ListaEnlazada {
  constructor() {
    // Inicializa la lista con un nodo principal (head) vacío
    this.head = null;
  }

  // Método para agregar un nuevo dato al final de la lista
  agregar(dato) {
    // Crea un nuevo nodo con el dato proporcionado
    const nuevoNodo = new Nodo(dato);

    // Si la lista está vacía (head es null), el nuevo nodo se convierte en el primer nodo
    if (!this.head) {
      this.head = nuevoNodo;
    } else {
      // Si la lista no está vacía, recorre la lista para encontrar el último nodo
      let actual = this.head;
      // Mientras el nodo actual tenga un siguiente, avanza
      while (actual.siguiente) {
        actual = actual.siguiente;
      }
      // Cuando se encuentra el último nodo, se enlaza al nuevo nodo
      actual.siguiente = nuevoNodo;
    }
  }
}

// Ejemplo de uso:
// Crear una nueva lista enlazada
const lista = new ListaEnlazada();

// Agregar elementos a la lista
lista.agregar(5); // Lista: 5 -> null
lista.agregar(10); // Lista: 5 -> 10 -> null
lista.agregar(15); // Lista: 5 -> 10 -> 15 -> null

console.log(lista.head.dato); // Imprime el primer valor: 1

C#

las listas enlazadas se pueden implementar mediante clases y referencias, pero también existen listas enlazadas listas para usar en System.Collections.Generic.LinkedList.

// Importa los espacios de nombres necesarios
using System; // Proporciona funcionalidades básicas como entrada/salida y tipos fundamentales
using System.Collections.Generic; // Contiene clases de colecciones como LinkedList

// Crea una lista enlazada genérica de enteros
LinkedList<int> lista = new LinkedList<int>();

// Agrega un elemento 
lista.AddLast(1); // Lista: 1

lista.AddLast(5); // Lista: 1 -> 5

lista.AddLast(3); // Lista: 1 -> 5 -> 3

// Obtiene y muestra el valor del primer nodo de la lista
Console.WriteLine(lista.First.Value); // Imprime el primer valor: 1

PHP

PHP tampoco tiene listas enlazadas de forma nativa, pero podemos crearlas mediante clases y referencias.

// Clase que representa un nodo en una lista enlazada
class Nodo { 
    public $dato;        // Almacena el valor del nodo
    public $siguiente;   // Apunta al siguiente nodo en la lista (o null si no hay siguiente)

    // Constructor para inicializar un nodo con un valor
    public function __construct($dato) {
        $this->dato = $dato;          // Asigna el valor proporcionado al nodo
        $this->siguiente = null;      // Por defecto, el nodo no apunta a ningún otro nodo
    }
}

// Clase que representa una lista enlazada
class ListaEnlazada {
    public $head;  // Apunta al primer nodo de la lista (o null si está vacía)

    // Constructor para inicializar una lista vacía
    public function __construct() {
        $this->head = null;  // La lista comienza sin nodos
    }

    // Método para agregar un nuevo nodo con un dato al final de la lista
    public function agregar($dato) {
        $nuevoNodo = new Nodo($dato); // Crea un nuevo nodo con el dato proporcionado
        
        // Si la lista está vacía (head es null), asigna el nuevo nodo como el primer nodo
        if (!$this->head) {
            $this->head = $nuevoNodo;
        } else {
            // Si la lista no está vacía, recorre los nodos para encontrar el último
            $actual = $this->head;
            while ($actual->siguiente) { // Avanza al siguiente nodo mientras exista uno
                $actual = $actual->siguiente;
            }
            // Una vez encontrado el último nodo, enlázalo al nuevo nodo
            $actual->siguiente = $nuevoNodo;
        }
    }
}

// Crear una instancia de ListaEnlazada
$lista = new ListaEnlazada();

// Agregar elementos a la lista
$lista->agregar(1); // Lista: 1
$lista->agregar(5); // Lista: 1 -> 5
$lista->agregar(3); // Lista: 1 -> 5 -> 3

// Imprimir el valor del primer nodo (head)
echo $lista->head->dato; // Imprime: 1

JAVA

Java no cuenta con una estructura nativa de listas enlazadas, pero permite crear una mediante clases o usando LinkedList de la librería java.util.

// Importa la clase LinkedList del paquete java.util
import java.util.LinkedList; 

// Clase principal para demostrar el uso de una lista enlazada en Java
public class EjemploListaEnlazada {
    public static void main(String[] args) {
        // Crea una instancia de LinkedList que almacena enteros
        LinkedList<Integer> lista = new LinkedList<>();

        // Agrega elementos a la lista enlazada
        lista.add(1); // Agrega el valor 1 al final de la lista: [1]
        lista.add(2); // Agrega el valor 2 al final de la lista: [1, 2]
        lista.add(3); // Agrega el valor 3 al final de la lista: [1, 2, 3]

        // Obtiene e imprime el primer elemento de la lista
        System.out.println(lista.getFirst()); // Imprime: 1
    }
}

C

En C, las listas enlazadas se crean mediante estructuras y punteros.

#include <stdio.h>  // Biblioteca estándar para entrada/salida
#include <stdlib.h> // Biblioteca estándar para manejo de memoria dinámica

// Estructura que representa un nodo de una lista enlazada
struct Nodo {
    int dato;                // Valor almacenado en el nodo
    struct Nodo* siguiente;  // Puntero al siguiente nodo (o NULL si no hay ninguno)
};

// Función para agregar un nuevo nodo al inicio de la lista
void agregar(struct Nodo** head, int dato) {
    // Reserva memoria para un nuevo nodo
    struct Nodo* nuevoNodo = (struct Nodo*)malloc(sizeof(struct Nodo));
    
    // Asigna el dato al nuevo nodo
    nuevoNodo->dato = dato;

    // Enlaza el nuevo nodo para que apunte al nodo actual señalado por head
    nuevoNodo->siguiente = *head;

    // Actualiza head para que apunte al nuevo nodo, convirtiéndolo en el primero
    *head = nuevoNodo;
}

int main() {
    // Inicializa la lista enlazada como vacía (head es NULL)
    struct Nodo* head = NULL;

    // Agrega nodos con valores 3, 2 y 1 al inicio de la lista
    agregar(&head, 3); // Lista: 3
    agregar(&head, 2); // Lista: 2 -> 3
    agregar(&head, 1); // Lista: 1 -> 2 -> 3

    // Imprime el valor del primer nodo (head)
    printf("%d\n", head->dato); // Salida: 1

    return 0; // Indica que el programa finalizó correctamente
}

C++

En C++, las listas enlazadas se implementan de forma similar a C, pero también puedes usar std::list de la librería estándar para una implementación lista para usar.

#include <iostream> // Biblioteca estándar para entrada/salida
#include <list>     // Biblioteca que proporciona la clase `list`
using namespace std; // Permite evitar el uso del prefijo `std::`

int main() {
    // Crea una lista enlazada que almacena enteros
    list<int> lista;

    // Agrega elementos al final de la lista
    lista.push_back(1); // Agrega el valor 1: lista = [1]
    lista.push_back(2); // Agrega el valor 2: lista = [1, 2]
    lista.push_back(3); // Agrega el valor 3: lista = [1, 2, 3]

    // Obtiene e imprime el primer elemento de la lista
    cout << lista.front() << endl; // Imprime: 1

    return 0; // Indica que el programa terminó correctamente
}

Las listas enlazadas son una estructura de datos eficiente para manejar colecciones dinámicas de datos. Nos permiten agregar o eliminar elementos sin necesidad de reorganizar toda la estructura, aunque algunos lenguajes, como Java y C++, tienen listas enlazadas integradas, otros lenguajes de programación requieren que las implementes manualmente. Saber trabajar con listas enlazadas es útil para la manipulación de datos en estructuras dinámicas y en situaciones donde la flexibilidad de los arrays tradicionales no es suficiente.