Métodos para Manipular Nodos en Listas Enlazadas

Domina la lógica de una linked list al implementar los métodos append y prepend para agregar nodos al final y al inicio. Conecta correctamente la cabeza, la cola y el puntero next para que la estructura crezca sin errores y valida la longitud paso a paso con pruebas simples.

¿Cómo agregar nodos al final con append?

Para que un nuevo nodo sea la nueva cola, la secuencia es directa: crear el nodo, enlazarlo con el tail.next y actualizar la cola. Así logras que el null final se reemplace por el nuevo nodo y la lista crezca de forma consistente.

class Node {
  constructor(value) {
    this.value = value;
    this.next = null;
  }
}

class LinkedList {
  constructor(initialValue) {
    const firstNode = new Node(initialValue);
    this.head = firstNode;
    this.tail = firstNode;
    this.length = 1;
  }

  append(value) {
    const newNode = new Node(value);
    this.tail.next = newNode; // enlaza el último nodo actual con el nuevo
    this.tail = newNode;      // el nuevo nodo se convierte en la cola
    this.length++;
    return this;
  }
}

¿Cuál es la lógica de tail.next y cola?

• Crear el nuevo nodo con el value que recibes.
• Asignar tail.next al nuevo nodo para colocarlo al final.
• Actualizar tail al nuevo nodo para que sea la cola.
• Incrementar length para reflejar el nuevo tamaño.

¿Cómo validar la estructura y la longitud?

• Verificar que la estructura existe con una longitud inicial de uno.
• Ejecutar append(2): la cabeza sigue siendo 1, la cola ahora es 2.
• Ejecutar append(3): la cola ahora es 3 y la cabeza permanece en 1.
• Observar el anidado: cada nodo tiene value y un next que apunta al siguiente o a null al final.

¿Cómo insertar al inicio con prepend?

Para agregar un nodo como nueva cabeza, primero lo conectas al inicio y luego actualizas la referencia de la cabeza. La clave: apuntar el newNode.next al head actual y después mover la cabeza al newNode.

class LinkedList {
  // ... mismo constructor y Node que arriba

  prepend(value) {
    const newNode = new Node(value);
    newNode.next = this.head; // conecta el nuevo nodo con la cabeza actual
    this.head = newNode;      // el nuevo nodo se convierte en la cabeza
    this.length++;
    return this;
  }
}

¿Qué cambia en la cabeza y los pointers?

• El nuevo nodo apunta con next a la cabeza anterior.
• La referencia head pasa a ser el nuevo nodo.
• La cola no cambia si la lista ya tenía más de un nodo.
• La longitud aumenta en uno.

¿Qué se observa al probar con cero como nueva cabeza?

• Ejecutar prepend(0): la cabeza ahora es 0.
• La cola se mantiene en 1 si la lista era [1] antes.
• La longitud refleja el cambio: pasa a 2 tras el prepend.

¿Qué habilidades y keywords refuerzas con esta práctica?

Comprendes cómo modelar una linked list con una clase que mantiene referencias a head, tail y length, y cómo un nodo encapsula value y next. Practicas el manejo de pointers para insertar correctamente sin romper la estructura. Además, validas el estado tras cada operación con retornos tipo return this y pruebas en el navegador.

• Diseño de métodos: append para el final y prepend para el inicio.
• Manipulación de referencias: head, tail, next y su actualización ordenada.
• Pensamiento visual: crear un mapa mental de cómo cambia el null al enlazar un nuevo nodo.
• Verificación incremental: revisar longitud y anidado tras cada operación.
• Preparación para el reto: método insert para colocar un nodo en medio, pensando primero la lógica en papel.

Si ya implementaste tu método, comparte tu solución y explica cómo llegaste a ella: así todos aprendemos más rápido.