Inserta nodos intermedios sin romper enlaces en JavaScript

Aprende a insertar un nodo en la parte intermedia de una lista enlazada en JavaScript sin romper referencias. Con una lógica clara y segura frente al garbage collector, verás cómo usar pointers, identificar el índice previo y encadenar correctamente next para mantener la estructura íntegra.

¿Cómo insertar un nodo intermedio en JavaScript?

Insertar en medio no significa “exactamente al centro”, puede ser después de la head o antes de la cola. Lo clave es no dejar ningún nodo existente sin un pointer, porque el garbage collector podría eliminarlo.

• Todas las soluciones válidas cuentan. Si tu lógica es distinta y el resultado es correcto, está bien.
• Secuencia segura. Localiza el nodo previo (índice − 1), guarda su siguiente en un holding pointer, enlaza el previo con el nuevo nodo y conecta el nuevo con el holding pointer.
• Actualiza la longitud. Aumenta la longitud y retorna la lista.

Ejemplo de implementación basada en la explicación:

class LinkedList {
  constructor() {
    this.head = null;
    this.length = 0;
  }

  append(value) {
    // Agrega al final. (Implementado previamente en tu estructura.)
  }

  insert(index, value) {
    // Validación: si el índice no existe, insertar al final.
    if (index >= this.length) {
      console.log('No hay suficientes elementos, se inserta al final.');
      return this.append(value);
    }

    const newNode = new Node(value);

    // firstPointer: nodo previo al índice objetivo.
    const firstPointer = this.getIndex(index - 1);

    // holdingPointer: el que “espera” para no perderse.
    const holdingPointer = firstPointer.next;

    // Reasignaciones seguras para no perder referencias.
    firstPointer.next = newNode;
    newNode.next = holdingPointer;

    this.length++;
    return this;
  }

  getIndex(index) {
    let counter = 0;
    let currentNode = this.head; // Siempre se inicia desde la head.
    while (counter !== index) {
      currentNode = currentNode.next;
      counter++;
    }
    return currentNode;
  }
}

¿Por qué importa el garbage collector y los pointers?

Si reasignas antes de tiempo, un nodo puede quedar sin pointer. Cuando eso pasa, el garbage collector lo elimina para liberar memoria. Por eso se usa un holding pointer: guarda temporalmente el enlace que aún necesitas.

• No rompas el enlace existente sin respaldo. Primero guarda el next actual.
• Evita “huérfanos”. Todo nodo debe quedar accesible por al menos un pointer.
• Orden importa. Reasignar en desorden provoca pérdidas de referencias.

¿Cuál es la secuencia correcta de reasignación de next?

• Localiza el previo con getIndex(index - 1).
• Guarda su siguiente en un holding pointer.
• Asigna previo.next = nuevoNodo.
• Asigna nuevoNodo.next = holdingPointer.
• Incrementa la longitud y retorna la lista.

¿Qué validaciones iniciales evitan errores de índice?

Validar índices y casos límite evita resultados inesperados.

• Índice fuera de rango. Si index ≥ longitud, se inserta con append al final.
• Retro de práctica. Valida listas vacías y entradas inválidas para fortalecer tu método.
• Mensajes claros. Un simple console.log ayuda a entender qué ocurrió.

Ejemplo mínimo de la validación usada arriba:

if (index >= this.length) {
  console.log('No hay suficientes elementos, se inserta al final.');
  return this.append(value);
}

¿Cómo recorrer la lista para ubicar el índice previo?

Para mover punteros con seguridad, necesitas el nodo previo al objetivo. Se recorre desde la head con un contador hasta que counter === index.

• Punto de partida. El current node inicia en la head.
• Recorrido lineal. Avanza con current = current.next e incrementa el contador.
• Devolución precisa. Cuando el contador coincide, retorna ese nodo.

Fragmento clave:

getIndex(index) {
  let counter = 0;
  let currentNode = this.head;
  while (counter !== index) {
    currentNode = currentNode.next;
    counter++;
  }
  return currentNode; // Nodo en la posición solicitada.
}

¿Listo para el siguiente paso? Implementa tu método remove para sacar un nodo intermedio y, si quieres moverlo al final, vuelve a usar append. Comparte tu solución y cuéntame cómo lo resolviste.