Arreglos vs Listas Enlazadas: ¿Cuál Usar para Crear una Playlist en tu App?

Cuando estás construyendo una playlist en una app, elegir la estructura de datos adecuada es crucial para optimizar el rendimiento y la experiencia del usuario. Las estructuras más comunes son los arreglos (arrays) y las listas enlazadas (linked lists). Aquí exploraremos sus diferencias, sus ventajas y desventajas, y cuándo es mejor usar cada una.

¿Cómo Funcionan los Arreglos y las Listas Enlazadas?

• Arreglo: Un arreglo almacena elementos en bloques de memoria contiguos, permitiendo el acceso rápido a cualquier elemento mediante su índice. Sin embargo, insertar o eliminar un elemento en el medio requiere desplazar otros elementos, lo cual puede ser costoso en listas largas.

• Lista Enlazada: En una lista enlazada, los elementos están dispersos en memoria y se conectan a través de nodos con referencias al siguiente elemento (y al anterior, si es doblemente enlazada). Esto permite insertar y eliminar nodos en tiempo constante, pero acceder a elementos específicos requiere recorrer la lista desde el inicio.

Análisis de Arreglos y Listas Enlazadas en una Playlist

Cada estructura tiene sus pros y contras en función de las operaciones más comunes en una playlist:

1. Insertar y Eliminar Canciones:

   • En un arreglo, insertar o eliminar una canción en una posición arbitraria requiere desplazar los elementos y tiene un costo promedio de (O(n)).
   • En una lista enlazada, estas operaciones son más rápidas (O(1)) si tienes la referencia al nodo. Esto hace que una lista enlazada sea ideal para aplicaciones donde agregas o eliminas canciones con frecuencia.

2. Acceso Directo a Canciones:

   • Un arreglo es muy eficiente, ya que puedes acceder directamente a cualquier canción mediante su índice en (O(1)).
   • En una lista enlazada, debes recorrer la lista para acceder a una posición específica, lo que toma (O(n)) en promedio. Si tu aplicación necesita acceso rápido y frecuente a canciones específicas, un arreglo es preferible.

3. Recorrido Secuencial:

   • Ambos tipos de estructura permiten avanzar o retroceder entre canciones secuencialmente. Sin embargo, una lista doblemente enlazada puede ser más intuitiva para gestionar la reproducción secuencial en una playlist.

4. Uso de Memoria:

   • Los arreglos son más eficientes en cuanto a memoria, ya que solo almacenan los elementos.
   • Las listas enlazadas requieren más memoria debido a las referencias adicionales que cada nodo almacena, especialmente en listas doblemente enlazadas.

Ejemplo Práctico de una Playlist con Linked List en TypeScript

La siguiente implementación crea una lista enlazada para una playlist en TypeScript. Incluye las funciones de agregar canciones, moverlas de posición y mostrar toda la playlist:

class SongNode {
  title: string
  artist: string
  next: SongNode | null
  prev: SongNode | null

  constructor(title: string, artist: string) {
    this.title = title
    this.artist = artist
    this.next = null
    this.prev = null
  }
}

class Playlist {
  head: SongNode | null
  tail: SongNode | null

  constructor() {
    this.head = null
    this.tail = null
  }

  // Agregar canción al final de la playlist
  addSong(title: string, artist: string) {
    const newSong = new SongNode(title, artist)
    if (!this.head) {
      this.head = newSong
      this.tail = newSong
    } else {
      this.tail!.next = newSong
      newSong.prev = this.tail
      this.tail = newSong
    }
  }

  // Mostrar toda la playlist
  showPlaylist() {
    let current = this.head
    while (current) {
      console.log(`${current.title} - ${current.artist}`)
      current = current.next
    }
  }

  // Mover una canción de una posición a otra
  moveSong(fromIndex: number, toIndex: number) {
    if (fromIndex === toIndex || !this.head) return

    let fromNode = this.head
    let index = 0

    // Obtener nodo de origen
    while (fromNode && index < fromIndex) {
      fromNode = fromNode.next
      index++
    }
    if (!fromNode) return

    // Desconectar el nodo de origen
    if (fromNode.prev) fromNode.prev.next = fromNode.next
    if (fromNode.next) fromNode.next.prev = fromNode.prev
    if (fromNode === this.head) this.head = fromNode.next
    if (fromNode === this.tail) this.tail = fromNode.prev

    // Insertar el nodo en la nueva posición
    let toNode = this.head
    index = 0
    while (toNode && index < toIndex) {
      toNode = toNode.next
      index++
    }
    if (toNode) {
      fromNode.next = toNode
      fromNode.prev = toNode.prev
      toNode.prev = fromNode
    } else {
      fromNode.next = null
      this.tail!.next = fromNode
      fromNode.prev = this.tail
      this.tail = fromNode
    }
  }
}

¿Qué Estructura Es Mejor para una Playlist?

• Usa un arreglo si necesitas acceder rápidamente a canciones específicas y tu lista es de tamaño fijo o no cambian con frecuencia.

• Usa una lista enlazada si planeas mover canciones frecuentemente o cambiar la lista de tamaño de manera dinámica, ya que facilita las inserciones y eliminaciones sin necesidad de desplazamientos.

Ambas estructuras tienen ventajas para distintos casos de uso, pero las listas enlazadas son generalmente mejores si tu aplicación necesita gestionar canciones con cambios frecuentes y dinámicos en la lista.