Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

Queues

18/25
Recursos

Aportes 47

Preguntas 0

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta 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 😅

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

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

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
    }

}

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

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

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