Entendiendo las Listas Enlazadas en Ruby

Las listas enlazadas son una estructura de datos fundamental en la programación, y Ruby, como lenguaje de programación versátil y poderoso, permite implementarlas de manera efectiva. En este artículo, exploraremos qué son las listas enlazadas, cómo funcionan y cómo puedes implementarlas en Ruby. Además, proporcionaremos ejemplos de código y discutiremos las ventajas y desventajas de usar listas enlazadas en comparación con otros tipos de estructuras de datos.

¿Qué es una Lista Enlazada?

Una lista enlazada es una colección de elementos, llamados nodos, donde cada nodo contiene un valor y una referencia (o enlace) al siguiente nodo en la secuencia. A diferencia de los arrays, que tienen un tamaño fijo y permiten el acceso aleatorio a sus elementos, las listas enlazadas son dinámicas y permiten la inserción y eliminación de elementos de manera eficiente.

Estructura de un Nodo

Un nodo en una lista enlazada típicamente tiene dos componentes:

Valor: El dato que almacena el nodo.
Referencia: Un puntero al siguiente nodo en la lista.

En Ruby, podemos definir un nodo de la siguiente manera:

class Nodo
  attr_accessor :valor, :siguiente

  def initialize(valor)
    @valor = valor
    @siguiente = nil
  end
end

Implementación de una Lista Enlazada

Ahora que tenemos nuestra clase de nodo, podemos construir una lista enlazada. La lista enlazada tendrá un puntero al primer nodo, conocido como "cabeza". A continuación, implementaremos una clase para la lista enlazada que incluirá métodos para agregar, eliminar y mostrar elementos.

class ListaEnlazada
  attr_accessor :cabeza

  def initialize
    @cabeza = nil
  end

  def agregar(valor)
    nuevo_nodo = Nodo.new(valor)
    if @cabeza.nil?
      @cabeza = nuevo_nodo
    else
      nodo_actual = @cabeza
      while nodo_actual.siguiente
        nodo_actual = nodo_actual.siguiente
      end
      nodo_actual.siguiente = nuevo_nodo
    end
  end

  def eliminar(valor)
    return if @cabeza.nil?

    if @cabeza.valor == valor
      @cabeza = @cabeza.siguiente
      return
    end

    nodo_actual = @cabeza
    while nodo_actual.siguiente
      if nodo_actual.siguiente.valor == valor
        nodo_actual.siguiente = nodo_actual.siguiente.siguiente
        return
      end
      nodo_actual = nodo_actual.siguiente
    end
  end

  def mostrar
    nodo_actual = @cabeza
    while nodo_actual
      print "#{nodo_actual.valor} -> "
      nodo_actual = nodo_actual.siguiente
    end
    puts "nil"
  end
end

Uso de la Lista Enlazada

Veamos cómo podemos utilizar nuestra clase de lista enlazada para agregar, eliminar y mostrar elementos:

lista = ListaEnlazada.new
lista.agregar(1)
lista.agregar(2)
lista.agregar(3)
lista.mostrar  # Salida: 1 -> 2 -> 3 -> nil

lista.eliminar(2)
lista.mostrar  # Salida: 1 -> 3 -> nil

Ventajas de las Listas Enlazadas

Las listas enlazadas tienen varias ventajas sobre otras estructuras de datos, como los arrays:

Inserción y eliminación eficientes: Agregar o eliminar elementos en una lista enlazada es más eficiente que en un array, especialmente si se realizan en el medio de la lista.
Uso eficiente de la memoria: Las listas enlazadas pueden crecer y decrecer dinámicamente, lo que significa que no necesitas predefinir su tamaño.
Flexibilidad: Puedes implementar diferentes tipos de listas enlazadas, como listas enlazadas dobles o circulares, según tus necesidades.

Desventajas de las Listas Enlazadas

A pesar de sus ventajas, las listas enlazadas también tienen desventajas:

Acceso secuencial: A diferencia de los arrays, donde puedes acceder a cualquier elemento directamente, en una lista enlazada debes recorrerla desde el principio para llegar a un nodo específico.
Mayor uso de memoria: Cada nodo requiere memoria adicional para almacenar la referencia al siguiente nodo, lo que puede ser ineficiente en comparación con un array.
Complejidad: La implementación de listas enlazadas puede ser más compleja que el uso de arrays, especialmente para principiantes.

Conclusión

Las listas enlazadas son una estructura de datos poderosa y flexible que puede ser muy útil en diversas aplicaciones. Aunque tienen sus ventajas y desventajas, su capacidad para manejar dinámicamente la memoria y permitir inserciones y eliminaciones eficientes las convierte en una opción valiosa en la programación.

Esperamos que este artículo te haya proporcionado una comprensión clara de las listas enlazadas en Ruby. Te animamos a experimentar con el código y a explorar más sobre esta fascinante estructura de datos. ¡Feliz codificación!