No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Queues

22/29
Recursos

Aportes 63

Preguntas 0

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

o inicia sesi贸n.

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

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

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

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 馃槈

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
    }

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();
<h3>Queue</h3>

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