Qué es queue y cómo funciona FIFO

Clase 22 de 29 • Curso de Estructuras de Datos con JavaScript

Resumen

Domina la estructura de datos queue con una guía práctica y directa. Entiende por qué su principio FIFO: primero en llegar, primero en salir resuelve problemas cotidianos y cómo se diferencia de un stack. Además, aclara qué hacen enqueue, dequeue y peek para pensar en una implementación limpia y ordenada.

¿Qué es una queue y por qué importa?

Una queue funciona con orden de llegada: el primero en entrar es el primero en salir. A diferencia de un stack, donde el último que entra es el primero que sale, aquí se respeta la fila. Visualízalo como una fila de muñequitos camino al baño: no sería correcto que el elefante desde atrás pase primero; el rinoceronte diría: “Ey, dude, yo llegué primero”. Esa es la esencia de la queue.

Queue: fila donde se atiende primero a quien llegó primero.
Stack: pila donde se atiende al último que llegó primero.
FIFO: comportamiento central de la queue.
LIFO: comportamiento del stack.
Top y bottom: en queue no escoges desde el bottom; todo entra atrás y sale por el frente.

Esta lógica también aplica a datos: cuando estructuras una lista tipo queue, respetas el orden de llegada para agregar, mirar y retirar elementos.

¿Qué operaciones definen una queue?

Las operaciones base mantienen el orden justo de la fila y te dan control sobre cómo entra y sale la información.

¿Cómo funciona el enqueue?

Agrega un elemento al final de la línea. Si ya tienes un primer elemento (el que ocupa el top de la fila), el siguiente debe formarse atrás. No reemplaza al primero ni se cuela: se añade al final, como en cualquier fila.

¿Cómo funciona el dequeue?

Remueve el primer elemento de la línea. A diferencia del stack, donde quitas el último que llegó, en queue atiendes a quien lleva más tiempo esperando. Es la “siguiente persona” en recibir el servicio.

¿Qué hace el peek?

Permite mirar el primer elemento de la queue. En lugar de ver el último agregado, como en un stack, aquí inspeccionas quién llegó primero, sin retirarlo aún.

Enqueue: agregar al final de la fila.
Dequeue: quitar del frente de la fila.
Peek: ver el primer elemento que entró.

¿Cómo aplicar la lógica en código?

Para implementarla, ajusta lo que ya sabes de stacks: cambia dónde agregas y de dónde sacas. En queue, todo lo nuevo se forma atrás y todo lo que sale viene del frente. Con esos pequeños cambios, la estructura queda casi lista.

Toma el reto: intenta construir tu queue, baja la lógica a código y compártelo en comentarios para revisarlo. En la siguiente sesión, se arma una lista queue paso a paso. ¿Cómo lo implementarías tú y qué estructura usarías para modelar la fila?

Rony Porraz Vargas

student•

Espero te ayude esto :D

Ana Rotela Cabrera

student•

Que bonita infografía

Kyb3r Cipher

student•

Gracias!

Carlos Eduardo Gomez García

teacher•

Un queue básicamente es una cola (o una fila para entenderlo mejor), esto es simple de entender porque nosotros las usamos diariamente sin darnos cuenta, como cuando nos formamos para acceder a un lugar por ejemplo. . Un queue es de tipo FIFO (First In First Out). First In (El primero que entra) First Out (Es el primero que sale). .

Rubén Ernesto Aragón Gil

student•

🧐

Fernando Quinteros Gutierrez

student•

🚶‍♂️ Queues

Ideas/conceptos claves

Una cola o queue es una estructura de datos muy similar a una Pila. Cuando usamos una Pila, ésta opera con una modalidad LIFO (Last In First Out), mientras que con una Cola es FIFO (First In First Out), es decir, siempre el primer elemento que agreguemos, será el primero que saquemos de ella.

Apuntes

Ejemplo: Un escenario común es cuando vamos al banco, Llegamos y lo primero que haces es tomar un turno, inmediatamente nos damos cuenta que ya había 10 personas primero que tú por lo que automáticamente deduces que ellos serán atendidos primero que tú. Si nos damos cuenta en este escenario el primer cliente que llego y solicito un turno sera el que sea atendido primero y tú que llegaste al último serás atendido hasta el final.

Tenemos diferentes métodos para trabajar con el primer elemento, es decir el que entra y sale
- Enqueue ⇒ Agregar un elemento al final de la línea
- Dequeue ⇒ Remover el primer elemento de la línea
- Peek ⇒ Tomar el primer elemento de la línea

RESUMEN: Una cola es similar a una fila es decir que los datos se ordenan de forma lineal pero la principal diferencia es que en esta estructura de datos el primero en entrar es el primer en salir

Alexis Villalva

student•

Gracias por el resumen :D

Juan Esteban Galvis

student•

Listo!! la verdad es reutilizar los métodos del Stack con pequeñas modificaciones, dejo mi resultado con enQueues, deQueues y peek:

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

class Cola{
    constructor () {
        // Elemento Superior
        this.top = null;
        // Elemento Inferior
        this.bottom = null;

        this.length = 0;
    }

    // Seleccionar el primer ingresado
    peek () {
        return this.bottom;
    }

    // Agregar al final de la cola
    enQueues (valor) {
        const NewNodo = new Nodo(valor);

        if (this.length === 0) {
            this.bottom = NewNodo;
            this.top = NewNodo;
            this.length++;
            return this;
        }

        this.top.next = NewNodo;
        this.top = NewNodo;
        this.length++;
        return this;
    }

    // Mostrar el último elemento
    getBottom () {
        return this.top;
    }

    // Eliminar al primero
    deQueues () {
        // Validar si hay elementos para borrar
        if (this.length === 0) {
            return "No hay datos para borrar";
        }

        // Validar si al borrar la Pila quedará vacia
        if (this.length === 1) {
            this.top = null;
            this.bottom = null;
            this.length--;
            return this;
        }
        
        // Borrar
        this.bottom = this.bottom.next;
        this.length--;
        return this;
    }
}

const Newcola = new Cola();
Newcola.enQueues(1)
Newcola.enQueues(2)
Newcola.enQueues(3)
// Result: 1 (bottom) - 2 - 3 (top) [length=3]

Newcola.deQueues()
// Result: 2 (bottom) - 3 (top) [length=2]

Newcola.deQueues()
// Result: 3 (bottom)(top) [length=1]

Newcola.deQueues()
// Result: "No hay datos para borrar" [length=0]

Christian Velázquez

student•

Gracias por el dato.

Juan Jose Arcani

student•

Reto cumplido :rocket:

El método enqueue() tubo su complejidad, aun no comprendo claramente porque this.first.prev se establece correctamente con su valor anterior, lo hace de manera implícita, o al menos eso creo :sweat_smile:

Leonardo de los angeles Espinoza Hernandez

student•

Mi clase de Queue :D

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

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

  peek() {
    return this.top;
  }

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

    const nextValues = this.top.next;
    this.top = nextValues;

    this.length--;
    return this.top;
  }
}

let myQueue = new Queue();

Jimmy Buriticá Londoño

student•

Queues FIFO Primero que entra, primero que sale. Enqueue: Agregar elementos nuevos al final de la línea (Back). Dequeue: Remover elementos del inicio de la línea (Front).

Daniel Omar Hernández Muñoz

student•

Listo! :D

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

  class queue {
    constructor() {
      this.first = null;
      this.last = null;
      this.length = 0;
    }
    peek() {
      return this.first
    }
    pop() {
      const getout = this.first;
      this.first = this.first.next;
      getout.next = null
      this.length--
      return getout;
    }
    push(value) {
      const element = new Node(value);
      if (this.length == 0) {
        this.first = element;
        this.last = element;
      } else {
        this.last.next = element
        this.last = element
      }
      this.length++
      return this;
    }
  }

  const myQueue = new queue();
  myQueue.push(2);
  myQueue.push(32);
  myQueue.push(43);
  myQueue.push(3);
  myQueue.push(4);
  myQueue.push(1);
  myQueue.push(54);
  myQueue.push(12);
  myQueue.push(44);
  myQueue.push(7);
  myQueue.push(6);

  //COMANDOS PARA PROBAR

  myQueue.peek();
  myQueue.pop();

Usuario anónimo

user•

📦 Un queue permite almacenar y recuperar datos, siendo el modo de acceso a sus elementos: primero que entra, primero que sale.

Joel Vicente Nieto Gómez

student•

Esta es mi solucion, para realizar los metodos, peek(), enqueue() y dequeue():

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

class Queue {
  constructor() {
    this.top = null;
    this.bottom = null;
    this.lenght = 0;
  }
  peek() {
    // Método para devolver el ultimo elemento de la cola
    return this.bottom;
  }
  enQueue(value){ // Método para agregar un elemento al final de la linea
    const newNode = new Node(value);
    if (this.lenght === 0) {
      this.top = newNode;
      this.bottom = newNode;
    } else {
      const holdingPointer = this.bottom;
      this.bottom = newNode;
      this.bottom.next = holdingPointer;
    }
    this.lenght++;
    return this;
  }
  deQueue(){ // Método para remover al primer elemento de la linea
    if (this.lenght === 0) {
      return `No hay elementos para eliminar`;
    } else {
      const topNode = this.top;
      if (this.lenght === 1) {
        this.top = null;
        this.bottom = null;
      } else {
        this.top = this.top.next;
      }
      this.lenght--;
      return topNode;
    }
  }
}

const myQueue = new Queue();```

Miguel Enrique Velásquez Millán

student•

Comparto por aquí mi implementación de las Queue ✨~

Cristian Camilo Cortes Ortiz

student•

QUEUES

las colas (queues) son estructuras de datos lineales que siguen el principio FIFO** (First In, First Out), donde el primer elemento añadido es el primero en ser eliminado. Las colas se utilizan para gestionar datos de manera secuencial, asegurando que los elementos se procesen en el orden en que fueron agregados. Las operaciones fundamentales de una cola incluyen enqueue (para añadir un elemento al final de la cola) y dequeue (para eliminar el primer elemento de la cola). Esta estructura es útil en escenarios como la gestión de tareas en cola, la planificación de procesos y el manejo de eventos. En JavaScript*, las colas pueden implementarse utilizando arrays, aprovechando métodos como* push para añadir elementos y shift para eliminarlos del frente de la cola.

Ulqernesh Karvenae

student•

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

class Queues {
  constructor(){
    this.top = null
    this.bottom = null
    this.length = 0;
  }
  peek(){
    return this.top
  }
  enqueue(value){
    const newNode = new Node(value)
    if (this.length === 0){
      this.top = newNode
      this.bottom = newNode
      console.log(this.top.next , newNode)

    } else {
      this.bottom.next = newNode; 
      this.bottom = newNode; 
      console.log(this.top.next , newNode)
    }

    this.length++
    return this
  }
  dequeue(){
    const topNew = this.top.next
    this.top = topNew
    this.length--
    
    return this
  }
}

const newQueues = new Queues()
newQueues.enqueue(1)
newQueues.enqueue(2)
newQueues.enqueue(3)
newQueues.enqueue(4)
newQueues.enqueue(5)
newQueues.enqueue(6)
newQueues.enqueue(7)
newQueues.enqueue(8)
newQueues.enqueue(9)

Esteban Bustos

student•

Aquí esta mi código de la estructura Queue, como dijo el profesor es muy similar al stack lo único que cambio fue la lógica para agregar elementos todo lo demás es exactamente igual.

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

class Queue {
    constructor() {
        this.top = null;
        this.bottom = null;
        this.length = 0;
    }
    peek() {
        return this.top;
    }
    queue(value) {
        const node = new Node(value);
        if(this.length === 0){
            this.top = node;
            this.bottom = node;
        } else {
            this.bottom.next = node;
            this.bottom = node;
        }
        this.length++;
        return this.bottom;
    }
    dequeue() {
        if(this.length>0){
            const deletedNode = this.top;
            this.top = this.top.next;
            this.length--;
            return deletedNode;
        }
        return undefined;
    }
}

const myQueue = new Queue();
console.log('Crear instancia de un Queue');
console.log('queue', myQueue.queue('Elemento 1'));
console.log('queue', myQueue.queue('Elemento 2'));
console.log('queue', myQueue.queue('Elemento 3'));
console.log('queue', myQueue.queue('Elemento 4'));
console.log('queue', myQueue.queue('Elemento 5'));
console.log('peek', myQueue.peek());
console.log('dequeue', myQueue.dequeue());
console.log('dequeue', myQueue.dequeue());
console.log('dequeue', myQueue.dequeue());
console.log('dequeue', myQueue.dequeue());
console.log('dequeue', myQueue.dequeue());
console.log('dequeue', myQueue.dequeue());

Andrés Schuster

student•

El código define una clase Node para crear nodos que tendrán un valor y una referencia al siguiente nodo. Luego, define una clase Queue que implementa una estructura de datos de cola.

La clase Queue tiene tres propiedades: first, last y length. first es una referencia al primer elemento de la cola, last es una referencia al último elemento de la cola, y length es la cantidad de elementos en la cola.

El método peek() devuelve el primer elemento de la cola sin eliminarlo.

El método enqueue(value) agrega un nuevo nodo con el valor value al final de la cola. Si la cola está vacía, tanto first como last apuntan al nuevo nodo. Si no está vacía, el nodo se agrega al final de la cola y se actualiza la referencia last.

El método dequeue() elimina el primer elemento de la cola y devuelve la cola actualizada. Si la cola está vacía, devuelve null. Si la cola solo tiene un elemento, last se actualiza a null.

El método isEmpty() devuelve true si la cola está vacía, false en caso contrario.

El método print() imprime en la consola los valores de cada nodo de la cola.

El método printList() devuelve un arreglo con los valores de cada nodo de la cola en el orden en que se encuentran.

// Definición de la clase Node que representa un nodo de la cola
class Node {
  constructor(value) {
    this.value = value; // Valor que contiene el nodo
    this.next = null; // Referencia al siguiente nodo (inicialmente nula)
  }
}

// Definición de la clase Queue que implementa una cola
class Queue {
  constructor() {
    this.first = null; // Referencia al primer elemento de la cola (inicialmente nula)
    this.last = null; // Referencia al último elemento de la cola (inicialmente nula)
    this.length = 0; // Cantidad de elementos en la cola (inicialmente cero)
  }

  // Devuelve el primer elemento de la cola sin eliminarlo
  peek() {
    return this.first;
  }

  // Agrega un nuevo elemento al final de la cola
  enqueue(value) {
    const newNode = new Node(value); // Se crea un nuevo nodo con el valor proporcionado
    if (this.length === 0) { // Si la cola está vacía
      this.first = newNode; // Se establece que el primer elemento es el nuevo nodo
      this.last = newNode; // Se establece que el último elemento es el nuevo nodo
    } else { // Si la cola no está vacía
      this.last.next = newNode; // Se establece que el último nodo apunta al nuevo nodo
      this.last = newNode; // Se establece que el último elemento es el nuevo nodo
    }
    this.length++; // Se incrementa la longitud de la cola
    return this; // Se devuelve la cola actualizada
  }

  // Elimina el primer elemento de la cola y lo devuelve
  dequeue() {
    if (!this.first) { // Si la cola está vacía
      return null; // Se devuelve null
    }
    if (this.first === this.last) { // Si la cola tiene un solo elemento
      this.last = null; // Se establece que el último elemento es null
    }
    const holdingPointer = this.first; // Se crea una referencia temporal al primer nodo
    this.first = this.first.next; // Se establece que el primer elemento es el siguiente nodo
    this.length--; // Se decrementa la longitud de la cola
    return holdingPointer; // Se devuelve el primer elemento eliminado
  }

  // Devuelve true si la cola está vacía, false en caso contrario
  isEmpty() {
    return this.length === 0;
  }

  // Imprime los valores de cada nodo de la cola en la consola
  print () {
    let current = this.first; // Se establece una referencia al primer nodo
    while (current) { // Mientras existan nodos
      console.log(current.value); // Se imprime el valor del nodo actual
      current = current.next; // Se establece que el nodo actual es el siguiente
    }
  }

  // Devuelve un array con los valores de cada nodo de la cola en orden
  printList () {
    const array = []; // Se crea un array vacío
    let current = this.first; // Se establece una referencia al primer nodo
    while (current) { // Mientras existan nodos
      array.push(current.value); // Se agrega el valor del nodo actual al array
      current = current.next; // Se establece que el nodo actual es el siguiente
    }
    return array; // Se devuelve el array con los valores
  }
}

Gustavo Adolfo Torres Quintana

student•

Andres, genial aporte + Un abrazo!

Juan Esteban Gallego Perez

student•

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

class Queue {
    constructor() {
        this.top = null
        this.bottom = null
        this.length = 0
    }
    
    enqueue(value) {
        const newNode = new Node(value)
        
        if(this.bottom === null) {
            this.bottom = newNode
            this.top = newNode
        } else {
            this.top.next = newNode
            this.top = newNode
        }
        this.length++
        
        return this
    }
    
    //removes first element in the list
    dequeue() {
        if(this.bottom.next) {
            const secondElement = this.bottom.next
            this.bottom = secondElement
        } else {
            this.bottom = null
            this.top = null
        }
        this.length--
        
        return this
    }
    
    peek() {
        return this.bottom
    }
}

myQueue = new Queue()
myQueue.enqueue(1)
myQueue.enqueue(2)
myQueue.enqueue(3)
console.log(myQueue.peek())

Pariksit Erikrsnan Ortiz Flores

student•

Mi aporte:

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

class Queue {
    constructor(){
        this.first=null;
        this.last = null;
        this.length = 0;
    }

    peek() {
        return this.first;
    }

    enqueue(value) {
        const newNode = new Node(value);
        if(this.length===0){
            this.first = newNode;
            this.last = newNode;
        } else {
            this.last.next = newNode;
            this.last = newNode;
        }
        this.length++;
        return this;
    }

    dequeue(){
        if(this.length===0){
            console.log("Queue Vacío");
        }else if(this.length===1){
            console.log(`Eliminado primer elemento: "${this.first.value}"`);
            this.first=null;
            this.last=null;
            this.length=0;
        }else {
            console.log(`Eliminado primer elemento: "${this.first.value}"`);
            const newFirst = this.first.next;
            this.first=newFirst;
            this.length--;
        }
        return this;
    }
}


const myQueue = new Queue();

Agustin Choque Veliz

student•

Aquí mi propuesta antes de ver de queue y sus métodos.

class Node {
    constructor(value){
        this.value = value;
        this.next = null;
    }
}
class Queue{
    constructor(){
        this.head = null;
        this.tail = null;
        this.lenght=0;
    }
    enqueue(value){
        const node = new Node(value);
        if (this.lenght === 0){
            this.head = node;
            this.tail = node;
        } else{
            this.tail.next = node;
            this.tail = node;
        }
        this.lenght++;
        return this;
    }
    dequeue(){
        if (this.lenght > 0){
            const node = this.head;
            this.head = this.head.next;
            this.lenght--;
            if (this.lenght == 0){
                this.tail = this.head;
            }
            node.next = null;
            return node;
        } else{
            return this.head;
        }
    }
    peek(){
        return this.head;
    }
}

const queue = new Queue();
const node1 = new Node(1);
queue.enqueue(node1);
const node2 = new Node(2);
queue.enqueue(node2);
const node3 = new Node(3);
queue.enqueue(node3);
const node4 = new Node(4);
queue.enqueue(node4);

console.log(queue);

queue.dequeue();

Víctor Andrés Córdova Poma

student•

Aquí mi aporte, con la función isEmpty:

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

class Queue { //FIFO: First In, First Out
    constructor(){
        this.bottom = null;
        this.top = null;
        this.length = 0;
    }

    enqueue(value){ //Agrega un nodo al final de la fila
        const newNode = new Node(value);

        if (this.length === 0) {
            this.bottom = newNode;
            this.top = this.bottom;
        } else {
            this.top.next = newNode;
            this.top = newNode;
        }
        this.length++;
    
        return newNode;
    }

    dequeue() {
        if (this.length === 0) return null;
        let currentNode;
        if (this.length === 1) {
            currentNode = this.bottom;

            this.bottom = null;
            this.top = null;
        } else if (1 < this.length) {
            currentNode = this.bottom;

            this.bottom = this.bottom.next;
        }
        this.length--;

        return currentNode;
    }

    perk() {
        return this.bottom;
    }

    isEmpty () {
        return this.length === 0;
    }
}

const queue = new Queue();

N40 M10

student•

Otro ejemplo de queue son las playlist de spotify, literalmente si bloqueas los scripts que le dan nombres a los botones puedes ver que los botones para las playlist dicen y usan queue

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

class Cola{
    constructor () {
        // Elemento Superior
        this.top = null;
        // Elemento Inferior
        this.bottom = null;

        this.length = 0;
    }

    // Seleccionar el primer ingresado
    peek () {
        return this.bottom;
    }

    // Agregar al final de la cola
    enQueues (valor) {
        const NewNodo = new Nodo(valor);

        if (this.length === 0) {
            this.bottom = NewNodo;
            this.top = NewNodo;
            this.length++;
            return this;
        }

        this.top.next = NewNodo;
        this.top = NewNodo;
        this.length++;
        return this;
    }

    // Mostrar el último elemento
    getBottom () {
        return this.top;
    }

    // Eliminar al primero
    deQueues () {
        // Validar si hay elementos para borrar
        if (this.length === 0) {
            return "No hay datos para borrar";
        }

        // Validar si al borrar la Pila quedará vacia
        if (this.length === 1) {
            this.top = null;
            this.bottom = null;
            this.length--;
            return this;
        }
        
        // Borrar
        this.bottom = this.bottom.next;
        this.length--;
        return this;
    }
}

const Newcola = new Cola();
Newcola.enQueues(1)
Newcola.enQueues(2)
Newcola.enQueues(3)
// Result: 1 (bottom) - 2 - 3 (top) [length=3]

Newcola.deQueues()
// Result: 2 (bottom) - 3 (top) [length=2]

Newcola.deQueues()
// Result: 3 (bottom)(top) [length=1]

Newcola.deQueues()
// Result: "No hay datos para borrar" [length=0]

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

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

  peek() {
    return this.top;
  }

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

    const nextValues = this.top.next;
    this.top = nextValues;

    this.length--;
    return this.top;
  }
}

let myQueue = new Queue();

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

  class queue {
    constructor() {
      this.first = null;
      this.last = null;
      this.length = 0;
    }
    peek() {
      return this.first
    }
    pop() {
      const getout = this.first;
      this.first = this.first.next;
      getout.next = null
      this.length--
      return getout;
    }
    push(value) {
      const element = new Node(value);
      if (this.length == 0) {
        this.first = element;
        this.last = element;
      } else {
        this.last.next = element
        this.last = element
      }
      this.length++
      return this;
    }
  }

  const myQueue = new queue();
  myQueue.push(2);
  myQueue.push(32);
  myQueue.push(43);
  myQueue.push(3);
  myQueue.push(4);
  myQueue.push(1);
  myQueue.push(54);
  myQueue.push(12);
  myQueue.push(44);
  myQueue.push(7);
  myQueue.push(6);

  //COMANDOS PARA PROBAR

  myQueue.peek();
  myQueue.pop();

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

class Queue {
  constructor() {
    this.top = null;
    this.bottom = null;
    this.lenght = 0;
  }
  peek() {
    // Método para devolver el ultimo elemento de la cola
    return this.bottom;
  }
  enQueue(value){ // Método para agregar un elemento al final de la linea
    const newNode = new Node(value);
    if (this.lenght === 0) {
      this.top = newNode;
      this.bottom = newNode;
    } else {
      const holdingPointer = this.bottom;
      this.bottom = newNode;
      this.bottom.next = holdingPointer;
    }
    this.lenght++;
    return this;
  }
  deQueue(){ // Método para remover al primer elemento de la linea
    if (this.lenght === 0) {
      return `No hay elementos para eliminar`;
    } else {
      const topNode = this.top;
      if (this.lenght === 1) {
        this.top = null;
        this.bottom = null;
      } else {
        this.top = this.top.next;
      }
      this.lenght--;
      return topNode;
    }
  }
}

const myQueue = new Queue();```

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

class Queues {
  constructor(){
    this.top = null
    this.bottom = null
    this.length = 0;
  }
  peek(){
    return this.top
  }
  enqueue(value){
    const newNode = new Node(value)
    if (this.length === 0){
      this.top = newNode
      this.bottom = newNode
      console.log(this.top.next , newNode)

    } else {
      this.bottom.next = newNode; 
      this.bottom = newNode; 
      console.log(this.top.next , newNode)
    }

    this.length++
    return this
  }
  dequeue(){
    const topNew = this.top.next
    this.top = topNew
    this.length--
    
    return this
  }
}

const newQueues = new Queues()
newQueues.enqueue(1)
newQueues.enqueue(2)
newQueues.enqueue(3)
newQueues.enqueue(4)
newQueues.enqueue(5)
newQueues.enqueue(6)
newQueues.enqueue(7)
newQueues.enqueue(8)
newQueues.enqueue(9)

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

class Queue {
    constructor() {
        this.top = null;
        this.bottom = null;
        this.length = 0;
    }
    peek() {
        return this.top;
    }
    queue(value) {
        const node = new Node(value);
        if(this.length === 0){
            this.top = node;
            this.bottom = node;
        } else {
            this.bottom.next = node;
            this.bottom = node;
        }
        this.length++;
        return this.bottom;
    }
    dequeue() {
        if(this.length>0){
            const deletedNode = this.top;
            this.top = this.top.next;
            this.length--;
            return deletedNode;
        }
        return undefined;
    }
}

const myQueue = new Queue();
console.log('Crear instancia de un Queue');
console.log('queue', myQueue.queue('Elemento 1'));
console.log('queue', myQueue.queue('Elemento 2'));
console.log('queue', myQueue.queue('Elemento 3'));
console.log('queue', myQueue.queue('Elemento 4'));
console.log('queue', myQueue.queue('Elemento 5'));
console.log('peek', myQueue.peek());
console.log('dequeue', myQueue.dequeue());
console.log('dequeue', myQueue.dequeue());
console.log('dequeue', myQueue.dequeue());
console.log('dequeue', myQueue.dequeue());
console.log('dequeue', myQueue.dequeue());
console.log('dequeue', myQueue.dequeue());

// Definición de la clase Node que representa un nodo de la cola
class Node {
  constructor(value) {
    this.value = value; // Valor que contiene el nodo
    this.next = null; // Referencia al siguiente nodo (inicialmente nula)
  }
}

// Definición de la clase Queue que implementa una cola
class Queue {
  constructor() {
    this.first = null; // Referencia al primer elemento de la cola (inicialmente nula)
    this.last = null; // Referencia al último elemento de la cola (inicialmente nula)
    this.length = 0; // Cantidad de elementos en la cola (inicialmente cero)
  }

  // Devuelve el primer elemento de la cola sin eliminarlo
  peek() {
    return this.first;
  }

  // Agrega un nuevo elemento al final de la cola
  enqueue(value) {
    const newNode = new Node(value); // Se crea un nuevo nodo con el valor proporcionado
    if (this.length === 0) { // Si la cola está vacía
      this.first = newNode; // Se establece que el primer elemento es el nuevo nodo
      this.last = newNode; // Se establece que el último elemento es el nuevo nodo
    } else { // Si la cola no está vacía
      this.last.next = newNode; // Se establece que el último nodo apunta al nuevo nodo
      this.last = newNode; // Se establece que el último elemento es el nuevo nodo
    }
    this.length++; // Se incrementa la longitud de la cola
    return this; // Se devuelve la cola actualizada
  }

  // Elimina el primer elemento de la cola y lo devuelve
  dequeue() {
    if (!this.first) { // Si la cola está vacía
      return null; // Se devuelve null
    }
    if (this.first === this.last) { // Si la cola tiene un solo elemento
      this.last = null; // Se establece que el último elemento es null
    }
    const holdingPointer = this.first; // Se crea una referencia temporal al primer nodo
    this.first = this.first.next; // Se establece que el primer elemento es el siguiente nodo
    this.length--; // Se decrementa la longitud de la cola
    return holdingPointer; // Se devuelve el primer elemento eliminado
  }

  // Devuelve true si la cola está vacía, false en caso contrario
  isEmpty() {
    return this.length === 0;
  }

  // Imprime los valores de cada nodo de la cola en la consola
  print () {
    let current = this.first; // Se establece una referencia al primer nodo
    while (current) { // Mientras existan nodos
      console.log(current.value); // Se imprime el valor del nodo actual
      current = current.next; // Se establece que el nodo actual es el siguiente
    }
  }

  // Devuelve un array con los valores de cada nodo de la cola en orden
  printList () {
    const array = []; // Se crea un array vacío
    let current = this.first; // Se establece una referencia al primer nodo
    while (current) { // Mientras existan nodos
      array.push(current.value); // Se agrega el valor del nodo actual al array
      current = current.next; // Se establece que el nodo actual es el siguiente
    }
    return array; // Se devuelve el array con los valores
  }
}

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

class Queue {
    constructor() {
        this.top = null
        this.bottom = null
        this.length = 0
    }
    
    enqueue(value) {
        const newNode = new Node(value)
        
        if(this.bottom === null) {
            this.bottom = newNode
            this.top = newNode
        } else {
            this.top.next = newNode
            this.top = newNode
        }
        this.length++
        
        return this
    }
    
    //removes first element in the list
    dequeue() {
        if(this.bottom.next) {
            const secondElement = this.bottom.next
            this.bottom = secondElement
        } else {
            this.bottom = null
            this.top = null
        }
        this.length--
        
        return this
    }
    
    peek() {
        return this.bottom
    }
}

myQueue = new Queue()
myQueue.enqueue(1)
myQueue.enqueue(2)
myQueue.enqueue(3)
console.log(myQueue.peek())

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

class Queue {
    constructor(){
        this.first=null;
        this.last = null;
        this.length = 0;
    }

    peek() {
        return this.first;
    }

    enqueue(value) {
        const newNode = new Node(value);
        if(this.length===0){
            this.first = newNode;
            this.last = newNode;
        } else {
            this.last.next = newNode;
            this.last = newNode;
        }
        this.length++;
        return this;
    }

    dequeue(){
        if(this.length===0){
            console.log("Queue Vacío");
        }else if(this.length===1){
            console.log(`Eliminado primer elemento: "${this.first.value}"`);
            this.first=null;
            this.last=null;
            this.length=0;
        }else {
            console.log(`Eliminado primer elemento: "${this.first.value}"`);
            const newFirst = this.first.next;
            this.first=newFirst;
            this.length--;
        }
        return this;
    }
}


const myQueue = new Queue();

class Node {
    constructor(value){
        this.value = value;
        this.next = null;
    }
}
class Queue{
    constructor(){
        this.head = null;
        this.tail = null;
        this.lenght=0;
    }
    enqueue(value){
        const node = new Node(value);
        if (this.lenght === 0){
            this.head = node;
            this.tail = node;
        } else{
            this.tail.next = node;
            this.tail = node;
        }
        this.lenght++;
        return this;
    }
    dequeue(){
        if (this.lenght > 0){
            const node = this.head;
            this.head = this.head.next;
            this.lenght--;
            if (this.lenght == 0){
                this.tail = this.head;
            }
            node.next = null;
            return node;
        } else{
            return this.head;
        }
    }
    peek(){
        return this.head;
    }
}

const queue = new Queue();
const node1 = new Node(1);
queue.enqueue(node1);
const node2 = new Node(2);
queue.enqueue(node2);
const node3 = new Node(3);
queue.enqueue(node3);
const node4 = new Node(4);
queue.enqueue(node4);

console.log(queue);

queue.dequeue();

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

class Queue { //FIFO: First In, First Out
    constructor(){
        this.bottom = null;
        this.top = null;
        this.length = 0;
    }

    enqueue(value){ //Agrega un nodo al final de la fila
        const newNode = new Node(value);

        if (this.length === 0) {
            this.bottom = newNode;
            this.top = this.bottom;
        } else {
            this.top.next = newNode;
            this.top = newNode;
        }
        this.length++;
    
        return newNode;
    }

    dequeue() {
        if (this.length === 0) return null;
        let currentNode;
        if (this.length === 1) {
            currentNode = this.bottom;

            this.bottom = null;
            this.top = null;
        } else if (1 < this.length) {
            currentNode = this.bottom;

            this.bottom = this.bottom.next;
        }
        this.length--;

        return currentNode;
    }

    perk() {
        return this.bottom;
    }

    isEmpty () {
        return this.length === 0;
    }
}

const queue = new Queue();

Qué es queue y cómo funciona FIFO

Introducción a las estructuras de datos

Estructuras de Datos en JavaScript para Desarrolladores

Estructuras de Datos: Conceptos Básicos y Aplicaciones Prácticas

Almacenamiento de Datos en Memoria con JavaScript

Arrays y strings

Cómo funcionan arrays en memoria de JavaScript

Construcción de Arrays con Clases en JavaScript

Métodos pop y delete en arrays

Playground: crea tu propia implementación de unshift

Playground: crea tu propia implementación de shift

Inmutabilidad de Strings y Almacenamiento en Memoria

Hash Table

Conceptos y Construcción de Hash Tables en JavaScript

Implementación de Hash Table en JavaScript: Método Set

Implementación del método get en hash table JavaScript

Playground: implementa el metodo Delete

Playground: implementa el método getAllKeys

Linked List

Estructuras de Datos: Listas Enlazadas en JavaScript

Estructura y Creación de una Lista Enlazada Simple en JavaScript

Métodos para Manipular Nodos en Listas Enlazadas

Inserta nodos intermedios sin romper enlaces en JavaScript

Doubly Linked List con punteros bidireccionales

Stacks

Stacks: Concepto y Operaciones Básicas en JavaScript

Implementación de Stacks en JavaScript: Métodos Push y Peek

Queues