Construir un stack en JavaScript es más sencillo cuando entendemos cómo funcionan los nodos y los pointers. Aquí verás cómo definir la clase, crear nodos, validar el estado y programar los métodos peek y push para crecer la estructura paso a paso con seguridad.

¿Cómo construir un stack en JavaScript desde cero?

Para iniciar, se define la clase sin valores iniciales: no se obliga a pasar un primer elemento al crear la instancia. En el constructor se establecen tres propiedades clave: top y bottom en null, y length en 0. Así, el stack comienza vacío y se llena con push.

• Instancia sin valor inicial: se crece con push, no en el constructor.
• Propiedades base: top, bottom y length con valores controlados.
• Estrategia: separar la definición del stack de la lógica de inserción.

¿Qué define el constructor y la instancia?

• top: el elemento de arriba. Inicia en null.
• bottom: el primer elemento en la base. Inicia en null.
• length: la longitud del stack. Inicia en 0.
• instancia: por ejemplo, const myStack = new Stack().

¿Por qué usar un node y next como en una linked list?

Cada elemento agregado se modela como un node con dos campos: value y next. Esto permite enlazar elementos como en una linked list y manipular el top con seguridad.

• node.value: guarda el dato.
• node.next: referencia al siguiente nodo. Inicia en null.
• beneficio: facilita operaciones LIFO y manejo de referencias.

¿Cómo se ve el código base?

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

class Stack {
  constructor() {
    this.top = null;
    this.bottom = null;
    this.length = 0;
  }

  peek() {
    return this.top;
  }

  push(value) {
    const newNode = new Node(value);
    if (this.length === 0) {
      this.top = newNode;
      this.bottom = newNode;
    } else {
      const holdingPointer = this.top;
      this.top = newNode;
      this.top.next = holdingPointer;
    }
    this.length++;
    return this;
  }
}

¿Qué hacen los métodos peek y push en un stack?

Estos métodos implementan el comportamiento LIFO del stack: el último que entra es el primero en salir. peek devuelve el elemento del top sin modificar la estructura. push agrega un nuevo nodo y lo coloca como top.

¿Cómo funciona peek para obtener el último elemento?

• objetivo: devolver el elemento en el top.
• parámetros: ninguno, no se selecciona un índice.
• retorno: la referencia al top actual.
• idea clave: no altera el stack, solo lo consulta.

¿Cómo se implementa push con validación y referencias?

• crear new node: const newNode = new Node(value).
• validación de vacío: si length === 0, top y bottom apuntan al mismo nodo.
• guardar referencia: usar un holding pointer con el top actual.
• reubicar punteros: this.top = newNode; this.top.next = holdingPointer.
• actualizar longitud: incrementar length y retornar el stack.
• prevención: evitar perder referencias para que el garbage collector no borre nodos.

¿Cómo probar el stack y qué sigue?

La verificación es directa: crear la instancia, hacer varios push y llamar a peek para confirmar que devuelve el último elemento agregado.

fullscreen
const myStack = new Stack();
myStack.push(1); // top y bottom son 1
myStack.push(2); // top es 2, bottom sigue siendo 1
myStack.push(3); // top es 3
const last = myStack.peek(); // devuelve el nodo con value 3

• resultado esperado: tras insertar 1, 2 y 3, peek devuelve el 3.
• invariante: bottom permanece en el primer valor insertado mientras no se elimine.
• reto propuesto: implementar pop para eliminar el último elemento.
• tip útil: dibujar la lógica en papel antes de codificar aclara el flujo de pointers.

¿Tienes tu versión de pop lista o una variante de validaciones que quieras mostrar? Compártela en comentarios y cuéntanos cómo lo resolviste.