Doubly Linked List con punteros bidireccionales

Domina la construcción de una doubly linked list: una estructura con recorrido bidireccional que usa punteros next y preview para moverse de la head a la tail y viceversa. Verás cómo su nodo incluye tres campos y cómo adaptar el método append para enlazar en dos direcciones con una sola línea clave.

¿Qué es una doubly linked list y por qué usarla?

Una doubly linked list es una linked list con enlaces hacia adelante y hacia atrás. A diferencia de una singly, no necesitas “volver a empezar” desde la cabeza para regresar; puedes ir de la tail a la head directamente. Esto puede hacer ciertas búsquedas y recorridos más ágiles en casos particulares.

¿Qué ventajas ofrece frente a una singly linked list?

• Recorrido en dos direcciones: head → tail y tail → head.
• Evita rehacer bucles desde el inicio al retroceder.
• Misma regla de acceso: no hay índice aleatorio, se recorre nodo a nodo.

¿Cómo se recorre sin volver al inicio?

• Avanza con next hasta la tail.
• Retrocede con preview hasta la head.
• Mantiene la lógica de lista enlazada: pasos secuenciales, sin acceso por índice directo.

¿Cómo se define la estructura: nodo, instancia y memoria?

El corazón de la lista es el nodo. Aquí cambia respecto a una singly: además de value y next, se agrega un puntero preview (al previo), que inicia en null.

¿Qué contiene el nodo de una doubly linked list?

• value: el dato que guarda el nodo.
• next: referencia al siguiente nodo.
• preview: referencia al nodo anterior; inicia en null.

Ejemplo mínimo del nodo:

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

¿Cómo se inicializa la primera instancia de la clase?

• Crear el primer nodo con value y next = null.
• Definir preview = null en ese primer nodo.
• Asignar head = tail = primerNodo.
• Iniciar length = 1 porque ya existe un elemento.

Representación mental en memoria:

• Los nodos forman una cadena con dos direcciones.
• Puedes “saltar” hacia atrás gracias a preview sin reiniciar desde la head.

¿Cómo programar append y qué reto sigue?

El método append añade un nodo al final y ahora debe enlazar en ambos sentidos. El ajuste clave es establecer el preview del nuevo nodo apuntando a la tail actual, luego encadenar el next y actualizar la tail.

¿Cómo cambia el método append?

• Crear el nuevo nodo.
• Apuntar su preview a la tail actual.
• Conectar la tail actual hacia adelante con next.
• Mover tail al nuevo nodo e incrementar length.

Fragmento esencial del enlace doble:

append(value) {
  const newNode = new Node(value);
  newNode.preview = this.tail;      // enlace hacia atrás
  this.tail.next = newNode;         // enlace hacia adelante
  this.tail = newNode;              // actualizar cola
  this.length++;
  return this;
}

Resultados esperados tras varios append:

• La head conserva preview = null.
• La tail conserva next = null.
• Los nodos intermedios tienen next y preview correctamente enlazados.

¿Qué métodos debes extender después?

• Implementa la misma lógica de doble enlace en insert.
• Ajusta referencias en remove para ambos lados.
• Revisa métodos previos de la singly y añade preview donde corresponda.

Sigue la recomendación: antes de codear, toma papel y lápiz para planear los enlaces. ¿Ya adaptaste tus métodos con el nuevo puntero? Comparte tu solución y cuéntanos cómo lo resolviste.