Creando tu primera Queue: implementar la función deQueue

Para los que usan JS, les dejo estos métodos que les servirán mucho:

• pop(): Elimina un item del final de una array.
• push(): Añade items al final del array
• shift(): Eleimina un item al final del array.
• unshift(): Agrega un item al principio del array.

Más info: https://alligator.io/js/push-pop-shift-unshift-array-methods/

Hay un error en la descripción de la clase, debería decir FIFO en vez de LIFO

En Javascript:

const size = 5;
const arr = [];
let clients = 0;

function enQueue() {
	if (arr.length >= size) {
		console.log('El Queue está lleno!');
	} else {
		clients++;
		arr.push(clients);
	}
}

function deQueue() {
	if (arr.length) {
		arr.pop();
	}
}

// Pruebas
enQueue();
enQueue();
enQueue();
deQueue();

Este es mi codigo en JS

function deQueue() {
  if (front == -1) {
    console.log(`Queue is empty`);
  } 
  else {
    console.log(`Value ${values[front]} deleted`);
    values[front] = undefined
    front++
    if (front > rear) {
      front = rear = -1
      console.log("The las item was deleted");
    }
  }
}

En la descripción del vídeo hay un error, debería ser FIFO en ves de LIFO.

En que casos debo usar estas funcionalidades en mi codigo? o en algun proyecto?

En JS.

function deQueue(){
    if(front == -1){
        console.log("Nuestro Que está vacío");
    } else {
        console.log(`Se elimino el valor de: ${array[front]}`);
        front++;
        if(front > rear){
            front = -1;
            rear = -1;
        }
    }
}```

class Queue:

    def __init__(self, SIZE):
        self.front = -1
        self.rear = -1
        self.queue = []
        self.SIZE = SIZE

    def en_queue(self, name):
        if self.rear >= self.SIZE - 1:
            print('Sorry, the queue are full')
        else:
            if self.front < 0:
                self.front = 0
                self.rear = 0

                self.queue.append(name)

                print(f'SE AGREGÓ {name} CORRECTAMENTE')

            else:
                self.rear += 1
                self.queue.append(name)

                print(f'SE AGREGÓ {name} CORRECTAMENTE')

        return(self.rear, self.front, self.queue)

    def de_queue(self):
        if len(self.queue) <= 0:
            self.front = -1
            self.rear = -1
        try:
            print(f"Se eliminó {self.queue[self.front]}")
            self.queue.pop(self.front)
        except IndexError:
            print('Sorry not more elements to delete.')

    def peek(self):
        print(self.queue[self.front])

    def size(self):
        print(len(self.queue))
    
    def is_empty(self):
        if len(self.queue) == 0:
            print('This queue are empty.')
        else:
            print('The queue is not empty')

    def is_full(self):
        if len(self.queue) == self.SIZE:
            print('This queue are full.')
        else:
            print('The queue is not full')

    def list_queue(self):
        print(self.queue)


if __name__ == "__main__":

    try:
        size = int(input('size: '))
        r = Queue(size)

        while True:
            option = input("""
            a = add
            b = remove
            c = list
            d = size
            e = peek
            f = is empty
            g = is full
            z = exit

            """)

            if option == 'a':
                name = input('Name: ')
                r.en_queue(name)
            elif option == 'b':
                r.de_queue()
            elif option == 'c':
                r.list_queue()
            elif option == 'z':
                break
            elif option == 'd':
                r.size()
            elif option == 'e':
                r.peek()
            elif option == 'f':
                r.is_empty()
            elif option == 'g':
                r.is_full()
            else:
                print('')
                print('Sorry this command is not allowed')
    except ValueError:
        print('Sorry, the size must be a number')
    
    

Comparto con ustedes un repositorio de Github en el que ire subiendo lo que se trabaje en este curso.
https://github.com/davidgonzalezfx/DataStructures-and-Algorithms

La verdad me ha parecido un poco complejo pero he logrado entender .

Madre mía que lógica mas mala para implementar un Queu. Lo único que vas a conseguir es que la gente se lie.

CREANDO TU PRIMERA QUEUE: IMPLEMENTAR FUNCION DE QUEUE
En deQueue: nosotros no controlamos los datos que salen, simplemente la lógica de Abstrac Data Type se encarga de dar el resultado, recordando que este método (dequeue) remueve y retorna el primer elemento en la cola si no está vacío.

Ese feature nuevo de mover el video a una esquina de la pantalla esta súper genial

deQueue en Javascript

function deQueue(){
			if(front==-1){
				document.write("<br>no hay ningun valor en la cola<br>");
			}else{
				document.write("Se elimino el valor "+array[front]+" de la posicion array["+front+"]<br>");
				for(z=0;z<array.length;z++){
					if(array.length == 1){
						array.length = 0;
						rear= -1;
						front=-1;
						break;
					}
					array[z]=array[z+1];
				}
				if(array.length > 1){
					array.length= array.length-1;
					for(y in array){
						document.write("array["+y+"]= "+array[y]+"<br>");
					}
				}
			}	
		}```

Por que en la descripción dice que es LIFO cuando es FIFO?

Excelente!!! Yo solo modificaría que la función deQueue me retorne el valor que está listo para salir.

No entendi pero bno

En esta clase aprendí que se pueden igualar dos variables al mismo tiempo a un solo valor, eso es algo que nunca había visto Gracias!.

void deQueue()
{
	if(front == -1)
	{
		printf("Nuestro queue esta vacio \n";)
	}else{
		printf("Se elimino el valor %d \n", values[front]);
		front++;
		
		if(front > rear )
		{
			front = rear = -1;
		}
	}
}```

Creo que no es buena práctica declarar las viables al final, pero bueno dice que porque es corto.

Mi aporte en Javascript:

function Queue() {
  const SIZE = 5;
  let collection = [];

  // Methods
  this.print = function(){
    console.log(collection);
  };
  this.enqueue = function(value){
    this.size() < SIZE ? collection.push(value) : console.log('Is full');
  };
  this.dequeue = function(){
    return collection.shift();
  };
  this.size = function(){
    return collection.length;
  };
  this.front = function(){
    return collection[0];
  };
  this.isEmpty = function(){
    this.size() > 0;
  };
}

let queue = new Queue();
queue.enqueue(1);
queue.enqueue(2);
queue.enqueue(3);
queue.enqueue(4);
queue.enqueue(5);

queue.enqueue(6); // Is full

queue.dequeue();
queue.enqueue(6);
queue.print();

Resultado de la consola:
Is full
[ 2, 3, 4, 5, 6 ]

En Python
Decidí hacer varias impresiones: cuando ya está lleno, como cuando ya no hay nada que eliminar.

# Python program to 
# demonstrate implementation of 
# Queue (FIFO) using lists

queue = ["","","","",""]
size = 5
front = -1
rear = -1


def insert(value):
    global queue
    global size
    global front
    global rear
    if rear == len(queue)-1:
        print("Queue is full")
    else:
        if front == -1:
            front = 0
        rear += 1
        queue[rear] = value


def extract():
    global queue
    global size
    global front
    global rear
    if front == -1:
        print("Queue is empty")
    elif front > rear:
        print("Queue is empty, there's nothing to delete")
        front = rear = -1
    else:
        print(f"{queue[front]} was deleted")
        queue[front] = ""
        front += 1
    

def run():
    insert("x1")
    insert("x2")
    insert("x3")
    insert("x4")
    insert("x5")
    insert("x6")
    print(f"{queue} front: {front} rear: {rear}\n")

    extract()
    print(f"{queue} front: {front} rear: {rear}\n")
    extract()
    print(f"{queue} front: {front} rear: {rear}\n")
    extract()
    print(f"{queue} front: {front} rear: {rear}\n")
    extract()
    print(f"{queue} front: {front} rear: {rear}\n")
    extract()
    print(f"{queue} front: {front} rear: {rear}\n")
    extract()
    print(f"{queue} front: {front} rear: {rear}\n")
    
        
if __name__ == "__main__":
    run()

Gracias

En Platzi hay algun curso de C desde cero?, puede ser interesante si no lo hay, ademas de que puede tener un enfoque en HPC con MPI.

¿Todavía no se está eliminando del array nada con la funcion deQueue() cierto?

#include  <stdio.h>
#define SIZE 5

void enQueue(int value){
    if (rear == SIZE-1)
        printf("Nuestro Queue esta lleno\n");
    else {
        if(front == -1)
            front = 0;
        rear++;
        items[rear] = value;
        printf("Se inserto el valor correctamente %d correctamente \n", value);
    }
}

void deQueue(){
    if(front == -1)
        printf("Nuestro Queue eta vacio\n");
    else
    {
        printf("se elimino el valor %d", items[front]);
        front++;
        if(front > rear)
        front = rear = -1;
    }
    
}

VHugoBarnes es correcta tu observación.

Código en Java:

void DeQueue()
{
	if (front == -1)
		System.out.println("The queue is empty.");
	else
	{
		front++;
		if (front > rear)
			front = rear = -1;
	}
}

Otro código en JS

    const deQueue = function(){
        if (front == -1) {
            console.log("No hay valores")

        }
        else{
            console.log(`Se eliminó el valor: ${values[front]}`)
            front++
            if (front > rear) {
                front = -1
                rear = -1
            }
        }

para hacerlo en python tuve que utilizar la función remove(x) que me devuelve un el elemento en la posición x (colocandola siempre como 0 internamente) esta función es propia de las listas, creen que sea ‘trampa’ (según los propositos del curso) hacerlo así? la otra solución que se me ocurre sería sobreescribir la lista anterior por una nueva con los otros valores y retornar el eliminado
algo así:

<retornar=lista[0]
lista=lista[1:max_size]```
}>

pero no me parece que sea eficiente.
esta fue mi solución original en python:

<import logging
logging.basicConfig(level=logging.INFO)
class Queue(object):
	def__init__(self,max_size):
		self.__rear=-1
		self.__front=-1
		self.__queue=[]
		self.__max_size=max_size-1
		pass
	def enQueue(self,data):
		if self.__rear<self.__max_size:
			self.__queue.append(data)
			logging.info(‘el dato {} ha sido agregado’.format(str(data)))
			self.__rear+=1

    		else:
        		logging.info('el queue ya ha alcanzado su capacidad maxima')
    			pass
	def deQueue(self):
   		 if self.__rear>-1:
        	 	logging.info('el dato {} ha sido retornado y removido'.format(self.__queue[0]))
        		self.__front+=1
        		self.__rear-=1
        		return self.__queue.pop(0)
    	else:
        	logging.info('no existen más datos en el queue')
    		pass
	def returnQueue(self):
    		return self.__queue
	pass```
>

void deQueue()
{
    if(front == -1)
      printf("Nuestro Queue esta vacio\n");
    else
    {
      printf("se elimino el valor %d", values[front]);
      front++;
      if(front > rear)
      front = rear = -1;
    }
}```

Windows 10 no me permite ejecutar el archivo uddt.exe alguna ayuda o sugerencia ?

muchas gracias!!!

en Javascript:

var size = 5; //longitud maxima de la cola
var turn = [];//Array de control
var cliente = 0// numero de lientes

var ingreso = document.getElementById(“In”);
ingreso.addEventListener(“click”, enQueue);
var salida = document.getElementById(“Out”);
salida.addEventListener(“click”, deQueue);

function enQueue(){
if (turn.length >= size){
console.log("Limite superado " + turn.length);

} else{
  cliente ++;
  turn.push(cliente);
  console.log("Cliente ingresado " + turn);
}

}

function deQueue(){
if (turn.length > 0){
turn.shift();
console.log("Cliente atendido quedan: " + turn);
}else {
console.log(“La cola esta vacia”);
}
}

¿El hecho de que la Queue tenga un límite de elementos que puede contener es algo necesario de este ADT o se está implementando de este modo por la limitante de C de tener arrays con un tamaño fijo?

Si el límite del Queue no fuese obligatorio, en distintos lenguajes su implementación se vuelve mucho más sencilla.

En JavaScript me está quedando así:

Tengo una duda ¿que es lo que hace que los valores guardados en values se vayan eliminando? No se si entendí bien pero, entonces la función deQueue, al o tener parámetros ¿por si sola es suficiente para que elimine los valores del Queue?. Me quedo el conflicto de no entender bien como sucede eso, Gracias!.

La función deQueue esta incompleta en la siguiente clase hablan más de ello

// Pop al elementos mas viejo
void deQueue() {

  // Hay elementos?
  if ( front == -1 ) {
    printf("No hay mas elementos\n");
    return
  }

  valor = values[front];
  printf("Se elimino el valor%d\n", valor);
  front++;

  // No mas elementos, resetenado
  if ( front > rear ) {
    front = rear = -1;
  }
}

#include <stdio.h>
#define SIZE 5

int front=0, rear=0;

int deQueue() {
	if(rear!=front){	
		int returnValue=queue[front++];
		front%=SIZE;
		return returnValue;;
	}
	return -1; // ésto sirve siempre y cuando  -1 no sea un valor válido  .   
}

void enQueue(int value){
	if((rear +1) % SIZE != front) {
		queue[rear++] = value;
		rear %=SIZE;
		printf(“Item %i added to queue at position %i.\n”, value, rear);
	} else 
		printf(“Sorry, queue is full\n”);
	
}```

ordenaron los curso para que de esa manera uno pueda entender el uso de algunos de los comandos que utiliza con c y se entienda bien los algoritmos

así lo hice terminare de ve el vídeo para ver en que me equivoque
![](

#include <stdio.h>
#include <stdlib.h>
#define SIZE 5

int items[5];short rear = 0;

void enQueue(const int valor){
    for(rear = 0; rear < 5;++rear){
        if(items[rear] == -1)
            break;}
    if(rear < SIZE){
        items[rear] = valor;
        printf("se ha ingresado el valor %d\n",valor);}
    else
        printf("nuestro Queue esta lleno\n");}

void deQueue(){
    if(rear != 0){
        printf("el valor %d a salido\n",items[0]);
        --rear;
        short i;
        for(i = 0; i <SIZE -1; ++i){
            items[i] = items[i + 1];
            items[i + 1] = 0;}}
    else
        printf("El deQueue esta vacio\n");}

void inicializar(int *cola){
    short i;
    for(i = 0; i < SIZE; ++i)
        cola[i] = -1;}

void imprime(int *cola){
    if(rear == 0){
        printf("el Queue esta vacio\n");
        return;}
    short i;
    for(i = 0; i < SIZE; ++i)
        printf("el %d vaor es : %d\n", i+1,items[i]);}

int main(void)
{
    inicializar(items);
    enQueue(5);
    enQueue(8);
    enQueue(9);
    enQueue(3);
    enQueue(1);
    enQueue(6);//aqui ya esta lleno
    deQueue();
    deQueue();
    deQueue();
    deQueue();
    deQueue();
    deQueue();//aqui ya esta vacio
    imprime(items);

    return 0;
}```

Me quedo una duda, ¿El valor se elimina cuando la posición front cambia + 1? Según lo que entiendo, no se elimina solo queda inaccesible.

Hola Amigos, dejo este comentario que me ayudó a entender la función deQueue().

Realmente la función deQueue(), no elimina nada del array, solamente imprime el valor de la posición del array e incrementa el puntero front.

Ya casi terminamos, este es el código que hicimos hoy:

void deQueue()
{
    if(front==-1)
    {
        printf("Our queue is empty\n");
    }
    else
    {
        printf("%i value has been removed\n",values[front]);
        front++;
        if(front>rear)
        {
            front=rear=-1;
        }
    }    
}

Saludos, les brindo mi código hecho en JS con botones

  <button id="in">Ingresar</button>
  <button id="out">Salir</button>
  <script>

var size = 5;
var turn = [];
var client = 0;

let ingreso = document.getElementById('in');
ingreso.addEventListener('click', enQueue);

let salir = document.getElementById('out');
salir.addEventListener('click', deQueue);

function enQueue(){
  if(turn.length >= size){
    console.log('limite superado')
  }
  else {
    client ++;
    turn.push(client);
    console.log('cliente ingresado' + ' ' + client)
  }
}

function deQueue(){
  if(turn.length > 0){
    turn.shift();
    console.log(`cliente atendido, quedan ${turn.length} lugares`)
  }
  else {
    console.log('La cola esta vacia')
  }
}
  </script>```

Continuamos!

Codifigo de la funcion:

void deQueue()
{
    if (front == -1)
        {
            printf("Nuestro Queue  esta vacio \n");
        }
        else
        {
            printf("Se elimino correctamente el valor %d en nuestra cola \n", items[rear]);
            front ++;
            if (front > rear)
            {
                front =  rear = -1;
            }
        }
}

–> Luego dentro del else, necesitamos avisar con un mensaje cual sera el objeto que borraremos de la cola, con una impresion en pantalla printft(), imprimimos el valor que siempre esta por salir en este caso seria front, luego necesitamos incrementar la posicion de front para correr a la siguiente front++.

Resetear front y rear: Lo que tenemos que hacer es una comparacion entre front y rear, comparando si front es mayor a rear, entonces reiniciamos sus valores a -1

Sí que se está explicando detalladamente.