Queues

Espero te ayude esto 😄

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).
.

🚶‍♂️ 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

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]

Reto cumplido 🚀

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 😅

Mi clase de Queue 😄

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();

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).

Listo! 😄

  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();

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

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();```

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
  }
}

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())

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();

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();

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();

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

Mi solucion al reto:

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

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

  enqueue(value){
    // Add element at the end
    const newNode =  new Node(value);
    if(this.length === 0){
      this.first =  newNode;
      this.last = newNode;
    } else {
      this.last.prev = newNode;
      this.last = newNode;
    }
    this.length++;
    return this;
  }

  dequeue(){
    // remove first element
    if(this.length === 1){
      this.first = null;
      this.last = null;
    } else {
      this.first = this.first.prev;
    }
    this.length--;
    return this;
  }

  peek(){
    // get first element
    return this.first;
  }
}

const myQueue = new Queue();

Solución al reto, aplicando la lógica vista en clase:
.
.
.

class Node {
    constructor(value){
        this.value = value;
        this.next = null;
        this.prev = null;
        //each node will have next and prev as null to chain new nodes
    }
}

class Queue {
    constructor(){
        this.head = null;
        this.tail = null;
        this.length = 0;
        //head and tail are different elements
    }
    peek(){
        if(this.length === 0){
            return undefined
        } else {
            return this.head;
            //only one element to see when the queue is greater than 0, which for a queue must be the head
        }
    }
    enqueue(value){
        const newNode = new Node(value);
        if(this.length === 0){
            this.head = newNode;
            this.tail = this.head;
            //when there're no nodes in the queue the new node must be the head and the tail at the same time
        } else if(this.length === 1){
            const formerNode = this.tail;
            newNode.next = formerNode;
            formerNode.prev = newNode;
            this.tail = newNode;
            //the enqueueing is pointed to the tail and references are made from the new node to the tail itself, allowing to add more elements referencing the tail
          } else {
            const formerQueue = this.tail;
            newNode.next = formerQueue;
            formerQueue.prev = newNode;
            this.tail = newNode;
            //the same code for when the length is greater than 1, this time as the tail is our last node, it also contains the reference to the rest of the queue.
        }
        this.length++;
        return this;
    }
    dequeue(){
        this.length--;
        //reducing the length of the list to trigger the following validation, if not a type erro will be triggered when 'this.head.prev' points to null, hence the latter doesn't have any reference in the queue

        if(this.length === 0){
            return undefined;
        } 
        const formerQueue = this.head.prev;
        //referencing the rest of the queue without the head        
        
        formerQueue.next = null;
        //releasing the next reference of the queue to the head

        this.head = formerQueue;
        //new head will be the former queue, which is in fact the queue without the previous head

        return this;
    }
}

let myQueue = new Queue();

A Javascrip: Eyyyy… a respetar la fila… No se coleeennnn jejee.

Se le tiene aporte en Java :v

class Queues {
    int length;
    Node top;
    Node bottom;

    Queues() {
        this.bottom = null;
        this.top = null;
        this.length = 0;
    }

    public class Node {
        int date;
        Node next;

        Node(int value) {
            this.date = value;
            this.next = null;
        }
    }

    /* Metodos Queue */
    /* retornar primer elemento agregado */
    public Node peek() {
        return this.top;
    }

    /*
     * Agregar un elemento al
     * final de la linea(bottom) [|_______|] <--
     */
    public void enqueue(int value) {
        Node newNode = new Node(value);
        if (this.length == 0) {
            this.top = newNode;
            this.bottom = newNode;

        } else {
            this.bottom.next = newNode;
            this.bottom=newNode;
        }
        this.length++;

    }

    /* Remover al primer elemento de la linea (top) */
    public void dequeue() {
        Node newTop= this.top.next;
        this.top= newTop; 
        this.length--;
    }
    /*Imprimir los date de cada nodo */
    public void print() {
        int counter = 0;
        Node currentNode=this.top;
        while (counter < this.length) {
            System.out.println("--> " + currentNode.date);
            currentNode=currentNode.next ;
            counter++;
        }
    }

    public static void main(String[] args) {
        Queues myQueues = new Queues();
        myQueues.enqueue(1);
        myQueues.enqueue(2);
        myQueues.enqueue(3);
        myQueues.enqueue(4);
        myQueues.enqueue(5);
        myQueues.print();
        System.out.println("\n After queue \n");
        myQueues.dequeue();
        myQueues.dequeue();
        myQueues.print();
        
    }
}

dejo mi aporte al reto

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

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

    peek(){
        if (this.length === 0){
            return 'empty stack'
        }
        return this.bottom
    }

    enqueue(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 
    }

    dequeue(){
        if (this.length === 0){
            return 'empty stack'
        }

        if (this.length === 1){
            this.top = null
            this.bottom = null
            this.length--
            return this 
        }

        let node = this.top
        let counter = 0 
        while (counter !== this.length-2){
            node = node.next 
            counter++
        }

        this.bottom = node 

        this.length--
        return this
    }
}

const MyQueues = new Queues()

hola este es mi aporte, si hay alun error comentenpleaseee

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.bottom;
  }
  enqueue(value) {
    const newNode = new Node(value);
    if (this.length === 0) {
      this.top = newNode;
      this.bottom = newNode;
    } else {
      this.bottom.next = newNode;
      this.bottom = newNode;
    }
    this.length++;
    return this;
  }
  dequeue() {
    if (!this.bottom) {
      return null;
    }
    if (this.length === 0) {
      console.log("no hay elemmentos apilados");
    }
    if (this.top === this.bottom) {
      this.top = null;
    }
    this.top = this.top.next;
    this.length--;
    return this;
  }
}

const myQueues = new Queues();
myQueues.enqueue(1);
myQueues.enqueue(2);
myQueues.enqueue(3);
myQueues.dequeue();
console.log(myQueues);

Mis soluciones de enqueue, dequeue y peek:

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

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

  enqueue(value) {
    if (!value) return console.error(`Escriba un valor`);
    const element = new Element(value);
    if (!this.first) {
      this.first = element;
      this.last = element;
    } else {
      this.last.next = element;
      this.last = element;
    }
    this.length++;
    return this;
  }

  dequeue() {
    if (this.length === 0) return console.error(`NO hay mas element`);
    if (this.length === 1) {
      this.first = null;
      this.last = null;
    } else {
      this.first = this.first.next;
    }
    this.length--;
    return this;
  }

  peek() {
    return this.first;
  }
}

const queues = new Queues();

queues.enqueue(1);
queues.enqueue(2);
queues.enqueue(3);

Mi solucion al reto con la implementacion de un metodo para imprimir la queue y poder visualizarla como un array normal

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.last = newNode;
      this.first = newNode;
    } else {
      this.last.next = newNode;
      this.last = newNode;
    }
    this.length++;
    return this;
  }
  dequeue() {
    if (this.length == 0) {
      return "Queue is empty";
    }
    let dequeued = this.first;
    if (this.length == 1) {
      this.first = null;
      this.last = null;
      this.length = 0;
    } else {
      this.first = this.first.next;
    }
    this.length--;
    return dequeued;
  }
  print() {
    let current = this.first;
    let queue = [];
    while (current != null) {
      queue.push(current.value);
      current = current.next;
    }
    console.log(queue);
  }
}

La simpleza con la que Diego explica las cosas! Un grande.

peek, enQueue y deQueue antes de ver el video

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

class Queue{
    constructor(){
        this.first={
            value: null,
            next: null
        }
        this.lenght = 0;
    }
    peek(){//seleccionar el primer elemento de la cola
        if(this.lenght === 0){  
            return this.first.value;
        }else{
            return this.first.value;
        }
    }
    enQueue(value){//agregar un elemento al final
         const newNode = new Node(value);
         if(this.lenght === 0){  
            this.first = newNode;
         }else{
            const actualLast = this.getIndex(this.lenght-1);
            actualLast.next = newNode
         }
         this.lenght++;
         return this;
    }
    deQueue(){//eliminar el primer elemento
        if(this.lenght === 0){  
            this.value = value;
            this.next =  null;
        }else{
           const secondNode = this.getIndex(1);
           this.first = secondNode
        }
        this.lenght--;
        return this;
    }
    getIndex(index){
        let counter = 0;
        let currentNode = this.first;
        while(counter !== index){
            currentNode = currentNode.next;
            counter++;
        }
        return currentNode;
    }
}

var miQueue = new Queue();
miQueue.peek();
miQueue.enQueue('Nueva Tarea');
miQueue.enQueue('Nueva Tarea2');
miQueue.enQueue('Nueva Tarea3');
miQueue.deQueue();
miQueue.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) {
            return undefined;
        }
        const removedNode = this.first;
        if (this.length === 1) {
            this.first = null;
            this.last = null;
        } else {
            this.first = removedNode.next;
        }
        this.length--;
        return removedNode;
    }

    peek() {
        return this.first;
    }
}e> 

<code> 
class QueueNode{
    public next : QueueNode | null
    public value : number
    constructor(value : number){
        this.value = value
        this.next = null
    }
}

export default class Queue{
    public top : QueueNode | null
    public bottom : QueueNode | null
    public length : number
    constructor(){
        this.bottom = null
        this.top = null
        this.length = 0
    }
    //adds element to end of queue
    public enqueue(value : number){
        let newNode : QueueNode = new QueueNode(value)
        if(this.length === 0){
            this.bottom = newNode
            this.top = newNode
        }else{
            if(this.top){
                this.top.next = newNode
                this.top = newNode
            }
        }
        this.length = this.length + 1
    }
    //removes first element from queue
    public dequeue(){
        if(this.bottom){
            if(this.bottom.next){
                this.bottom = this.bottom.next
            }else{
                console.error("there is no nodes to make bottom")
            }
            this.length = this.length - 1
        }else{
            console.error("there are no nodes to delete")
        }
    }
    //return first element inserted into Queue
    public peek(){
        return this.bottom
    }
}

export {QueueNode}

Implementación de Queue:

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 (newNode) {
			if (this.length === 0) {
				this.top = newNode;
				this.bottom = newNode;
			} else {
				this.bottom.next = newNode;
				this.bottom = newNode;
			}
			this.length++;
		}
		return this;
	}

	dequeue() {
		if (this.length === 0) {
			return "Queue vacía.";
		} else {
			this.top = this.top.next;
		}
		this.length--;
		return this;
	}
}

const myQueue = new Queue();

Mis soluciones de enqueue, dequeue y 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) return this;

        if ( this.length === 1 ){
            this.first= null;
            this.last= null
            this.length--
            return this;
        } 
        const dequeued = this.first.value;
        this.first = this.first.next;
        this.length--
        return dequeued;
    }

}

Clase 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;
    }
    enqueue(value) {
        const newNode = new Node(value);

        if (newNode.value) {
            if (this.length === 0) {
                this.first = newNode;
                this.last = newNode;
            } else {
                const holdingPointer = this.last;
                
                this.last = newNode;
                holdingPointer.next = this.last;
            }
            this.length ++;

            return this;
        }
        
    }
    dequeue() {
        const holdingPointer = this.peek();;

        if (this.length > 1) {
            this.first = this.first.next;

            holdingPointer.next = null;
        } else {
            this.first = null;
            this.last = null;
        }

        if (this.length > 0) {
            this.length--;
        }

        return holdingPointer;
    }
}

let myQueue = new Queue();

Les comparto mi codigo para la clase Queue que hice tratando de no ver el video :3

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

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

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

        this.length +=1

    }

    deque(){
        if(this.length === 1){
            delete this.first && this.last
        } else if (this.length > 1) {
            const saver = this.first
            this.first = this.first.before
            this.first.before = saver.before.before
            this.first.next = null
        }

        this.length-=1
    }

    peek(){
        const first = this.first
        return first
    }
}

const myQueue = new Queue();

Queues

Entendí : ) yahu

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

class Queue {
    constructor(){
        this.top = this.bottom = null;
        this.next = null;
        this.length = 0;
    }
    peek() {
        return this.bottom;
    }
    enqueue(value) {
        const newNode = new Node(value);
        if(this.length === 0) {
            this.top = this.bottom = newNode;
        }
        else {
            this.top.next = newNode;
            this.top = newNode;
        }
        this.length++;
        return this;
    }
    dequeue() {
        if(this.length === 0) {
            return console.log("El stask esta vacio");
        }
        this.bottom = this.bottom.next;
        this.length--;
        return this;
    }
}

const myQueue = new Queue();

Buen dia campeon. estructura de datos single linked list head y tail como referencia.

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

class Queue {
  constructor() {
    this.head = null;
    this.tail = null;
    this.length = 0;
  }
  enqueue(value) {
    const newNode = new Node(value);
    if (value === undefined) {
      return null;
    }
    if (!this.length) {
      this.head = newNode;
      this.tail = newNode;
    } else {
      newNode.next = this.head;
      this.head = newNode;
    }
    this.length++;

    return this;
  }
  dequeue() {
    let message = {Error: 'The Queue is Empty'};
    const queueList = this.tail;

    if (this.length === 0) {
      throw new Error(message.Error);
    } else if (this.length === 1) {
      this.head = null;
      this.tail = null;
    } else {
      let node = this.head;
      for (let i = 1; i < this.length - 1; i++) {
        node = node.next;        
      }
      node.next = null;
      this.tail = node;
    }
    this.length--;

    return queueList;
  }
  peek() {
    return this.tail
  }
  print() {
    let current = this.head;
    let counter = 1;

    while (current) {
      console.log(`length ${counter++} <--> ${current.value} `);
      current = current.next;
    }
  }
}

const myQueueList = new Queue();

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

class Queue{
  constructor(){
    this.first = null;
    this.last = null;
    this.length = 0;
  }
  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;
  }
  peek(){
    return this.first;
  }
  dequeue(){
    if (!this.length) 
      throw new Error ("The Stack is empty");
    const firstNode = this.first;
    if (this.length === 1){
      this.first = null;
      this.last = null;
    }else{
      this.first = this.first.next;
    }
    this.length--;
    return firstNode;
  }
}

Mi codigo de Queues

class Node{
    constructor(value){
        this.value = value;
        this.next = null;
    }
}
class Queue{
    constructor(){
        this.head = null;
        this.tail = null;
        this.length = 0;
    }
    peek(){        
        return this.head;        
    }
    enqueue(value){
        const newNode = new Node(value);
        if(this.length === 0){
            this.tail = newNode;
            this.head = newNode;
        }else{            
            this.tail.next = newNode;
            this.tail = newNode;
        }   
        this.length++;     
        return this;
    }
    dequeue(){
        let pointer = this.tail;
    switch (this.length) {
        case 0:
            return this;
        case 1:
            this.tail = null;
            this.head = null;
            this.length--;
            return this;
        default:
            this.head= this.head.next;            
            this.length--;
            return this;
    }        
    }
}

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

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

  enqueue(value) {
    const node = new Node(value);
    if (!this.len) {
      this.top = node;
    } else {
      let item = this.top;
      for (let i = 0; i < this.len - 1; i++) {
        item = item.next;
      }
      item.next = node;
    }
    this.len++;
  }
  
  peek(){
    return  this.top;
  }
  
  dequeue(){
    this.top = this.top.next;
  }
}

const q = new Queue();
q.enqueue(1);
q.enqueue(2);
q.enqueue(3);
q.enqueue(4);
console.log(q);

Comparto mi solución al reto:

class Node {
  constructor(value) {
    this.value = value;
    this.next = null;
  }
}
class Queue {
  constructor(){
    this.first = null;
    this.last = null;
    this.length = 0;
  }
  
  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++;
  }
  
  dequeue() {
    if(this.length == 0 ) {
        return "Queue is empty";
    } 
    if(this.length === 1 ) {
      const lastItem = this.first;
      this.first = null;
      this.last = null;
      this.length--;
      return lastItem.value;
    }
    this.length--;
    const first = this.first;
    this.first = first.next;
    return first.value;
  }
  peek() {
    if(this.length === 0) {
      return null;
    }
    return this.last.value;
  }
}

const queue = new Queue();
queue.enqueue(1)
queue.peek();
queue.enqueue(2)
queue.peek();
queue.enqueue(3)
queue.peek();
queue.enqueue(4)
queue.peek();
queue.enqueue(5)
queue.dequeue()
queue.dequeue()
queue.dequeue()
queue.dequeue()
queue.dequeue()

mi código

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

class Queue{
    constructor(){
        this.front = null;
        this.tail = null;
        this.length = 0;
    }

    peek(){
        return this.front;
    }

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

    dequeue(){
        let item = {};
        if(this.length === 0){
            return null;
        } else {
            item = this.front;
            this.front = item.next;
            if(this.length === 1){
                this.tail = null;
            }
            this.length--;
        }
        return item;
    }
}

const myQueue = new Queue();

Solución al reto, clase Queue.

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

class Queue {
    constructor() {
        this.front = null;
        this.back = null;
        this.length = 0;
    }
    peek() {
        return (this.front != null) ? this.front.value : this.front;
    }
    enqueue(value) {
        const newNode = new Node(value)
        if (this.length === 0) {
            this.front = newNode;
            this.back = this.front;
        } else {
            this.back.next = newNode
            this.back = newNode;
        }
        this.length++;
        return this;
    }
    dequeue() {
        if (this.length === 0) {
            return undefined;
        }
        if (this.length === 1) {
            this.back = null
        }
        const removedFront = this.front;
        const newFront = this.front.next;

        if (removedFront.next != null) { removedFront.next = null };
        this.front = newFront;

        this.length--;
        return removedFront.value;
    }
    print() {
        if (this.length === 0) {
            console.log("This queue is empty");
        }
        let probe = this.front;
        for (let i = 0; i < this.length; i++) {
            console.log(probe.value);
            probe = probe.next;
        }
    }
}

la implementacion de la estructura de datos Queues o cola en java

primero una interface para definir las cabeceras de los metodos

public interface InterfaceColaDoble<E> {
    public int size();
    public boolean isEmpty();
    public E Front();
    public E Tail();
    public void Enqueue(E elemento);
    public void Dequeue();
    
    
    
}

despues creamos nos nodos con esta clase

public class ColaDobleNodo<E> {
    E elemento;
    ColaDobleNodo<E> prev;
    ColaDobleNodo<E> next;

    public ColaDobleNodo() {
        elemento =null;
        prev = null;
        next = null;
    }

    public E getElemento() {
        return elemento;
    }

    public void setElemento(E elemento) {
        this.elemento = elemento;
    }

    public ColaDobleNodo<E> getPrev() {
        return prev;
    }

    public void setPrev(ColaDobleNodo<E> prev) {
        this.prev = prev;
    }

    public ColaDobleNodo<E> getNext() {
        return next;
    }

    public void setNext(ColaDobleNodo<E> next) {
        this.next = next;
    }
    
    
    
}```

por ultimo la implementacion de la clase

public class ColaDoble<E> implements InterfaceColaDoble<E> {

ColaDobleNodo<E> head;
ColaDobleNodo<E> tail;
int size;

public ColaDoble() {
    head = null;
    tail = null;
    size = 0;
}

@Override
public int size() {
    return size;
}

@Override
public boolean isEmpty() {
    if(this.size == 0){
      return true;  
    }else{
       return false; 
    }
}

@Override
public E Front() {        
    E elemento;
    
   if(this.isEmpty()==true){
       elemento=null;
       System.out.println("la cola esta vacia");
   }else{
       elemento= this.head.getElemento();
   }
   
   return elemento;
}

@Override
public E Tail() {
    E elemento;
    
   if(this.isEmpty()==true){
       elemento=null;
       System.out.println("la cola esta vacia");
   }else{
       elemento= this.tail.getElemento();
   }
   
   return elemento;
}

@Override
public void Enqueue(E elemento) {
    
    if(this.isEmpty()==true){
        
      ColaDobleNodo<E> newNode = new ColaDobleNodo<E>() ; 
      newNode.setElemento(elemento);
      newNode.setNext(null);
      newNode.setPrev(null);
      this.head = newNode;
      this.tail = newNode;
      this.size = 1;
       
   }else{
        
        ColaDobleNodo<E> newNode = new ColaDobleNodo<E>() ; 
        newNode.setElemento(elemento);
        newNode.setNext(null);
        newNode.setPrev(tail);
        this.tail.setNext(newNode);            
        tail = newNode;            
        this.size ++;
       
   }
}

@Override
public void Dequeue() {
    
    if(this.isEmpty()==true){
      System.out.println("la cola esta vacia");  
      
   }else{
        head= head.getNext();
        this.size--;
   }
    
}

}```

Implementación de algoritmo de cola:

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

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

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

  dequeue() {
    const prevFirstElem = this.first;
    if(this.length === 0){
      console.log("There is no element in queue");

    } else if(this.length === 1){
      this.first = null;
      this.last = null;
    } else {
      this.first = prevFirstElem.next;
    }
    this.length--;
    return prevFirstElem
  }

  peek(){
    if(this.length === 0) {
      console.log("There is no element in queue");
    } else {
      return this.first;
    }
  }

}

const myQueue = new Queue();
myQueue.enqueue(1);
myQueue.enqueue(2);
myQueue.enqueue(3);
myQueue.enqueue(4);
myQueue.enqueue(5);
myQueue.dequeue();
console.log(myQueue);

Mi código sin haber visto la clase

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

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

    enqueue(value){
        let newNode = new Node(value)
        //Validamos si es el primer elemento
        if (this.lenght === 0){
            //Añadimos el nodo como primer elemento
            this.first = newNode
            //Añadimos el primer elemento como el ultimo
            //si es la primera vez
            this.last = this.first
        }
        //establecemos el nuevo nodo
        //como el next del ultimo elemento del queue
        this.last.next = newNode
        //el nuevo nodo se establece como el ultimo elemento
        this.last = newNode
        //aumentamos el tamaño del queue
        this.lenght++
        return this
    }
    
    dequeue(){
        if(this.lenght === 1){
            //Cambiamos el valor del ultimo
            //a null cuando el queque se vacie
            this.last = null
        }else if(this.lenght === 0){
            //Si el queque está vacio
            console.log('El queue está vacío')
            return this
        }
        //Asignamos como first al siguiente elemento del queue
        this.first = this.first.next
        //reducimos el tamaño del queue
        this.lenght--
        return this
    }
    peek(){
        //regresamos el primer elemento del queue
        return this.first
    }

}

let queue = new Queue()
queue.enqueue(1)
queue.enqueue(2)
queue.enqueue(3)
queue
queue.peek()
queue
queue.dequeue()

Lectura recomendada 👀

Les dejo esta lectura, si desean complementar la clase 😉

• Estructuras de datos con JavaScript - Parte 2: Colas (Queues)

RETO

Creo que lo logre, no se si es el código mas optimo pero fue lo que se me ocurrió

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

class Queue {
    constructor(){
        this.top = null;
        this.bottom = null;
        this.length = 0;
    }
    peek(){
        return this.bottom;
    }
    enqueue(value){
        const newNode = new Node(value);
        if(this.length === 0){
            this.top = newNode;
            this.bottom = newNode;
        }else{
            //this.bottom.prev = newNode;
            if( !this.bottom.prev ){
                this.bottom.prev = newNode;
                
            }else{
                const lasIndex = this.findIndex();
                lasIndex.prev = newNode;
                
            }
        }
        this.top = newNode;
        this.length++;
        return this;
    }
    findIndex(){
        let returnedItem = this.bottom;
        let counter = 0;
        while( counter < (this.length - 1) ){
            returnedItem = returnedItem.prev;
            counter++;
        }
        return returnedItem;
    }
    dequeue(){
        if(this.length === 0){
            console.error('No hay elementos en el Queue');
            return this;
        }else{
            if( this.length === 1 ){
                this.top = null;
            }
            this.bottom = this.bottom.prev;
            this.length--;
            return this;
        }
    }
}
const myQueue = new Queue();
myQueue.enqueue(1);
myQueue.enqueue(2);
myQueue.enqueue(3);
myQueue.enqueue(4);
myQueue.enqueue(5);

Queues o Filas

Reto Queue y sus tres métodos:
.

Comparto mi código con la solución antes de ver la siguiente clase 😄, es muy inspirador ver que puedes empezar a escribir código solo :3. No se si soy el único

Mi implementación.

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.bottom;
    }
    enqueue(value) {
        const newNode = new Node(value);
        if(this.length === 0){
            this.top = newNode;
            this.bottom = newNode;
        }else{
            this.top.next = newNode;
            this.top = newNode;
        }
        this.length++;
        return this;
    }
    dequeue(){
        if(this.length > 0){
            this.bottom = this.bottom.next;
            this.length--;
            return this;
        }
        return undefined;
    }

}

const myQueue = new Queue();

👌

Retos cumplidos

    peek(){
        return console.log(this.bottom);
    }

    enqueue(value){
        const newNode = new Node(value);
        if (newNode.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 console.log(this);
        } else {
            console.log("Ingresa un valor");
        }
    }

    dequeue(){
        if (this.length === 0){
            console.log("El Queue está vacío");
        } else {

            if(this.length === 1){
                this.top = null;
                this.bottom = null;
            }else{
                let target = this.top;
                for (let i = 1; i < this.length -1; i++){
                    target = target.next;
                }
                target.next = null;
                this.bottom = target;
            }

            this.length--;
            return console.log(this);
        }
    }

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

class Queue {
    constructor(){
        // back = parte trasera de la cola, front = parte delantera de la cola
        this.back = null
        this.front = null
        this.length = 0
    }
    enqueue(value){
        let newNode = new Node (value)
        if(this.length == 0){   //si la cola esta vacia
            this.front = newNode
            this.back = this.front
        } else {    // con un elemento o mas de un elemento
            this.back.next = newNode
            this.back = newNode
        }
        this.length++
        return this
    }
    dequeue(){
        if(this.length == 0){
            return 'We cant dequeue an empty queue'
        } else {
            this.front = this.front.next
            this.length--
            return this
        }
    }
    peek(){
        if(this.length == 0){
            return 'Empty Queue'
        } else {
            return this.front.value // aqui solo devuelvo el valor por que no quiero ver toda la cola
        }
    }
}

const myQueue = new Queue()```

Implementación Queues

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() {
        switch (this.length) {
            case 0:
                return console.log("No se puede realizar la operacion. La cola no tiene elementos.")
            case 1:
                this.first = null
                this.last = null
                this.length--
                    return this
            default:
                this.first = this.first.next
                this.length--
                    return this

        }

    }
}

const myQueue = new Queue()

Demostración

Mi solución:

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

class Queue {
    constructor(){
        this.first = null;
        this.last = null;
        this.length = 0;
    }
    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) {
            return null;
        }
        const holdingPointer = this.first;
        if (this.length === 1){
            this.first = null;
            this.last = null;
        } else {
            this.first = this.first.next;
        }
        this.length--;
        return holdingPointer;
    }
    peek(){
        return this.first;
    }
}

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

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

    this.length = 0;
  }

  enqueue(value){
    const newNode = new Node(value);

    if(!this.length){
      this.first = newNode;
      this.last = newNode;
      this.length++;
      return this;
    }

    this.last.next = newNode;
    this.last = newNode;
    this.length++;
    return this;
  }

  dequeue(){
    if(!this.length){
      return undefined;
    }

    const item = this.first;

    this.first = this.first.next;
    this.length--;
    return item;
  }

  peek(){
    if(!this.first){
      return undefined;
    }

    return this.first
  }
}

const queue = new Queue();```

Resulto mas facil de trabajar que el stack ya que no hay que recorrer toda la estructura para hacer dequeue, este es mi codigo:

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

    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) {
            return null;
        }

        this.first = this.first.next;
        length --;
        return this;
    }

    peek(){
        return this.first;
    }
}

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

Mi intento de los metodos 😊

		peek() {
        if(this.length > 0){
            return this.bottom
        }else console.error('no hay datos cargados')
    }
    enqueue(value) {
        const newNode = new Node(value)
        if (this.length === 0) {
            this.top = newNode
            this.bottom = newNode
        } else {
            const holdingPointer = this.top
            this.top = newNode
            holdingPointer.next = this.top
        }
        this.length++
        return this
    }
    dequeue() {
        if (this.length > 1) {
            const holdingPointer = this.bottom
            delete this.bottom
            this.bottom = holdingPointer.next
            this.length--
        } else if (this.length === 1) {
            delete this.top
            delete this.bottom
            this.length--
        } else {
            console.error('No hay datos cargados')
        }
        return this
    }

Comparto: https://medium.com/laboratoria-developers/queues-in-javascript-2602677c9c3b#:~:text=Una cola (queue en inglés) es una estructura de datos,retiramos data por el frente.&text=Es lo que llamamos una,First In%2C First Out).

Ahí dejo mi implementación de Queue (muy similar a Stack):

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 += 1

        return this
    }

    dequeue( ) {

        const firstNode = this.first

        if( this.length > 0){
            this.first = this.first.next
            this.length -= 1
        } 
        if( this.length === 0) {
            this.first = null
            this.last = null
        }
        
        return firstNode
    }

}

Métodos terminados de queues(antes de ver la siguiente clase)

/*
FIFO
bottom       top
  OK    OK    OK
*/

class NewNode {
	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 NewNode(value);
		if (this.length === 0) {
			this.top = newNode;
			this.bottom = newNode;
			this.length++;

			return this;
		}
		const holdingPointer = this.bottom;
		this.bottom = newNode;
		this.bottom.next = holdingPointer;
		this.length++;

		return this;
	}

	dequeue() {
		if (this.length === 0) {
			return this;
		}
		const prevNode = this.searchPrevNode();
		this.top = prevNode;
		this.top.next = null;
		this.length--;

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

	searchPrevNode() {
		let currentNode = this.bottom;
		for (let i = 2; i < this.length; i++) {
			currentNode = currentNode.next;
		}

		return currentNode;
	}
	peek() {
		return this.top;
	}
}

const queue = new Queue();

O fila en español. Son bastante similar a las stacks, pero tiene un comportamiento distinto, El de esta es FIFO (First in, first out), como un fila de personas en un banco por ejemplo. La persona que llega primero tiene derecho a ser atendida antes que el ultimo. .
.

• Tenemos métodos que nos ayudan en el manejo de las queue
  • Enqueue: agrega elementos al final de la fila
  • Dequeue remueve el primer elemento de la fila
  • Peek toma el primer elemento de la fila