Creando tu primera Queue: main code

RETOOO!!! y mis apuntes

Codigo completo

#include<stdio.h>

#define SIZE 5
int values[SIZE];
int front = -1;
int rear = -1;

void imprimir(int v[]){
  for(int i=front; i<=rear; i++){
    printf("%d, ", v[i]);
  }
  printf("\n");
}

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

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

main(int argc, char const *argv[])
{
  enQueue(10);
  enQueue(20);
  enQueue(30);
  enQueue(40);
  enQueue(50);
  enQueue(60);
  deQueue();
  deQueue();
  deQueue();
  deQueue();
  deQueue();
  deQueue();
  enQueue(60);
  enQueue(70);
  enQueue(80);
  enQueue(90);
  enQueue(100);
  enQueue(110);




  return 0;
}

En esta parte, si ejecutas la función deQueue, se imprimirá que el queue esta vacío.

Así me quedo el reto, la verdad pensaba que era mucho mas difícil y empece a poner puros IFs y Whiles jajajajajaj.

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

lo unico que agregue fue el rear++. puesto que si front y rear aumentan se mantiene el mismo tamaño del Queue y queda un espacio en rear para un nuevo value

Así fue como lo hice yo

#include <stdio.h>
#define SIZE 5


int items[4] = {2}, values[SIZE], front = -1, rear = -1;

void enQueue(int value){
    if (rear == SIZE -1)
        printf("Queue is full \n");
    else {
        if (front == -1)
            front = 0;
        rear++;
        values[rear] = value;
        printf("We just added  \"%d\" value successfully \n", values[rear]);
    }
}


void deQueue(){
    if ( front == -1)
        printf("Our queue is empty\n");

    else{
        printf("We have deleted the %d value\n", values[front]);
        for (int counter = 0; counter != rear; counter++)
            values[counter] = values[counter + 1]; 
        rear--;
    }
}

int main (int argc, char const *argv[])
{
    enQueue(1);
    enQueue(2);
    enQueue(3);
    enQueue(4);
    deQueue();
    enQueue(6);
    enQueue(7);
    return 0;
}

El ucrso y la metodología me parecen excelentes para aprender a pensar de una forma algorítmica. SOlo le sugiero a los compañeros que no están muy familiarizados con el lenguaje C y qué han tenido dificultades, que vean el curso de introducción a C para que puedan sacarle máximo provecho a este curso.

no me ha gustado mucho el curso… pero nada hacerle…

Buenas a todos! Aquí está el código del reto propuesto por el profe en esta clase.

Unas cosas que aclarar:

1.- Agregue una función más para imprimir el contenido de la Queue, su nombre es printQueue.

2.- Modifiqué la función deQueue de forma que al momento de eliminar el valor, sea realizado un ciclo que va a mover todos los números ingresados una posición más adelante para al final eliminar la posición final dejándola en 0 y retrocediendo el valor de rear un espacio. El ciclo se vale del valor de la variable rear para determinar cuántos espacios debe retroceder.

3.- La variable front quedó renegada a únicamente marcar cuando esté vacía/en uso la lista.

Espero que les quede claro con el código lo que acabo de decir!

#include <stdio.h>
#define SIZE 5
int values[SIZE], front= -1, rear= -1;

void enQueue(int value){
    if(rear == SIZE-1)
        printf("The Queue is full.\n");
    else {
        if(front == -1)
            front = 0;
        rear++;
        values[rear] = value;
        printf("%d has been inserted correctly\n", value);
    }
}

void deQueue(){
    if(front == -1)
        printf("The Queue is empty.\n");
    else{
        printf("%d has been deleted correctly\n", values[front]);
        int i;
        for(i = 0; i < rear; i++)
            values[i] = values[i+1];
        values[rear] = 0;
        rear--;
        if(front > rear)
            front = rear = -1;
    }
}

void printQueue(){
    if(rear == -1)
        printf("The Queue is empty.\n");
    else{
        int i;
        for(i = 0; i <= rear; i++)
            printf("Position %d: %d\n", i, values[i]);
    }
}

int main(int argc, char const *argv[]){
    ...
}

Lo que mas me tomó tiempo de este ejercicio fue lograr compliar en C, tuve que investigar hasta que descubri que debia descgargar gcc hasta que lo logre. Porque todos ya sabian C o lo tenian configurados en sus equipos?. De igual forma me gusta el curso y lo que hacemos. Saludos a todos!

Esta es mi solucion al reto… Busque la manera de hacerlo lo mas eficientemente posible, por que notaba que despues de insertar o borrar cierta cantidad de datos no tenia el mismo resultado.

#include<stdio.h>
#define SIZE 5
int values[SIZE], front = -1, rear= -1;


void enQueue(int value){
    if(rear == SIZE-1)
        printf("The Queue is full\n" );
    else {
        if(front == -1)
            front = 0;
        rear++;
        values[rear] = value;
        printf("The value %d stored correctly\n", value);

    }

}

void deQueue(){
    if(front == -1)
        printf("The Queue is empity\n" );
    else{
        printf("Deleted the value %d\n", values[front]);
        front++;
        rear--;
        if (front == SIZE || front > rear)
          front = rear = -1;
    }

}

main(int argc, char const *argv[])
{
    enQueue(1);
    enQueue(2);
    enQueue(3);
    enQueue(4);
    enQueue(5);
    enQueue(6);
    deQueue();
    deQueue();
    deQueue();
    deQueue();
    deQueue();
    deQueue();
    enQueue(6);
    deQueue();
    deQueue();
    return 0;
}```

Aquí esta mi solución al reto hecha en python (soy nuevo en este lenguaje si alguien sabe como podría optimizar mi código leeré su respuesta mucho gusto)

# Declaracion de constantes
SIZE = int(5)
# Declaracion de variables
front = int(-1)
rear = int(-1)
# Declaracion de arreglos
values = [None] * SIZE


# Funcion para agregar datos a la queue
def en_queue(value):
    global rear, front, values
    # si el indicador de la parte final es igual al tamaño del queue entonces
    if rear == SIZE - 1:
        print("Nuestro Queue esta lleno \n")
    else:
        # inicializa el indicador de la cabeza en cero
        if front == -1:
            front = 0

        # aumenta el indicador de la cabeza en uno y agrega el valor
        rear = rear + 1
        values[rear] = value
        print("Se agrego el valor {} correctamente \n".format(value))


# Funcion para eliminar datos a la queue
def de_queue():
    # llamado de las variables globales
    global front, rear, SIZE
    # si el indicador de la cabeza es -1
    if front == -1:
        print("\n\nNuestro Queue esta vacio\n")
    else:
        print("Se elimino el valor {}\n".format(values[front]))
        front += 1
        # ciclo que mueve todos los datos a la siguiente posicion en la queue y modifica el indicador de cola
        for x in range(1, 5):
            values[x - 1] = values[x]
            values[x] = None
            if x == 4:
                rear = rear - 1
                break
        # si el arreglo queda vacio entonces reinicia los indicadores
        if front > rear:
            front, rear = -1, -1


# Funcion para imprimir los valores de la queue
def imprimir_queue():
    print("\nEstado actual de la Queue")
    for x in range(0, 4):
        # Si el campo de la queue es diferente de vacio entonces
        if values[x] is not None:
            print(values[x])


if __name__ == "__main__":
    en_queue(1)
    en_queue(2)
    en_queue(3)
    en_queue(4)
    en_queue(5)
    de_queue()
    de_queue()
    en_queue(10)
    imprimir_queue()

**Resultado:
**

Se agrego el valor 1 correctamente 

Se agrego el valor 2 correctamente 

Se agrego el valor 3 correctamente 

Se agrego el valor 4 correctamente 

Se agrego el valor 5 correctamente 

Se elimino el valor 1

Se elimino el valor 3

Se agrego el valor 10 correctamente 


Estado actual de la Queue
3
4
5
10

Python

fila = []

def añadir(i, s):
    if i <= 4:
        i += 1
        s += 1
        fila.append(i)
        print(fila, ' \n')
    else:
        print(fila, ' \n', 'Fila llena', ' \n')

    return i, s


def eliminar(s):
    if len(fila) > 0:
        del fila[0]
        s += 1
        print(fila, ' \n')
    else:
        print('Fila vacia', ' \n')

    return s


def run():
    i = 0
    s = 0
    while True:
        num = int(input('Que deceas hacer 1-Agregar, 2-Eliminar '))
        if num == 1:
            i, s = añadir(i, s)
        else:
            s = eliminar(s)
        if s >= 9 and len(fila) == 0:
            s = 0
            i = 0


if __name__ == '__main__':
    run()

Mi código para resolver el reto:

#include <stdio.h>
#define SIZE 5

// 
int values[SIZE], firstOut = -1;
int total = 0, insert = 0;

void enQueue(int value) 
{
	if (total == SIZE) 
	{
		printf("Queue full\n");
	} else {
		if (total == 0) 
		{
			firstOut = insert;
		}
		values[insert] = value;
		insert++;
		if (insert == SIZE)
		{
			insert = 0;
		}
		total++;
		printf("The value %d was added sucessfully\n", value);
	}
}

void deQueue()
{
	if (total == 0) 
	{
		printf("Queue empty\n");
	} else {
		printf("The value %d was eliminated\n", values[firstOut]);
		firstOut++;
		if (firstOut == SIZE)
		{
			firstOut = 0;
		}
		total--;
	}
}

int main(int argc, char const *argv[])
{
	...
	return 0;
}

Lo que trato de representar son indicadores (insert y firstOut) que me señalen la situación de la cola. ‘insert’ dice cual es la posición en la que un valor se debe ubicar respecto al último de la cola, y firstOut el valor en cola que debe ser atendido.

Haciendo el reto me surgio la duda en como comprueban que el código es correcto, hice pruebas pero todo de forma manual y tediosa xd, supongo que habrán mejores formas. ¿Cómo hacen ustedes para comprobar que sus códigos son correctos?

Aquí dejo mi aporte espero lo entiendan, lo logré después de darle un par de vueltas encima

#include <stdio.h>
#define SIZE 5

int values[SIZE], front, rear;

void inicializar(){ // Función que inicializa las variables por defecto
	front = -1;
	rear = -1;
	int i;
	
	for(i = 0; i < SIZE; i++){
		values[i] = 0;
	}
} 

void mostrarQueue(){// Función para mostrar la Queue por pantalla
	int i;
	
	for(i = 0; i < SIZE; i++){
		if(values[i] != 0){
			printf("%d", values[i]);
		}
	}
	printf("\n");
}

void enQueue(int value){
	if(rear == SIZE - 1){
		printf("Queue full.\n");
	}else{
		if(front == -1){
			front++;
		}
		if(rear < SIZE){//Si el rear no ha llegado al final del Queue aumenta en uno y guarda el valor en la Queue
		rear++;
		values[rear] = value;
		printf("%d insertado correctamente en la Queue. \n", value);		
		}
	
	}	
}

void deQueue(){
	if(front == -1){
		printf("Queue vacio.\n");
	}else{
		printf("%d Removido correctamente. \n", values[front]);
		int i; // Código para reordenar el Queue corriendolo un indice a la izquierda para así poder insertar un nuevo valor en la ultima posición
		int aux;
		for(i = 0; i < SIZE; i++){
			aux = values[i]; // Método burbuja para ordenar el Queue
			values[i] = values[i+1];
			values[i+1] = aux;
		}
		
		values[rear] = 0;//La ultima posición del rear se convierte 0 para poder alojar un valor nuevo
		values[SIZE -1] = 0;//También se convierte en 0 las posiciones a su derecha por si se elimina más de una vez
		rear--;// Se resta el rear para poder liberar la condición de la función enQueue para guardar un valor nuevo
		if(rear == -1){//Avistador cuando la Queue se queda vacia por borrar todos sus elementos
			front--;
		}
	}
}
void main(){
	inicializar();
}```

Mi solucion fue en la funcion deQueue() eliminar el corrimiento de front dejandolo fijo al principio del arreglo y realizando un corrimiento al resto del mismo dejo el codigo:

void deQueue(){
    if(front == -1)
        printf("Nuestro Queue esta vació \n");
    else{
        printf("se elimino el valor de %d \n",values[front]);
        //*Corrimiento del arreglo
        for (int i = 0; i < rear; i++){
            values[i]=values[i+1];
        }
        //*Borro el valor actual de rear ya que fue movido
        values[rear]=0;
        //* Resto a uno rear para que este al final de la cola despues del corrimiento
        rear--;
        if(front >  rear)
            front = rear = -1;
    }
}

Mi implementación 😄

#include <stdio.h>
#define SIZE 5

int values[SIZE];
int front = -1, rear = -1;

// Optimiza los espacios y recorre los valores al inicio
void cleanQueue() {

  // No hay elementos
  if ( front == -1 ) {
    printf("No hay elementos, todo bien\n");
    rear = -1;
    return;
  }

  // Ya esta al inicio
  if ( front == 0 ) {
    printf("Nada que optimizar, la queue esta al inicio\n");
    return;
  }

  // Cuantos valores hay?
  int rango = rear - front + 1;

  //Temporal para ver donde ir insertando
  int insertarIzq = 0;

  // Recorrer los elementos he ir insertando a la izquierda
   for ( int i = front; i <= rango; i++ ) {
     values[insertarIzq] = values[i];
     insertarIzq++;
   }

   // Resetear elementos
   front = 0;
   rear = rango-1;
}

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

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

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

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

  // Optimizar el queue
  cleanQueue();
}

// Insertar un valor a la cola
void enQueue( int value ) {

  // Condicion de ver si la cola ya esta llena
  if ( rear == ( SIZE - 1 ) ) {
    printf("Nuestro queue esta lleno\n");
    return;
  }

  // Si no hay elementos, inicializar el front
  if ( front == -1 ) {
    front = 0;
  }

  // Extender el rear e insertar el valor
  rear++;
  values[rear] = value;
  printf("Se inserto el valor %d correctamente\n", value);
}

void printAll() {
  printf("\n----------\n");
  for ( int i = 0; i < SIZE; i++ ) {
    printf("%d, ", values[i]);
  }
  printf("\n");
  for ( int i = front; i <= rear; i++ ) {
    printf("%d, ", values[i]);
  }
  printf("\n----------\n");

}

int main(int argc, char const *argv[]) {
  enQueue(1);
  enQueue(2);
  enQueue(3);
  enQueue(4);
  enQueue(5);
  deQueue();
  enQueue(6);
  deQueue();
  deQueue();
  enQueue(7);
  deQueue();
  deQueue();
  deQueue();
  deQueue();
  deQueue();
  
  return 0;
}

ESTA ES LA FORMA EN QUE LO HICE EN PYTHON ( estoy abierto a sugerencias.)

import queue


cola = queue.Queue(5)

def enqueue():
    while cola.qsize() < 5:
        if fullqueue():
            print(f'La cola tiene {cola.qsize()} elementos.\n')
        valor = input('Ingresa un elemento a la cola:\n')
        cola.put(valor)
        print(f'El valor {valor} se inserto correctamente en la cola.\n')


def fullqueue():
    if cola.qsize() == 5:
        True
    elif cola.qsize() == 0:
        False


def dequeue():
    if cola.qsize() > 0:
        elemento = cola.get()
        print(f'El elmento {elemento} de la cola se a retirado.')
    elif cola.empty():
        print('YA NO HAY ELEMENTOS EN LA COLA')


def mostrar_cola():
    opc = input('AL MOSTRAR LOS ELEMENTOS DE LA COLA SE PERDERAN LOS DATOS ALMACENADOS ¿QUIERES SEGUIR? [Y] [N]:\n')
    if opc.lower() == 'y':
        i = 0
        print('Los elementos en la cola son:\n')
        while cola.qsize() > 0:
            print(f'{i} => {cola.get()}')
            i += 1
        print('\nLA COLA ESTA VACIA')
    elif opc.lower() == 'n':
        print('Bye, bye ...')

def menu():
    print("""
[1] Mostrar elementos de la cola.
[2] Ingresar elementos a la cola.
[3] Retirar elementos de la cola.
[4] Salir\n""")


def main():
    fin = False
    while not fin:
        menu()
        opc = int(input('Escoje una opcion:\n'))
        if opc == 1:
            mostrar_cola()
        elif opc == 2:
            enqueue()
        elif opc == 3:
            dequeue()
        elif opc == 4:
            fin = True

if __name__ == '__main__':
    main()

En mi caso yo resolví el reto asi:

#include<stdio.h>

#define SIZE 5
int items[SIZE], front = -1, rear = -1;

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 %d correctamente \n", value);
	}

}

void deQueue() {
	if (front == -1)
		printf("Nuestro Queue esta vacío \n");
	else {
		printf("Se eliminó el valor %d\n", items[front]);
		front++;
		if (front > rear || front < rear)
			front = rear = -1;
	}
}

int main(int argc, char const *argv[])
{	
	enQueue(1);
	enQueue(2);
	enQueue(3);
	enQueue(4);
	enQueue(5);
	deQueue();
	enQueue(6);
	return 0;
}```

Simplemente use el operador or (`||`) de C para que se evalué no sólo cuando el Queue esta lleno si no también cuando tiene un espacio disponible así:
`if (front > rear || front < rear)`

No conozco muy bien C así que no se si esta es la mejor solución

He realizado 2 implementaciones en python, una utilizando las listas (linked lists) y otra empleando arrays.

Código utilizando linked lists (listas de python)

import random

def de_queue(data, items):
    if(data['front'] == -1):
        print("Our queue is empty")
    else:
        print(f"The value {items[data['front']]} was removed")
        items.pop(data['front'])
        if len(items):
            data['rear'] -= 1
        else:
            data['front'] = data['rear'] = -1


def en_queue(value, data, items, SIZE):
    if data['rear'] == SIZE - 1:
        print("Our Queue is full")
    else:
        if data['front'] == -1:
            data['front'] = 0
        data['rear'] += 1
        items.append(value)
        print(f"The value {value} was added correctly")


def run(SIZE):
    items = []
    data = {
        'front': -1,
        'rear': -1
    }
    numbers_to_insert = SIZE
    numbers = [random.randint(0, 100) for i in range(numbers_to_insert)]

    for number in numbers:
        en_queue(number, data, items, SIZE)


if __name__ == '__main__':
    SIZE = 5 # limite de elementos para la cola

    run(SIZE)

Código utilizando arrays (usando numpy de python)

import random
import numpy as np

def de_queue(data, items):
    if(data['front'] == -1):
        print("Our queue is empty")
    else:
        print(f"The value {items[data['front']]} was removed")
        indices = list(range(0,items.size - 1))
        values = items[1:items.size]
        np.put(items, indices, values)

        if data['rear']:
            data['rear'] -= 1
        else:
            data['front'] = data['rear'] = -1

def en_queue_arr(number, data, items, SIZE):
    if data['rear'] == SIZE - 1:
        print("Our Queue is full")
    else:
        if data['front'] == -1:
            data['front'] = 0
        data['rear'] += 1
        items[data['rear']] = number
        print(f"The value {number} was added correctly")


def np_arrays(SIZE):
    items = np.empty(SIZE)
    data = {
        'front': -1,
        'rear': -1
    }
    numbers_to_insert = SIZE
    numbers = [random.randint(0, 100) for i in range(numbers_to_insert)]

    for number in numbers:
        en_queue_arr(number, data, items, SIZE)


if __name__ == '__main__':
    SIZE = 5 # limite de elementos para la cola

    np_arrays(SIZE)

Gráfico comparativo de los tiempos de ejecución de las 2 implementaciones anteriores

Solucion en JavaScript

const SIZE = 5;
    let front = -1;
    let rear = -1;
    let values = [];

    function enQueue (value) {
      if (rear == SIZE-1) {
        console.log('Nuestro Queue esta lleno');
      }else {
        if (front == -1) {
          front = 0;
        }
        rear++;
        values.push(value);
        console.log(`'Se anadio el valor ${value} en la posici'on ${rear}'`);
      }
    }

    function deQueue () {
      if(front == -1) {
        console.log('Nuestro Queue esta vacio');
      }else {
        console.log(`Se elimino el valor ${front} correctamente`);
        front++;
        rear--;
        if (front == SIZE) {
          front = rear = -1;
        }
      }
    }

Solución en C

#include<stdio.h>
#define SIZE 5

int values[SIZE], front = -1, rear = -1;

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

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

Java

• Haciendo borrado por listas completas
• Agreagar listas de manera dinamica
• Uso de scanner para ingresar valores por consola, solo un scanner por la cantidad x de valores ingresados

Class Impl

import java.util.ArrayList;
import java.util.List;


public class ArrayClass {
	
	String[] array; 
	List<Integer> numList = new ArrayList<>();
	int rear = -1;
	int front = -1;
	int SIZE;
	
	public void addArray(String elementos) {

	array = elementos.split("");
	SIZE = array.length;
	
	 if(front == -1) {
			 front = 0;
			 rear++;
				while(rear < SIZE) 
					
					numList.add(Integer.valueOf(array[rear]));
					System.out.println("Se inserto correctamente el valor " + numList.get(rear));
					rear++;
					}
				
	           }
	 if(rear == SIZE) {
			rear--;
		}
	 
		if(rear == SIZE-1) {
			System.out.println("Lista completa ");
		}
	}
	
	public void resetArray() {
		
		if(front == -1){
			System.out.println("Array vacio");
			}
		
			do{
				System.out.println("Se borro elemento " +  numList.get(0));
				numList.remove(0);
				front++;
			}while(front <= rear);
			
			if(front > rear) {	
				System.out.println("Se borro el array completamente");
				front = rear = -1;
			}
		}
}

Class Insert data

import java.util.Scanner;

public class Main {
	
	public static void main(String[] args) {
		
		Scanner sc = new Scanner(System.in);
		ArrayClass add = new ArrayClass();
		String opcion;
		String elementos;
		
		do {
			System.out.println("Inserte numeros");
			String num = sc.next();
			add.addArray(num);
			System.out.println("Seleccione una opcion");
			System.out.println("1 Agregar mas elementos");
			System.out.println("2 Borrar lista");
			opcion = sc.next();
			
			if(opcion.equals("2")) {
				add.resetArray();
				System.out.println("Seleccione una opcion");
				System.out.println("1 Agregar mas elementos");
				System.out.println("2 Borrar lista");
				opcion = sc.next();
				}
			
		}while(!opcion.equals("2"));
		

	}
}

Mi código en Python 3.7 del Reto:

"""
Pasos de nuestro Algoritmo:
•	Crear una Queue que vaya guardando los usuarios por orden de llegada.
•	Si llega otro usuario solicitando un pedido y hay espacio en la Queue, este se pone en la cola siempre y cuando haya espacio.
•	Cuando la orden del primer usuario ya esta lista, se entrega al usuario y se remueve este del al Queue,
    y así sucesivamente por orden de llegada. Siempre revisar antes si existen elementos para remover de la Queue.
"""
import os   #Libreria para manejar comandos propios del sistema operativo
from queue import Queue #Importamos la clase Queue, que simula una FIFO

def enqueue(colita, elemento):  # Función o método para insertar elementos en la cola
    if(colita.full()):  #Valida si la cola esta full
        print("No podemos atenderlo en estos momentos, estamos full")
        input("Digite 1 para seguir:")
    else:   #La cola no esta full
        colita.put(elemento)    #Función put agrega el elemento a la cola
        print("Se agrego correctamente su pedido {}".format(elemento))
        input("Digite 1 para seguir:")


def dequeue(colita): # Función o método para sacar elementos de la cola
    if(colita.empty()): #Valida si la cola esta vacia
        print("No hay pedidos para entregar")
        input("Digite 1 para seguir:")
    else: #La cola no esta vacia
        elemento = colita.get()
        print("Se entrega correctamente el pedido {}".format(elemento))
        input("Digite 1 para seguir:")

cola = Queue(5)  #Creamos el objeto cola de la clase Queue

while True:     #Bucle infinito para mostrar las opciones al usuario
    #os.system('cls')				#Limpia pantalla
    opciones = int(input("Digite el número para Opciones de Pedidos:\n 1. Ingresar un Pedido\n 2. Retirar su Pedido\n 3. Cerrar la Aplicación\n Opción:"))
    if(opciones == 1): #Ingresar un pedido
        pedido = input("Ingrese su número de pedido:")
        enqueue(cola,pedido)
    elif(opciones == 2): #Retirar un pedido
        dequeue(cola)
    elif(opciones == 3): #Cerrar la aplicación
        print("Se cerro la aplicación")
        break
    else:
        print("Digite correctamente una opción")```

Implementación… Con apuntes incluidos.

#include <stdio.h>
#define SIZE 5

int values[SIZE], front = 0, rear = -1, emptySpots = SIZE;

void enQueue(int value)
{
	if (rear == SIZE-1) //Si el queue esta lleno no se puede añadir más elementos.
		printf("Nuestro queue esta lleno.\n"); 
	else
	{
		printf("Se inserto el valor %d.\n", value); //Confirmación del elemento a añadir.
		rear++; //Al agregar un nuevo elemento al queue, el valor de rear incrementara en +1.
		emptySpots--; //Y por consiguente habrá un espacio vacio menos.
		values[rear] = value; //Asignara el nuevo valor a la lista (se almacenará al fondo).
	}
}

void deQueue()
{
	if (emptySpots == SIZE) //Imprime el mensaje diciendo que el queue está vacio si no hay valores en el.
		printf("Nuestro queue esta vacio.\n");
	else
	{
		printf("Se elimino el valor %d.\n", values[front]); //Mensaje mencionando el valor a quitar.
		for (int i = 0; i < SIZE; ++i)
		{
			values[i] = values[i + 1]; //Mueve todos los valores hacia adelante una posición.
		}
		values[rear] = 0; //"Borra" el valor trasero (que ya fue movido una posición adelante)
		rear--; //Mueve el rear un valor hacia adelante.
		emptySpots++; //Aumenta la cantidad de espacios vacios en el queue.
		if (emptySpots == SIZE) //Verifica si todos los valores fueron borrados.
			rear = - 1; //Restablece el valor de rear.
	}
}

void printQueue() //Imprime el queue.
{
	printf("Queue: ");
	for(int i = 0; i < SIZE; i++)
		printf("[%d]", values[i]);
	printf("\n");
}

int main(int argc, char const *argv[])
{
	for (int i = 0; i < SIZE; ++i) //Llenamos el queue.
	{
		enQueue(i + 1); 
		printQueue(); //La ultima iteración mostrará [1][2][3][4][5].
	}
	enQueue(1); //Mostrará que el queue está lleno.
	deQueue(); //Quitamos el primer elemento de la fila.
	printQueue(); //Mostrará [2][3][4][5][0].
	enQueue(1); //Añade 1 al final. 
	//Se soluciona el error ya que puede añadir nuevos elementmos independientemente de lo
	//lleno que esté el queue.
	printQueue(); //Mostrará [2][3][4][5][1].
	for (int i = 0; i < SIZE; ++i) //Vaciará el queue.
	{
		deQueue();
		printQueue(); //La ultima iteración mostrará [0][0][0][0][0].
	}
	deQueue(); //Mostrará que el queue está lleno.
	enQueue(10); //Añade un 10.
	printQueue(); //Mostrará [10][0][0][0][0].
	enQueue(20); //Añade un 20.
	printQueue(); //Mostrará [10][20][0][0][0].
	enQueue(30); //Añade un 30.
	printQueue(); //Mostrará [10][20][30][0][0].
	deQueue(); //Quitamos el primer elemento de la fila.
	printQueue(); //Mostrará [20][30][0][0][0].
	return 0;
}

Dale tu FeedBack a mi solucion con implementacion sobre criptomonedas (Depositos y Retiros) :
Hice un Queue Circular que verifica si esta lleno y evita sobreescribir el valor rear en front , con esta operacion de residuo, que use en las lineas 8,16,29.

(rear+1)%SIZE 

#include <stdio.h>
#define SIZE 5

int front=-1, rear=-1, balance=0;

//Funcion para depositar saldo a la billera-function to add wallet balance
void depositWallet(int deposit){
    if ( (rear+1)%SIZE == front ) 
        printf("\n Llegaste al limite, no puedes depositar \n");
    else
    {
        balance += deposit;
        printf("\n Fondos recibidos en tu wallet: %d, tu saldo es:%d ", deposit, balance); //Confirmar monto del deposito
        if (front == -1 || front == SIZE-1)
            front = 0;        
        rear = (rear+1)%SIZE; //queue circular
        printf("\trear = %i & front = %i", rear, front);
    }       
}

//Funcion para gastar saldo de la billetera-wallet balance spending function
void withdrawWallet(int withdraw){
    if (rear == -1 || balance == 0)
        printf("\n Tu saldo es: %d, no tienes criptomoneda para gastar", balance);
    else
    {
        balance -= withdraw;
        printf("\n Enviaste: %d, tu saldo es: %d", withdraw, balance);
        front = (front+1)%SIZE;
        printf("\t \t rear = %i & front = %i", rear, front);
    }    
}

int main()
{
    depositWallet(1);
    depositWallet(3);
    depositWallet(4);
    depositWallet(1);
    depositWallet(2);
    depositWallet(4);
    withdrawWallet(2);
    withdrawWallet(3);
    depositWallet(2);
    depositWallet(5);
    depositWallet(1);
    withdrawWallet(2);
    withdrawWallet(4);
    withdrawWallet(2);
    depositWallet(1);
    depositWallet(4);
    depositWallet(3);
    depositWallet(5);
    return 0;
}

Circular Queue, se llama el tipo de cola que permite siempre reutilizar el espacio sin tener que hacer deQueue de todos los elementos para volver a agregar uno.

#include <stdlib.h>
 10 #include <stdio.h>
  9 #include <stdbool.h>
  8
  7 #define SIZE 5
  6
  5 int values[SIZE], front = -1, rear = -1, size = 0;
  4
  3 bool isEmpty(){
  2   return size == 0;
  1 }
12
  1 bool isFull(){
  2   return size == SIZE;
  3 }
  4
  5 void enQueue(int value){
  6   if(isFull()){
  7     printf("The Queue is full\n");
  8   } else {
  9     rear = (rear + 1) % SIZE;
 10     values[rear] = value;
 11     size++;
 12     printf("The value %d was inserted successfuly\n", value);
 13   }
 14 }
 15
 16 void deQueue(){
 17   if(isEmpty()){
 18     printf("The Queue is empty\n");
 19   } else {
 20     front = (front + 1) % SIZE;
 21     size--;
 22     printf("The value was dequeued successfuly\n");
 23   }
 24 }
 25

Hice algunos cambios al programa, implementé un arreglo circular. Cuando hay un valor almacenado en la última posición del arreglo, el siguiente valor se guarda en la primera posición del arreglo (si el arreglo no está lleno), para ello empleo ésta instrucción:

rear = (rear + 1) % SIZE;

Es interactivo, puedes encolar y desencolar elementos las veces que quieras, siempre que no haya desborde y/o haya elementos en el arreglo según el caso. Se muestra como van los elementos. Claro que hay otras formas mejores de implementarlo. Aquí el código:

#include <stdio.h>
#define SIZE 5
int values[SIZE], front = -1, rear = -1;

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

void deQueue() {
    if(front == -1)
        printf("Nuestro Queue esta vacio\n");
    else {
        printf("Se elimino el valor %d\n", values[front]);
        values[front] = 0; // posición disponible para almacenar otro valor
        if(front == rear)
            front = rear = -1; // la cola esta vacía
        else
            front = (front + 1) % SIZE; // si front es la última posición del arreglo,  entonces front = 0
    }
}

void print_deQueue() {
    for(int i = front, j = 0; j < SIZE; j++) {
        if(values[i] != 0)
            printf("%d -> ", values[i]);
        i = (i + 1) % SIZE;
    }
}

int main(int argc, char const *argv[])
{
    int option, value;
    
    do
    {
        printf("\n\n1.- Enqueue\n");
        printf("2.- Dequeue\n");
        printf("3.- Salir\n");
        printf("Escoge una opcion: ");
        scanf("%d", &option);

        switch (option)
        {
            case 1:
                printf("Valor: ");
                scanf("%d", &value);
                enQueue(value);
                print_deQueue();
                break;
            case 2:
                deQueue();
                print_deQueue();
                break;
            case 3:
                printf("Fin del programa.");
                break;
            default:
                printf("Opcion No valida.");;
        }
    } while (option != 3);
    
    return 0;
}

#include <stdio.h>
#define SIZE 5
int values[SIZE],front = -1,rear = -1;

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

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

int main(int argc, char const *argv[])
{
	enQueue(1);
    enQueue(2);
    enQueue(3);
    enQueue(4);
	
	return 0;
}

al ejecutar mi codigo solo me inserta el numero uno, me pueden ayudar con el codigo

Quisiera hacer mas practicas con las estructuras de datos, me pueden enviar mas retos, por favor.

Les comparto el codigo con el que resolvi el reto. Use rear como variable principal y corri los datos cada vez que salia uno, dejando de esta manera el ultimo espacio disponible.

#include<stdio.h>
#define SIZE 5

int values[SIZE], front=0, rear=-1,i,j;

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

void deQueue(){
  if (rear == -1) {
    printf("Nuestro Queue esta vacio\n");
  }else{
     printf("Se elimino el valor %d\n", values[front]);
     for (j=0; j<5; j++) {
       values[j]=values[j+1];
     //printf("x %d %d\n", rear,values[j]);
     }
     rear--;

  }
  }

int main() {
  enQueue(1);
  enQueue(2);
  enQueue(3);
  enQueue(4);
  enQueue(5);
  deQueue();
  deQueue();
  deQueue();
  deQueue();
  deQueue();
  deQueue();
  enQueue(10);
  enQueue(11);

  for (i=0; i <5; i=i+1){
    printf("values[%d]: %d\n",i,values[i]);
  }
  return 0;
}

Otra vez problemas con la consola, mejor los compilo y ejecuto en codeblocks.

Al final he conseguido hacer la queue dinamica, funciona todo perfectamente, he eliminado el front de la ecuación para que siempre el dequeue extraiga el item en posicion 0 del array, y solo se mueve el rear.
Me ha parecido mas sencillo asi. y cuando se extrae un dato mediante queue, se mueve toda la cola una posición hacia atrás.

using System;
namespace queue
{
    class queueImplementación
    {
        const int size = 5;
        static int rear = -1;
        static int[] items = new int[size];
        static public void enQueue(int valor)
        {
            if (rear == size - 1) Console.WriteLine("Nuestro Queue, está lleno, no posible insertar: " + valor.ToString()); //Detectar si cabe otro item, sinó, mostrar error.
            else
            {
                rear++;
                items[rear] = valor;
                Console.WriteLine("Se insertó el valor " + valor.ToString() + " Correctamente");
            }
        }
        static public void deQueue()
        {
            if (rear < 0)
            {
                Console.WriteLine("no hay elementos a retirar");
            }
            else
            {
                Console.WriteLine("se eliminó el valor: " + items[0].ToString());
                moverCola();
                rear--;
            }
        }

        private static void moverCola()
        {
            switch (rear)
            {
                case 4:
                    items[0] = items[1];
                    items[1] = items[2];
                    items[2] = items[3];
                    items[3] = items[4];
                    items[4] = 0;
                    break;
                case 3:
                    items[0] = items[1];
                    items[1] = items[2];
                    items[2] = items[3];
                    items[3] = 0;
                    break;
                case 2:
                    items[0] = items[1];
                    items[1] = items[2];
                    items[2] = 0;
                    break;
                case 1:
                    items[0] = items[1];
                    items[1] = 0;
                    break;
                case 0:
                    break;
                default: Console.WriteLine("error, rear");break;
            }
            
        }

        static void Main(string[] args)
        {
        }
    }
}

Lo hice en c# por comodidad, puesto que el curso es de algoritmos he obviado el lenguaje a usar.

Me gustaria saber, si hay algun problema en hacerlo sin usar el front
¿trae algun problema hacerlo de este modo?

No me gusta mucho redireccionar toda la memoria, pero es la forma mas rapida que se me ocurrió a las 05:00 am 😛.
Básicamente, cuando se elimina un elemento en lugar de hacer front++; opto por hacer rear--;, de ese modo el front siempre queda apuntando a 0 y luego de quitar un elemento de front, para que el mismo no muestre un valor que se eliminó, recorro la lista de elementos y los muevo a la izquierda.

Saludos!

#include<stdio.h> // Para imprimir en pantalla
#define SIZE_QUEUE 5
#define VALUE_INIT -1

int rear = VALUE_INIT; // Posicion del ultimo elemento en la Queue
int front = VALUE_INIT; // Posicion primer elemento a tomar
int elementos[SIZE_QUEUE] = {VALUE_INIT};

int estaLlena() {
    return rear == SIZE_QUEUE - 1;
}

int noFueIniciada() {
    return front == VALUE_INIT;
}

void enQueue(int value) {
    // Si hay espacio, agregamos un elemento.
    if (estaLlena()) {
        // Esta lleno
        printf("ERROR: El Queue está lleno, no se puede agregar elementos.\n");
    } else {
        if (noFueIniciada()) {
            // Es el primer elemento que se agrega a la queue, cambio el front.
            front = 0;
        }
        rear++;
        elementos[rear] = value;
        printf("OK: Se agrego el '%d' correctamente.\n", value);
    }
}

void deQueue() {
    if (noFueIniciada()) {
        printf("ERROR: No hay elementos para obtener.\n");
    } else {
        printf("INFO: Se eliminó el valor %d.\n", elementos[front]);
        // El front es siempre 0, pero el ultimo elemento varia
        rear--;
        if (front > rear) {
            front = VALUE_INIT;
            rear = VALUE_INIT;
        }  else {
            for (int i = 0; i < SIZE_QUEUE - 1; i++) {
                elementos[i] = elementos[i + 1];
            }
        }
    }
}

int main(int argc, char const *argv[])
{
    enQueue(1);
    enQueue(2);
    enQueue(3);
    enQueue(4);
    enQueue(5);
    deQueue();
    enQueue(6);
    deQueue();
    return 0;
}

hola que tal un gran saludo a todos mi solución a el reto fue que al mismo código del Ing. celis antes de la linea 39 donde hace el incremento de la variable front (front++), inserte la variable rear con decremento( rear–) para que cada vez que se elimine un turno se pueda insertar otro, bueno buena suerte a todos.

Código

#include <stdio.h>
#define SIZE 5
int values[SIZE],front=-1,rear=-1;

void enQueue(int value)
{
    if(rear  == SIZE-1){
        printf("Nuestro queque esta lleno \n");
    }else{
        if(front  == -1){
            front = 0;
        }
        rear++;
        values[rear]=value;
        printf("Se inserto el valor %d correctamente\n",value);
    }
}
void deQueue()
{
    if(front == -1){
        printf("No hay elementos en nuestro Queue");
    }else{
        printf("Se elimino el valor %d \n",values[0]);
        rear--;
        for( int i = 0 ; i < SIZE-1;i++){
            values[i]=values[i+1];
        }
    }
    if(rear == 0){
        front = rear = -1;
    }

}
main(int argc, char const *argv[])
{
    enQueue(1);
    enQueue(2);
    enQueue(3);
    enQueue(4);
    enQueue(5);
    deQueue();
    deQueue();
    enQueue(6);
    enQueue(7);
    return 0;
}```

**#include <stdio.h>
#define SIZE 5
int values [SIZE], front = -1, rear = -1;

void enQueue (int value) {

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

}

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;
        } else {
            rear--;
        }
    }

}

main(int argc, char const *argv[])
{
    enQueue(1);
    enQueue(2);
    enQueue(3);
    enQueue(4);
    enQueue(5);

    deQueue();
    deQueue();

    enQueue(10);
    enQueue(11);
    enQueue(12);

    return 0;
}**```

Se debe tener muy buen manejo de los códigos para la estructuración del problema.

Me gusto mucho como quedo mi código, deje una secuencia de llamadas a las funciones que prueban todos los casos posibles. Ojala a alguien le ayude, tienen dudas no duden en ponerlo en los comentarios Saludos!

/* Para crear una Queue debemos seguir los siguientes pasos:

1 Crear un pointer para saber que hay en front y rear
2 Colocar estos valores en -1 al inicializar
3 Incrementar en 1 el valor de “rear” cuando agregamos un elemento
4 Retornar el valor de front al quitar un elemento e incrementar en 1 el valor de front a usar dequeue.
5 Antes de agregar un elemento revisar si hay espacios
6 Antes de remover un elemento revisamos que existan elementos
7 Asegurarnos de que al remover todos los elementos resetear nuestro front y rear a -1 y agregar el valor de 0 a 
Front al hacer nuestro primer enqueue
 */

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

int values [SIZE];
int copyValues [SIZE];
int front = -1, rear = -1, cfront = 0;

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

void deQueue(){
    if(front == -1){
        printf("Nuestro Queue esta vacio\n");
    }else{
        printf("Se elimino el valor %d\n", values[cfront]);
        for (int i = 0; i < SIZE; i++)
        {
            if(values[i + 1] != 0){
            copyValues[i] = values[i + 1];
            }else{
                copyValues[i]= -1;
            }
            
        }
        for (int i = 0; i < SIZE; i++){
            if (copyValues[i] != -1){
                values[i] = copyValues[i];
            }
            else{
                values[i] = 0;
            }
        }
        rear--;
        front++;
        if(copyValues[0] == -1){
            front = rear = -1;
        } 
    }
} 

int main(){

    deQueue();
    enQueue(10);
    enQueue(5);
    enQueue(7);
    enQueue(3);
    enQueue(8);
    deQueue();
    deQueue();
    enQueue(2);
    enQueue(4);
    enQueue(6);
    deQueue();
    deQueue();
    deQueue();
    deQueue();
    deQueue();
    deQueue();

    return 0 ;
}

Implementación completa de Queue
Se vacia y se llena de forma dinámica.

• enQueue(): Inserta un nuevo valor
• deQueue(): Devuelve el valor en cola
• size(): Nos muestra cuántos elementos tenemos almacenados en el queue
• isEmpty(): Nos muestra si el queue está vacío
• isFull(): Nos muestra si el queue está lleno

#include <stdio.h>
#define SIZE 5

int queue[SIZE], front = -1, rear = -1, saved = 0, amount = 0;

void enQueue(int value)
{
    saved = 0;

    if (rear > SIZE - 2)
    {
        if (front != 0)
        {
            rear = 0;
            saved = 1;
        }
    }
    else
    {
        if (rear + 1 != front)
        {
            rear++;
            saved = 1;
        }
    }

    if (front == -1)
        front = 0;

    if (saved)
    {
        queue[rear] = value;
        printf("Value %d was succesfully stored\n", value);
    }
    else
        printf("The queue is full, the value %d was not stored\n", value);
}

void deQueue()
{
    if (front == -1)
        printf("The queue is empty\n");
    else
    {
        printf("%d\n", queue[front]);
        if (front == rear)
        {
            front = -1;
            rear = -1;
        }
        else
        {
            if (front == SIZE - 1)
                front = 0;
            else
                front++;
        }
    }
}

void size()
{
    if (front == -1)
        amount = 0;
    else
    {
        if (rear >= front)
            amount = rear - front + 1;
        else
            amount = SIZE - (front - rear - 1);
    }
    printf("There are %d items in the queue\n", amount);
}

void isEmpty()
{
    if (front == -1)
        printf("The queue is empty\n");
    else
        printf("The queue is not empty\n");
}

void isFull()
{
    if ((front == 0 && rear == 4) || (front - rear == 1))
        printf("The queue is full\n");
    else
        printf("The queue is not full\n");
}

int main(int argc, char const *argv[])
{
    deQueue();
    enQueue(56);
    enQueue(2);
    deQueue();
    size();
    isEmpty();
    isFull();

    return 0;
}

Pase 1 hora viendo por que no compilaba, actualicé todo, usé compiladores online, instalé de nuevo gcc, para que me diera cuenta que lo que fallara era una “t” faltante en printf() xd

Aqui mi código del reto:

#include <stdio.h>
#define SIZE 5
int values[SIZE], front = -1, rear = -1;

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

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

int main(int argc, char const *argv[])
{
    enQueue(1);
    enQueue(2);
    enQueue(3);
    enQueue(4);
    enQueue(5);
    deQueue();
    enQueue(6);
    return 0;
}```

Creación dinámica de valores para Queue:

int main(int argc, char const *argv[])
{
	for(int i=0; i<5; i++){
        	enQueue(i);
	}
	for(int j=0; j<5; j++){
        	deQueue();
	}
return 0;
}

Lo malo con el codigo aqui implementado es que solo se puede alternar entre llenar y vaciar; es decir, no podemos insertar y remover elementos de manera dinamica (Como en el video, aunque elimino uno, el programa le seguia diciendo que estaba lleno. Por esto, tenia que vaciar todo el queue para poder volver a insertar mas elementos). Aqui les dejo un codigo en C++ que es bastante parecido pero que permite llenar y vaciar el Queue de manera dinamica.

#include <iostream>

#define SIZE 5

struct Queue {
  int* arr;
  int capacity; // Maxima capacidad del queue
  int front;
  int rear;
  int count; // Contador de elementos en el queue

  Queue (int cap) : capacity(cap) {
    arr = new int[cap];
    front = 0;
    rear = -1;
    count = 0;
  }

  ~Queue() { delete arr; }

  bool enQueue(int value) {
    if ( isFull() ) {
      std::cout << "Queue is full!\n";
      return 0;
    }

    rear = (rear+1) % capacity; // si se pasa del final, regresara al inicio
    arr[rear] = value;
    count++;
    return 1;
  }

  bool deQueue() {
    if ( isEmpty() ) {
      std::cout << "Queue is empty.\n";
      return 0;
    }

    front = (front+1) % capacity; // si se pasa del final, regresara al inicio
    count--;
  }

  int peek() {
    if ( isEmpty() ) {
      std::cout << "No items to show";
      return -1;
    }

    return arr[front];
  }

  bool isEmpty() {
    return count == 0;
  }

  bool isFull() {
    return count == capacity;
  }
};

int main() {
  Queue q(SIZE);
  q.enQueue(2);
  std::cout << q.peek() << "\n";

  return 0;
}

Asi solucione el reto
Elimine el “front++”, corri todos los datos hacia el lado izquierdo y le reste 1 a rear.

int items[SIZE], front = -1, rear= -1;

void enQueue(int value)
{
    if(rear == SIZE-1)
     {
        printf("The Queue is full \n");
     }
     else
        {
          if(front == -1)
            {
              front = 0;
            }
          rear++;
          items[rear] = value;
          printf("The value %d was inserted correctly \n", value);
        }
}

void deQueue()
{
    if(front==-1)
     {
       printf("The Queue is empty \n");
     }
     else
        {
         printf("The value %d was deleted correctly \n", items[front]);

         items[0]= items[1];
         items[1]= items[2];
         items[2]= items[3];
         items[3]= items[4];
         rear--;
         if(front > rear)
          {
            front = rear = -1;
          }

        }
}

main(int argc, char const *argv[])
{
    enQueue(1);
    enQueue(2);
    enQueue(3);
    enQueue(4);
    enQueue(5);
    printf("************************************** \n");
    deQueue();
    deQueue();
    deQueue();
    deQueue();
    deQueue();
    printf("************************************** \n");
    enQueue(6);
    enQueue(7);
    enQueue(8);
    enQueue(9);
    enQueue(10);
    return 0;
}****

Creo que debió declarar primero las variables “values, rear y front” antes de desarrolar el código para que se entendiera mejor.

<code>
/*
Crear un pointer para saber que hay en front y rear
Colocar estos valores en -1 al inicializar
Incrementar en 1 el valor de “rear” cuando agregamos un elemento
Retornar el valor de front al quitar un elemento e incrementar en 1 el valor de front a usar dequeue.
Antes de agregar un elemento revisar si hay espacios
Antes de remover un elemento revisamos que existan elementos
Asegurarnos de que al remover todos los elementos resetear nuestro front y rear a -1
*/

#include <stdio.h>
#define SIZE 5
int values[SIZE];
int front = -1;
int rear = -1;

void marchQueue(){
    for(int indice=0; indice < rear; indice++ )
        values[indice] = values[indice + 1];
    rear--;
}

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

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



int main(int argc, char const *argv[])
{
    enQueue(1);
    enQueue(2);
    enQueue(3);
    enQueue(4);
    enQueue(5);
    enQueue(6);
    deQueue();
    deQueue();
    deQueue();
    deQueue();
    deQueue();
    deQueue();
    enQueue(6);
    enQueue(6);
    return 0;
}

El curso ha estado genial, hasta ahora las clases y ejemplos me han gustado, espero que los demás los estén disfrutando tanto como yo!
Les muestro mi setup para esta clase:

Ejercicio queue con LIFO y menú.

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

int values[SIZE], front = -1, rear = -1, indexer, opc = 0, v = 0;
/*- values es el arreglo en el que se formará la pila, su caracter de Queue se le añade con el algoritmo de las funciones
  - front funciona como apuntador al primer elemento de la pila
  - rear funciona como apuntador al ultimo elemento de la pila que ha sido introducido
  - indexer funciona como iterador, necesario para recorrer los elementos del Queue cuando se elimina un elemento, ya que se elimina el elemento en el front
    y todos los que se encuentran despues deben ser desplazzados
  - opc se utiliza como variable de selección para el menú
  - v se usa como valor que se desea introducir para la función enQueue(); a la hora de invocar dicha función desde el menú*/

void enQueue(int value) //funcion para agregar elementos al Queue
{
    if (rear == SIZE-1 && front == 0) //estas condiciones nos indican que nuestro Queue está lleno
    {
        printf("Nuestro Queue esta lleno \n");
    }
    else
    {
        if (front == -1) //Estado inicial de Queue
        {
            front = 0; //front en su primer valor
            rear = 0; //rear en su primer valor
            values[rear] = value; //inserta el valor en la posición actual del rear (en este caso podría cambiarse por 0 ya que la condición asegura)
            					 //que estamos en el estado en que se está introduciendo por primera vez un valor a la Queue
            printf("\nSe inserto el valor correctamente: %d\n\n", value); 
            
        }
        else
        {
            rear++; //si no se cumple la condición anterior, solo se desplaza el apuntador rear
            values[rear] = value;
            printf("\nSe inserto el valor correctamente: %d\n\n", value); 
        }
    }
}

void deQueue() //función para eliminar elementos del Queue
{
    if (rear == -1) //el apuntador del front no se ha iniciado en 0 porque no hay nada en el Queue
    {
        printf("Nuestro Queue esta vacio\n");
    }
    else
    {
        printf("se elimino el valor %d\n", values[rear]);
        indexer = 0; //el indexer debe iniciar en 0 cada vez que se invoca la funcion para que siempre se hagan iteraciones empezando por el elemento 0

        rear--;
        
    }
     
}

void show() //función para mostrar los elementos del Queue 
{
    indexer = 0; //el indexer debe iniciar en 0 cada vez que se invoca la funcion para que siempre se hagan iteraciones empezando por el elemento 0
    if(rear == -1)
    {
    	printf("\nNuestro Queue esta vacio\n\n");
	}
	else
	{
		while(indexer <= rear)
    	{
        	printf("Registro %d: %d\n", indexer, values[indexer]); //itera la cantidad de veces que tenga de elementos el Queue e imprime el elemento en cada posición.
        	indexer++;
    	}	
	}
}

int main(int argc, char const *argv[])
{

    while (opc != 4) //while se usa para que el menu se continue mostrando hasta que se eliga la opcion "salir" en el menú
    {
        printf("----------Queue FIFO----------\n");
        printf("Opciones:\n");
        printf("Introducir(1)\nRetirar(2)\nVer Queue actual(3)\nSalir(4)\n\n");
        printf("Por favor introduzca su opcion: ");
        scanf("%d", &opc); //selección de opción para el menú.
        
        switch (opc)
        {
            case 1:
                printf("\nPor favor introduzca el valor que desea introducir: ");
                scanf("%d", &v);
                enQueue(v); //llamada a función con parametro indicado por el usuario
                system("PAUSE"); //pausa la ejecución para poder ver el resultado de la llamada a la función
                system("cls"); //limpia la pantalla para que no se recorra la aplicación en cada ejecución
                break;
    
            case 2:
                deQueue();
                system("PAUSE");
                system("cls");
                break;

            case 3:
                show();
                system("PAUSE");
                system("cls");
                break;

            case 4:
                printf("vuelva pronto!\n");
                system("PAUSE");
                break;
            
            default:
                printf("Por favor introduzca una opcion valida\n");
                system("PAUSE");
                break;
        }
    }
    
    
    return 0;
}

#include <stdio.h>
#define SIZE 5

int values[SIZE], front = -1, rear = -1;
//Queue -> Cola, First in, First Out (FiFo)


//enQueue -> Inserta un elemento en la cola
void enQueue(int value)
{
    if (rear == SIZE-1)  //verifica que la queue no este llena
    {
        printf("El queue esta lleno\n");
    } else {
        if (front == -1)  //verifica si la queue esta vacia
        {
            front = 0;  
        }
        rear++;  //aumenta uno a la cola
        values[rear] = value; //asigna el valor a la cola
        printf("Se inserto el valor %d correctamente\n", value);
    }
}

//deQueue -> Remueve el frente de la cola
void deQueue()
{
    int buffer = front;
    if (front == -1)  //verifica que la queue no este vacia
    {
        printf("El queue esta vacio\n");
    } else {
        printf("Se elimino el valor %d\n", values[front]);
        for ( int i = 0; i<=rear; i++ )
        {
            values[buffer] = values[buffer+1];
            buffer++;
        }
        rear--;
        if (front > rear)
        {
            front = rear = -1;
        }
    }
}

//Main
int main(int argc, char const *argv[])
{
    enQueue(1);
    enQueue(2);
    enQueue(3);
    enQueue(4);
    enQueue(5);
    deQueue();
    enQueue(10);
    deQueue();
    enQueue(15);
    return 0;
}

Por qué el profe escribe la línea “return 0” en la función main?

Buenas noches compañeros y compañeros, les comparto la solución a la que llegue. Espero les sea de ayuda y no duden en corregirme si me he equivocado!

Ejecutado en la terminal

Y les dejo un archivo donde hago un análisis a profundidad de como llegué a esa respuesta

Estoy de vuelta, aquí mi solución del Reto

#include <stdio.h>
#include <stdlib.h>

/* Definicion del tamaño de la cola */
#define SIZE 5

/* Definicion de las variables para la cola y punteros de control*/
int queue[SIZE], front = -1, rear = -1;

/* Funcion para insertar un elemento en la cola */
void enQueue ( int value )
{
    if ( front == 0 && rear == SIZE-1 )
    {
        printf ( "The Queue is full \n" );
    } else {
        if ( front == -1 && rear == -1 ) {
            front++;
            rear++;
        } else {
            rear++;
        }
        queue[rear] = value;
        printf ("The value = %d was entered correctly \n", value);
    }
}

/* Funcion para eliminar un elemento en la cola */
void deQueue()
{
    if ( front == -1 && rear == -1 ) {
        printf ("The Queue is empty \n");
    } else {
        printf ( "Value %d was successfully removed \n", queue[front] );
        for ( int i = 0; i < rear; i++ ) {
            queue [i] = queue [i + 1] ;
        }
        if ( front == 0 && rear == 0 ) {
            front--;
            rear--;
        } else {
            rear--;
        }
    }
}


int main()
{
    deQueue();
    enQueue (1);
    enQueue (2);
    enQueue (3);
    enQueue (4);
    enQueue (5);
    enQueue (6);

    deQueue();
    enQueue (1);
    deQueue();
    deQueue();
    deQueue();
    deQueue();
    deQueue();
    deQueue();
    deQueue();

    return 0;
}

#include <stdio.h>
#define SIZE 5
int values[SIZE], front = -1, rear = -1;

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

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

int main(int argc, char const *argv[])
{
  enQueue(1);
  enQueue(2);
  enQueue(3);
  enQueue(4);
  enQueue(5);
  deQueue();
  deQueue();
  deQueue();
  deQueue();
  deQueue();
  deQueue();
  enQueue(10);
  enQueue(10);
  enQueue(10);
  enQueue(10);
  enQueue(10);
  enQueue(10);
  return 0;
}

dejo mi código, anduve probando otras cosas, pero no sé por qué en vs code no genera la salida en consola y en la página https://replit.com si mostraba bien el resultado, así que guarde aparte este código que si muestra salida en vs code.

#include <stdio.h>
#define SIZE 5

int values[SIZE], front = -1, rear = -1;
int i,temporal;

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

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


void MostrarValoresArreglo(){
  
    printf("----------------------------------------------\n");
    for( i = 0; i <= SIZE-1; i++)
            {
                printf("Valor [%d] = %d \n", i, values[i]);
            }
    printf("----------------------------------------------\n");
}

void MostrarValoresFrontRear(){
    printf("----------------------------------------------\n");
    printf("Valor de front= %d, valor de rear= %d\n", front,rear);
}


int main(int argc, char const *argv[])
{
    enQueue(1);
    enQueue(2);
    enQueue(3);
    enQueue(4);
    enQueue(5);
    MostrarValoresFrontRear();
    MostrarValoresArreglo();
    deQueue();
    deQueue();
    MostrarValoresFrontRear();
    MostrarValoresArreglo();
    enQueue(34);
    MostrarValoresFrontRear();
    MostrarValoresArreglo();
    deQueue();
    MostrarValoresFrontRear();
    MostrarValoresArreglo();
    return 0;
}

me tome mi tiempo jajaj

//1 - crear pointer para saber que hay en front y rear.


//2 - colocar estos valores en -1 al inicializar. 
//3 - incrementar en 1 el valor de "rear" cuando agregamos un elemento.
//4 - retornar el valor del front al quitar un elemento e incrementar
    //en 1 el valor de front al usar el dequeue.
//5 - antes de agregar un elemento revisar si hay esapcio.
//6 - antes de remover un elemento revisamos que existan elementos.
//7 - asegurarnos que al remover todos los elementos
    //resetear nuestro front y rear a -1 y agregar el valor de 0
    //a front al hacer nuestro primer queue.

#include <stdio.h>
#define SIZE 5
int values [SIZE], front = -1, rear = -1;

void enQueue(int value){
    if(rear == SIZE-1)
    printf("Maxima Capacidad \n");
    else {
        if(front == -1)
            front = 0;
        rear++;
        values[rear] = value;
        printf("seagrago el dato %d correctamenre \n", value);
    }
}

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

}
int main(int argc, char const *argv[])
{
    enQueue(10);
    enQueue(1);
    enQueue(20);
    enQueue(17);
    enQueue(16);
    deQueue(10);
    enQueue(100);
    enQueue(200);
    return 0;
}

Implementando librería queue en python, corrige lo del reto en un código más optimo.

Outpul:

item 1 was inserted correctly
item 2 was inserted correctly
item 3 was inserted correctly
item 4 was inserted correctly
item 5 was inserted correctly
Full Queue
item 1 has been removed
item 6 was inserted correctly
item 2 has been removed
item 3 has been removed
item 4 has been removed
item 5 has been removed
item 6 has been removed
Empty Queue

Ha sido frustrante para mi tener que pasar de c a python. Aunque después de muchas horas vi que realmente era prácticamente lo mismo.
Agradezco a Dios por GPT que me ayudo 🤣 y me explicó todo.

enqueue

dequeue

#run/ output

Si se ejecuta el deQueue sin tener valor asumo que leera el if con la variable front en -1 y se imprimira que el Queue esta lleno.

Yo hice el reto en C#, implementando esta clase Queue con estas modificaciones en sus métodos, la base de todo está en el módulo:

using System;

namespace EstructurasDeDatosYAlgoritmos
{
    internal class Queue
    {
        public int size = 5;
        public int rear;
        public int front;
        public int[] items;
        
        public Queue(int size)
        {
            this.rear = -1;
            this.front = -1;
            this.items = new int[size];
            this.size = size;
        }

        public void enQueue(int value)
        {
            if(rear - front == size - 1)
            {
                Console.WriteLine("Nuestro Queue está lleno \n");
            }
            else
            {
                if (front == -1)
                    front = 0;
                rear++;
                items[rear % size] = value;
                Console.WriteLine($"Se inserto el valor {value} correctamente \n");

            }
        }
        public void deQueue()
        {
            if (front == -1)
                Console.WriteLine("Nuestro Queue está vacío \n");
            else
            {
                Console.WriteLine($"Se eliminó el valor {items[front % size]}");
                front++;
                if(front > rear)
                {
                    front = rear = -1;
                }
            }
        }
    }
}

Así hice mi código, espero les sirva

#include <stdio.h>
#include <stdlib.h>

#define MAX_QUEUE_SIZE 3

int queue[MAX_QUEUE_SIZE];
int front = 0; // puntero al inicio de la cola
int rear = -1; // puntero al final de la cola
int count = 0; // número de elementos en la cola

void enqueue(int value) {
    // Comprobar si la cola está llena
    if (count >= MAX_QUEUE_SIZE) {
        printf("La cola está llena.\n");
    } else {
        // Actualizar posición del puntero rear
        rear = (rear + 1) % MAX_QUEUE_SIZE;
        // Añadir elemento al final de la cola
        queue[rear] = value;
        // Incrementar contador de elementos en la cola
        count++;
    }
}

int dequeue() {
    if (count <= 0) {
        printf("La cola está vacía.\n");
        return -1;
    } else {
        int value = queue[front];
        front = (front + 1) % MAX_QUEUE_SIZE;
        count--;
        printf("se borrara: ");
        return value;
    }
}

int main() {
    enqueue(1);
    enqueue(2);
    enqueue(3);

    printf("%d\n", dequeue()); // imprime 1
    printf("%d\n", dequeue()); // imprime 2
    printf("%d\n", dequeue()); // imprime 3

    enqueue(7);
    
    for (int i = 0; i < MAX_QUEUE_SIZE; i++)
    {
        printf("%d", queue[i]);
    }
    

    return 0;
}

Reto: Llenar y vaciar el queue dinámicamente:

Reto: Llenar y vaciar el queue dinámicamente:

Esta es mi solución al reto.
Encontré que se tiene que restar 1 a rear, porque lo que estamos haciendo en la función deQueue es liberar una posición del arreglo y la variable rear tiene el valor del tamaño del arreglo. Por lo que al reducir uno a esta variable nos permite seguir ingresando datos, actualizando el número de elementos
También agregué esta condición en la misma función porque así permite que la función indique cuando el arreglo está vacío:
if((front == -1)||(rear==0)){
Se aceptan comentarios para mejorar, espero que les sirva.
Saludos 😄 !

Solución al reto:

#include <stdio.h>

#define SIZE 5

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

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

void mover(){
    for(int i = 0; i < rear; i++)
        values[i] = values[i + 1];
    rear--;
    front = 0;
}

void print(){
    for(int i = 0 ; i <= rear; i++)
        printf("%d ",values[i]);
    printf("\n");
}

int main(){
    enQueue(0);
    enQueue(1);
    enQueue(2);
    enQueue(3);
    enQueue(4);
    print();
    deQueue();
    deQueue();
    enQueue(6);
    enQueue(0);
    enQueue(1);
    enQueue(2);
    enQueue(3);
    enQueue(4);
    print();
    deQueue();
    deQueue();
    deQueue();
    deQueue();
    deQueue();
    deQueue();
    print();
    enQueue(6);
    enQueue(0);
    enQueue(1);
    enQueue(2);
    enQueue(3);
    print();
}

Esta es mi solución, supongo que hay mejores maneras de hacerlo, pero esta me pareció la más lógica.
Aquí no necesito el front porque cuando remuevo un número muevo todos los valores de array una posición adelante y por eso el elemento que está por salir siempre está en la posición 0 del array.
A más le añadí un menu para que se lo pueda usar como una aplicación normal y no tener todo quemado en al código
Este es mi código:

#include <stdio.h>

#define SIZE 5

int rear = -1, values[SIZE];

void deQueue() {
    if(rear == -1)
        printf("No se puede sacar el valor, porque el queue está vacio");
    else {
        printf("Se va a eliminar el valor de %d del queue", values[0]);
        for(int i = 0; i < SIZE - 1; i++) {
            values[i - 1] = values[i];
        }
        rear--;
    }
}

void enQueue() {
    int value;
    if(rear == SIZE - 1)
        printf("No se puede ingresar más valores, porque el queue está lleno");
    else {
        printf("Ingrese el valor que quiere agregar: ");
        scanf("%d", &value);

        values[++rear] = value;
        printf("Se añadió el valor de %d correctamente", value);
    }
}

int main() {
    unsigned char option;

    do {
        printf("\n¿Qué desea hacer?");
        printf("\nAgregar un dato [1]");
        printf("\nQuitar un dato [2]");
        printf("\nSalir[9]");
        printf("\nOpción: ");
        scanf("%hhd", &option);

        switch (option) {
            case 1:
                enQueue();
            break;
            case 2:
                deQueue();
            break;
            case 9:
            break;
            default:
                printf("Ingrese una opción valida");
            break;
        }
    } while (option != 9);

    return 0;
}

// Fue lo mas interactivo que pude Hacerlo 👽

#include<stdio.h>
#define SIZE 5
int front = -1, rear = -1;
int values[SIZE] = {0, 0, 0, 0, 0};
// [-1, 0, 0, 0, -1]

// Agregar elemento a cola:
void enQueue(int value){
if(rear == SIZE-1)
printf(“Nuestro Queue esta lleno\n” );
else {
if(front == -1)
front = 0;
rear++;

    values[rear] = value;
    printf("Se inserto el valor %d correctamente\n", value);

}

}

// Quitar elemento de cola:
void deQueue(){
if(front == -1)
printf(“Nuestro Queue esta vacio\n” );
else {
printf(“se elimino el valor %d\n”, values[front]);
front++;
rear–;

    if(front > rear)
    front = rear = -1;

}

}

void elige(){
int valor = scanf;
int value;
printf(“Elige una opcion: \n”);
printf(“1.- Agregar valor a queue: \n”);
printf(“2.- Remover valor a queue: \n”);
printf(“3.- Imprimir estado de queue: \n”);
scanf("%d", &valor);
if (valor == 1)
{
//int value;
printf(“Que valor quieres agregar? \n”);
scanf("%d", &value);
enQueue(value);
printf("… \n");
elige();

}
else if (valor == 2){
    int ralue;
    printf("Que valor quieres Remover? \n");
    scanf("%d", &ralue);
    deQueue();
    printf("... \n");
    elige();


}
else if (valor == 3){

    printf("%d", values[rear]);
    printf("... \n");
    elige();

}
else{
    int respu = scanf;
    printf("Error 404: \n");
    printf("Reintentar: yes == 1  /  no == Cualquier tecla: \n");
    scanf("%d", &respu);
    if (respu == 1)
    {
        elige();
    }
    else {
        printf("Fin de la QueueMulation... \n");
    }
    
}

}

main(int argc, char const *argv[])
{
elige();

}

Esta es mi solución. Si encuentran alguna falla, hacérmela saber por favor, así mejoro mi aprendizaje.
.
La única duda que tengo, es si es correcto poner vacío un espacio del Array usando " ". Quise ponerle 0, pero pues cero igual es un valor, así que no me pareció correcto.
.
Lo que hago en el código es que al borrar un valor, el resto lo re posiciono hasta el inicio del Queue, trasladando no solo su valor, sino también el indicador de front y rear, y dejo en vacío las posiciones anteriores.
.
Solo esta sección es lo que cambie, el resto del código es similar al de la clase.

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

En Java

Scanner sc = new Scanner(System.in);
		int op;
		int insert = 0;
		InQueue queueTest =  new InQueue();
		
		do {
			System.out.println("-- Choose an option --");
			System.out.println("1. Add an element");
			System.out.println("2. Delete and element");
			System.out.println("3. Out");
			op = sc.nextInt();
			switch (op) {
			case 1:
				queueTest.inQueue(insert);
				insert++;
				break;
			case 2:
				queueTest.delQueue();
				break;
			case 3:
				System.out.println("Bye");
				break;
			}
			
		} while (op != 3);```

Hola chicos, agregue una lógica adicional al metodo deQueue, para quitar y agregar dinámicamente valores a la cola. Ejemplo de entrada:
exampleOne.enQueue(1);
exampleOne.enQueue(2);
exampleOne.enQueue(3);
exampleOne.enQueue(4);
exampleOne.deQueue();
exampleOne.deQueue();
exampleOne.enQueue(5);
exampleOne.enQueue(6);

A continuación dejo el método:

private void deQueue() {
        if (front <= -1) {
            System.out.println("Our queue is empty");
        } else {
            System.out.println("front is " + front + " the value " + values[front] + " is remove");
            front++; //1
            if (front > end) {
                front = -1;
                end = -1;
            }
            int i = 0;
            while (i < values.length) {
                if (i + 1 == values.length) {
                    end--;
                    front--;
                    break;
                }
                int aux = values[i + 1];
                values[i] = aux;
                i++;
            }
        }
    }

Aquí dejo mi versión del código visto en clases. Este añade todas las operaciones de una Queue que vimos en el glosario de funciones para ADT.

#include <stdio.h>

//Definition of the queue size
#define SIZE 5

//Declaration of queue
int values[SIZE], front = -1, rear = -1;

//Declaration of queue functions
void enQueue(int); 	//Inserts elements at the end of the queue
int deQueue();       	//Remove and returns the first element of the queue
int peek();        	//Returns the first element of the queue
int isEmpty();    	//Returns true if the queue is empty
int isFull();      		//Returns true if the queue is full

int main()
{
    deQueue();
    enQueue(1);
    enQueue(2);
    enQueue(3);
    enQueue(4);
    enQueue(5);
    enQueue(6);
    printf("The first is: %d\n", peek());
    deQueue();
    printf("The first is: %d\n", peek());
    deQueue();
    deQueue();
    deQueue();
    deQueue();
    deQueue();
    printf("The first is: %d\n", peek());
    
    return 0;
}

void enQueue(int value)
{
    if (isFull())
        printf("The Queue is full.\n");
    
    else
    {
        if (isEmpty())
            front = 0;
        
        rear++;
        values[rear] = value;
        printf("The value %d was inserted.\n", value); 
    }
}

int deQueue()
{
    int first = -1;

    if (isEmpty())
        printf("The Queue is empty.\n");

    else
    {
        first = values[front];
        printf("The value %d was eliminated\n", values[front]);
        front++;

        if (front > rear)
            front = rear = -1;
    }
    
    return first;
}

int peek() 
{
    if (!isEmpty())
        return values[front];

    return -1;
}

int isEmpty()
{
    if (front == -1) 
        return 1;
    
    return 0;
}

int isFull()
{
    if (rear == SIZE - 1)
        return 1;

    return 0;
}

Salida:

The Queue is empty.      
The value 1 was inserted.
The value 2 was inserted.
The value 3 was inserted.
The value 4 was inserted.
The value 5 was inserted.
The Queue is full.       
The first is: 1
The value 1 was eliminated
The first is: 2
The value 2 was eliminated
The value 3 was eliminated
The value 4 was eliminated
The value 5 was eliminated
The Queue is empty.
The first is: -1

Mi reto utilizando python.

#Creamos la cola
def create_queue():
queue = []
return queue

#Llenamos la cola
def en_queue(queue,front,rear):
if len(queue) >1:
print(‘El arreglo está lleno’)
return queue

else:
    while rear <4:
        numero = int(input('Ingresa un número: '))
        if front == -1 :
                front +=1
                rear +=1
                queue.insert(front,numero)
        else:
                rear +=1
                queue.insert(rear,numero)
                
    return queue
    print(queue)

#Vaciamos la cola
def del_queue(queue,front,rear):
if len(queue) == 0:
print(‘La cola está vacia’)
return queue
else:
print(queue[0])
queue.pop(0)
return queue

def main():
front =-1
while True:
print(’----------- Opciones-----------’)
print(‘1. Crear arreglo’)
print(‘2. Registrar un turno’)
print(‘3. Llamar un turno’)
print(‘4. Salir’)
option = int(input('Selecciona una opción: '))

if option == 1:
    cola=create_queue()
    file =1
    rear = -1
    front = -1
    print(cola)
elif option == 2:
    if 'file' not in locals():
        print ('La fila no existe')
    else:
        cola=en_queue(cola,front,rear)
        if front == 0:
            rear +=1
        print(cola)
elif option ==3:
    cola=del_queue(cola,front,rear)
elif option ==4:
    print('Bye, Bye')
    break

if name == ‘main’:
main()

aqui mi reto

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

int item[SIZE], front = -1, rear = -1;

void enQueue (int valor){
    if (rear == SIZE - 1){
        printf("el queue esta lleno\n");
    }
    else{
        if (front == -1)
            front = 0;
        rear ++;
        item[rear]= valor;
        printf("se inserto el valor %i correctamente\n", valor);
    }
}

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

int main()
{
    enQueue(1);
    enQueue(5);
    enQueue(6);
    enQueue(7);
    enQueue(8);
    enQueue(10);
    deQueue();
    deQueue();
    deQueue();
    deQueue();
    deQueue();
    enQueue(100);
    return 0;
}

Que tal colegas.

Yo lo implementé en JS.

let Ordenes = []
class Orden {
    constructor(platillo, bebida) {
        this.Orden = {
            platillo: platillo,
            bebida: bebida
        }
        this.Pointer = {
            front: false,
            rear: 0
        }
    }

    enQueue() {
        //Agrega elemento y checar si hay espacio para agregar
        console.log(this.Orden)
        if (this.Pointer.rear === 3) {
            console.log('No hay espacio para añadir su orden, intente más tarde')
        }else {
          
            if(this.Pointer.front === false) {
                Ordenes.push(this.Orden)
                this.Pointer.front = true
            }else {
                //Sumar 1 en rear
                Ordenes.unshift(this.Orden)
                this.Pointer.rear++
            }

        }

        
    }

    deQueue() {
        //Remover elemento y checar si hay que eliminar.
        if (this.front === false) {
            console.log('No hay ordenes que entregar')
        }else {
            setTimeout(() => {
                switch(this.Pointer.rear) {
                    case 0:
                        //Eliminar el primero que llego
                        Ordenes.shift()
                        console.log('La orden ha sido entregada')
                        this.Pointer.front = false
                        this.Pointer.rear = 0
                        break;
                    case 1:
                        Ordenes.shift()
                        this.Pointer.rear--
                        break;
                    case 2:
                        Ordenes.shift()
                        this.Pointer.rear--
                        break;
                    case 3:
                        Ordenes.shift()
                        this.Pointer.rear--
                        break;
                }
            }, 8000)
        }
        
        //Al eliminar todos los elementos, dejar front y rear en -1
    }


}

const Rafael = new Orden('hamburguesa', 'fresca')
const Chava = new Orden ('Hotdog', 'Coca')
const George = new Orden ('pastel', 'leche')

Rafael.enQueue()
Chava.enQueue()
George.enQueue()

console.log(Ordenes)

Rafael.deQueue()
console.log(Ordenes)

Yo encontré una solución diferente a las ya publicadas. Lo que hice fue inmediatamente después de eliminar un elemento muevo los restante una posición hacia adelante, así me aseguro de que la posición 0 de la lista la ocupe siempre el próximo elemento a ser eliminado y que los espacios para agregar nuevos elementos queden al final. Así se evitan errores al intentar insertar un nuevo elemento cuando ya se han eliminado algunos

Yo esperaba que hicieramos una Queue con estructuras y apuntadores :c

#include<stdio.h>
#define SIZE 5
int values[SIZE], front = -1, rear = -1;

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

void deQueue(){
    if(front == -1 || rear == -1) // si front o rear es -1
        printf("Nuestro Queue esta vacio\n");
    else{
        printf("Se elimino el valor %d\n", values[front]);
        for(int auxiliar=0; auxiliar != rear; auxiliar++){ //Un ciclo que nos ayudara a mover los valores de posicion
            values[auxiliar] = values[auxiliar + 1];
        }
        values[rear] = 0; //esta instruccion es para que el último valor se muestre "eliminado"
        rear --; //el rear se mueve a la posicion anterior
        /*front++;
        if(front>rear)
            front = rear = -1;*/
    }
}

void show(){ //esta funcion muestra el contenido de la Queue y sus posiciones
    for(int i =0;i<SIZE;i++){
        printf("Valor %d en la posicion %d\n", values[i], i);
    };
}

int main(){
    show();
    enQueue(1);
    enQueue(2);
    enQueue(3);
    enQueue(4);
    enQueue(5);
    show();
    deQueue();
    enQueue(10);
    deQueue();
    enQueue(20);
    show();
    deQueue();
    deQueue();
    deQueue();
    deQueue();
    deQueue();
    show();

    return 0;
}```

<code>
/* Modificacion de la funcion void para que sea una cola dinamica*/
27 void deQueue(){
 1   int aux  = 0;
 2   if(front == -1)
 3     printf("Nuestro Queue esta vacio \n");
 4   else{
 5     printf("Se elimino el valor %d \n", values[front]);
 6     /*
 7       Muevo todos los valores un espacio hacia el frente, asi, mi front siempre sera 0, o el inicio de la cola. 
 8     */
 9     for(int i = 0; i < rear-1; i++){
10       aux = values[i+1];
11       values[i] = aux;
12     }
13     values[rear] = 0;
14     /*
15       Regreso en una posicion el rear despues de eliminar el primer elemento
16     */
17     rear--;
18     if(front > rear) 
19       front = rear = -1;
20   }
21 }

Logre completar el reto en php

<?php

class Queue
{

  protected $size  =  5;
  protected $front = 1;
  protected $values = [];
  protected $rear  ;

  public function enQueu(int $value)
  {
    if(count($this->values) >= $this->size )
    {
      echo "Nuestro Queue esta lleno \n";
    }
    else
    {
      $this->values[count($this->values)] = $value;
      echo "Se inserto el valor $value correctamente \n";
    }
  }

  public function deQueue()
  {
    if(count($this->values) == 0)
    {
      echo "Nuestro Queue esta vacio \n";
    }
    else{
      echo "Se elimino el valor ".$this->values[0] . "\n";
      $this->values = array_slice($this->values,$this->front);
    }
  }
}

$queue = new Queue;

$queue->enQueu(1);
$queue->enQueu(2);
$queue->enQueu(3);
$queue->enQueu(4);
$queue->enQueu(5);
$queue->enQueu(6);
$queue->enQueu(7);
$queue->deQueue();
$queue->deQueue();
$queue->deQueue();
$queue->deQueue();

$queue->enQueu(15);
$queue->enQueu(45);
 
$queue->deQueue();
$queue->deQueue();

$queue->deQueue();
$queue->deQueue();

#include <stdio.h>
#define SIZE 5

int values[SIZE], front = -1, rear = -1;

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

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

int main(int argc, char const *argv[]) {
    enQueue(1);
    enQueue(2);
    enQueue(3);
    enQueue(4);
    enQueue(5);
    deQueue();
    deQueue();
    deQueue();
    deQueue();
    deQueue();
    enQueue(10);
    return 0;
}```

Cumpliendo el reto 😃
Auque es sobre una interpretación de lo que le entendí al profe.

Esta programación permite ingresar mas de 5 datos, siempre que supera los cinco va reordenando la cola, pasando el de segunda posición al primero, el tercero al segundo y así sucesivamente. Siempre que se agregue un nuevo dato se le posiciona en última posición. Y cuando se elimina (deQueue) se toma el primer valor de la cola.

#include<stdio.h>
#define SIZE 5
int values[SIZE], rear = -1;


void enQueue(int value){
    if(rear == SIZE-1){
        int i;
        for(i=0; i<rear; i++)
        {
            values[i]=values[i+1];
        }
        values[rear]=value;
        printf("Se reordena la cola e insertó el valor %d correspondiente \n", value);
        }
    else {
        rear++;
        values[rear] = value;
        printf("Se insertó el valor %d correspondiente \n", value);
        }
}

void deQueue(){
    if (rear == -1)
        printf("Nuestro Queue está vacío\n");   
    else {
        printf("Se eliminó el valor %d de la primera posición \n", values[0]);
        int i;
        for(i=0; i<rear; i++)
        {
            values[i]=values[i+1];
        }
        // if(rear == 0){
        //     values[rear]="";
        // }
        rear--;    
    }
}

main(int argc, char const *argv[])
{
    enQueue(1);  
    enQueue(2);  
    enQueue(3);  
    deQueue();
    deQueue();
    deQueue();
    enQueue(2);  
    enQueue(3);  
    enQueue(4);  
    enQueue(5);  
    enQueue(6);  
    enQueue(7);  
    printf("Value[0] %d \n", values[0]);
    printf("Value[1] %d \n", values[1]);
    printf("Value[2] %d \n", values[2]);
    printf("Value[3] %d \n", values[3]);
    printf("Value[4] %d \n", values[4]);
    return 0;
} ```

Aquí dejo mi aporte completo:

#include <stdio.h>
#define SIZE 5
int values[SIZE], front = -1, rear = -1;

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

void deQueue() {
    if(front == -1) {
        printf("Nuestro Queue esta vacío\n");
    } else {
        printf("Se elimino el valor %d\n", values[front]);
        for(int i = 0; i < rear; i++) {
            values[i] = values[i + 1];
        }
        values[rear] = 0;
        rear--;
        if(front > rear) {
            front = rear = -1;
        }
    }
}

void printQueue() {
    printf("-----------------------------\n");
    if(rear == -1)
        printf("Nuestro Queue esta vacío\n");
    else{
        int i;
        for(i = 0; i <= rear; i++)
            printf("Posición %d: %d\n", i, values[i]);
    }
    printf("-----------------------------\n");
}

int main(int argc, char const *argv[])
{
    enQueue(1);
    enQueue(2);
    enQueue(3);
    enQueue(4);
    enQueue(5);
    deQueue();
    enQueue(6);
    enQueue(7);
    enQueue(8);
    enQueue(9);
    deQueue();
    deQueue();
    enQueue(10);
    enQueue(11);
    printQueue();
    return 0;
}

Lo que agregué fue:

        for(int i = 0; i < rear; i++) {
            values[i] = values[i + 1];
        }
        values[rear] = 0;
        rear--;```

void deQueue() {
if(front == -1) {
printf(“Nuestro Queue esta vacío\n”);
} else {
printf(“Se elimino el valor %d\n”, values[front]);
for(int i = 0; i < rear; i++) {
values[i] = values[i + 1];
}
values[rear] = 0;
rear–;
if(front > rear) {
front = rear = -1;
}
}
}

#include <stdio.h>
#define  SIZE 5

int values[SIZE], front = -1, rear = -1;

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

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

int main()
{
	enQueue(1);
	enQueue(2);
	enQueue(3);
	enQueue(4);
	enQueue(5);

	deQueue();
	deQueue();
	deQueue();
	deQueue();
	deQueue();
	deQueue();

	return 0;
}

Les comparto este link para los que están aprendiendo a usar vim

https://www.arsys.es/blog/soluciones/comandos-vim/#Los_modos_de_Vim

Reto Cumplido

/* 1.	Crear un pointer para saber que hay en front y rear
2.	Colocar estos valores en -1 al inicializar
3.	Incrementar en 1 el valor de “rear” cuando agregamos un elemento
4.	Retornar el valor de front al quitar un elemento e incrementar en 1 el valor de front a usar dequeue.
5.	Antes de agregar un elemento revisar si hay espacios
6.	Antes de remover un elemento revisamos que existan elementos
7.	Asegurarnos de que al remover todos los elementos resetear nuestro front y rear a -1
 */
#include "stdio.h"
#define SIZE 5
int values[SIZE], front = -1, rear = -1;

void vaciador(){
    for (int i = 0; i > SIZE; i++ ){
        values[i] = 0;
    }
}

void aKiller(){
    for (int i = SIZE - 1; i > rear; i--)
    {
        values[i] = 0;
    }
}

void corrector(){
    values[0] = values[1];
    values[1] = values[2];
    values[2] = values[3];
    values[3] = values[4];
}

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

void deQueue(){
    if(front == -1){
        printf("el queue esta vacio : ( añade un numero para poder eliminarlo  \n");
    }
    else{
        printf("se elimino el valor %d\n", values[front]);
        rear --;
        
        corrector();
        aKiller(); 
    }
}

void prQueue(){
    for(int i = 0; i <= rear; i++) {
        printf("posicion: %d es = %d\n", i, values[i]);
    }
}

int main(int argc, char const *argv[])
{   
    /* inserte aca enqueue() y dequeue() */
    vaciador();
    prQueue();
    return 0;       
}

Mi aporte en Python, ahora con input para que el usuario pueda ingresar elementos y eliminar elementos.

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

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

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

def extract():
    global queue
    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
    elif front == rear:
        print(f"{queue[front]} was deleted")
        queue[front] = ""
        print("Queue is now empty")
        front = rear = -1
    else:
        print(f"{queue[front]} was deleted")
        queue[front] = ""
        front += 1
    
def run():
    option = 0
    while option != 4:
        menu = """
            Welcome, choose an option:
            1 - Add a customer
            2 - Delete the last customer
            3 - See the queue
            4 - Exit
            """

        option = int(input(menu))

        if option == 1:
            value = input("Client's name: ")
            insert(value)
        elif option == 2:
            extract()
        elif option == 3:
            print(f"{queue} front: {front} rear: {rear}\n")   
        elif option == 4:
            print("Goodbye")    
            break
        else:
            print("Incorrect Option")


if __name__ == "__main__":
    run()

Mi aporte con python

SIZE = 5
rear = -1
front = -1
items = []

def enQueue(value):

    global rear
    global front
    global items

    if rear == (SIZE - 1):
        return 'Nuestro queue esta lleno, Sorry!'
    else:
        if front == -1:
            front = 0
        rear += 1
        items.append(value)
        return 'Se inserto el valor ' + str(value) + ' correctamente'



def deQueue():
    global rear
    global front

    if front == -1:
        return "Nuestro Queue esta vacio"
    else:
        print("Se elimino el valor " + str(items[front]))
        items.pop(front)
        front = 0 

        if len(items) == 0:
            front = rear = -1 
            
        return items


def run():

    print(deQueue())
    print(enQueue(8))
    print(enQueue(10))
    print(enQueue(40))
    print(enQueue(50))
    print(enQueue(15))
    print(enQueue(100))
    print(deQueue())
    print(deQueue())
    print(deQueue())
    print(deQueue())
    print(deQueue())
    print(deQueue())
    print(deQueue())
    print(enQueue(120))



if __name__ == "__main__":
    run()

Una pregunta respecto al codigo:

#include <stdio.h>
#define SIZE
int items [SIZE];
int rear = -1;
int front = -1;
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 a agregado el valor correctamente: %d \n", value);
    }
}
void deQueue(){
    if (front == -1)
        printf("Nuestro Queue esta vacio \n");
    else{
        printf("Se elimino el valor:  %d \n",items[front]);
        front++;
        if(front > rear){
            front = rear = 0;
        }
    }
}
int main(int argc, char const *argv[])
{
    deQueue();
    return 0;
}

por que las if no tienen llaves y aun asi funcionan?

Este es mi codigo en python

class Queue:

    def __init__(self, size):
        self.size = size
        self.values = []
        self.rear = -1
        self.front = -1

    def enQueue(self, value):
        if self.rear == self.size-1:
            print('Nuestro Queue esta lleno')
        else:
            if self.front == -1:
                self.front = 0
            self.rear += 1
            self.values.append(value)
            print(f'Se inserto el valor {value} correctamente\n')

    def deQueue(self):
        if self.front == -1:
            print('Nuestro Queue esta vacio\n')
        else:
            print(f'Se elimino el valor {self.values[self.front]}')
            self.values.pop(self.front)
            self.front += 1
            if self.front > self.rear:
                self.front = self.rear = -1
            else:
                self.front -= 1
                self.rear -= 1

    def show(self):
        print(self.values)


if __name__ == "__main__":
    lista = Queue(5)
    lista.deQueue()
    lista.show()
    lista.enQueue(10)
    lista.show()
    lista.enQueue(11)
    lista.show()
    lista.enQueue(12)
    lista.show()
    lista.enQueue(13)
    lista.show()
    lista.enQueue(14)
    lista.show()
    lista.enQueue(15)

Dejo el código del reto y la implementación de los métodos de la queue.

#include<stdio.h>
#include <stdbool.h>
#define SIZE 5
int values[SIZE], front = -1, rear= -1;

int Size(){
    return (rear-front)+1;
}

bool isFull(){
    return Size() == SIZE;
}

bool isEmpity(){
    return front == -1;
}

void printQueue(){
    int index;
    for(index=front;index<=rear;index++){
        printf("%d",values[index]);
        if (index+1<=rear)
            printf(" -> ");
    }
    printf("\n");
}

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

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

int main(int argc, char const *argv[])
{
    enQueue(1);
    enQueue(2);
    enQueue(3);
    enQueue(4);
    enQueue(5);
    deQueue();
    enQueue(6);
    deQueue();    
    deQueue();
    enQueue(7);
    enQueue(8);
    enQueue(9);    
    deQueue();
    enQueue(9);
    deQueue();
    enQueue(10);
    return 0;
}

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

Les comparto mi desafio

#include <stdio.h>
#define SIZE 5//Definir el tamano del ARRAY. NO lleva ;
int values[SIZE], front = -1, rear = -1, total =5;//Separar con , cuando todas las variables


//enQueue Agrega un elemento al final de la estructura
void enQueue(int value) //void no retorna ningun valor, solo guarda el valor
{
	if(rear == total - 1) //Verificar que tenemos espacios disponibles en el array
		printf("Nuestro Queue esta lleno \n"); // \n salto de linea
	else
	{
		if(front == -1)
			front = 0;
			rear++; // ++incrementa en 1 la variable
			values[rear] = value; //Guardando el valor en la posicion que estamos generando
			printf("Se inserto el valor %d correctamente\n", value);
	}
}


//Dequeue Remueve un elemento al inicio de la estructura
void deQueue() // NO requiere argumentos
{
	if(front == -1) //Verificar que tenemos valores en front
		printf("Nuestro Queue esta vacio \n");
	else
	{
		printf("Se elimino el valor %d \n", values[front]);
		front++;
		total++;
		if(front > rear)
			front = rear = -1;
	}
}


//main code
int main(int argc, char const *argv[])
{
	enQueue(1);
	enQueue(2);
	enQueue(3);
	enQueue(4);
	enQueue(5);
	enQueue(6);
	deQueue();
	deQueue();
	enQueue(7);
	enQueue(8);
	enQueue(9);
	deQueue();
	deQueue();
	deQueue();
	deQueue();
	deQueue();
	deQueue();
	return 0;
}

Me doy por vencido en la programación.

¿oye pero no estamos tratando el queue como lifo envés de fifo?

Una posible solución al reto!.

#include<stdio.h>
#define SIZE 5

int values [SIZE], front = -1, rear = -1;

void enQueue(int value)
{
    if(rear == SIZE-1)
        printf("Nuestro Queue esta lleno \n");
    else
    {
        if (front == -1) 
        {
            front = 0;
        }
        rear++;
        values[rear] = value;
        printf("Se inserto el valor %i correctamente \n", value);
    }
}
void deQueue()
{
    if (front == -1) 
        printf("Nuestro Queue esta vacio \n");
    else
         printf("Se ELIMINO el valor %i CORRECTAMENTE \n", values[front]);
         rear -= 1; /* Se resta un valor al rear */
        front++;

    if (front > rear)
        front = rear = -1; 
}

int main(int argc, char const *argv[])
{
    enQueue(1);
    enQueue(2);
    enQueue(3);
    enQueue(4);
    enQueue(5);
    deQueue();
    enQueue(10);
    deQueue();
    enQueue(6);
    deQueue();
    enQueue(7);
    enQueue(8);
    
    return 0;
}

void deQueue()
{
    if(front == -1)
    {
        printf("La cola esta vacia\n");
    }
    else
    {
        //Cambie el valor del indice front por rear
        printf("Se elimino el valor %d \n",values[rear]);
        front++;
        //Decremento la variable rear
        rear--;

        if(front>rear)
        {
            front=rear=-1;
        }
    }
    
}

excelente forma de explicar me encanta!!!

gracias ricardo

A continuación les dejo mi aportación en Java.
Si alguien pregunta la razón por la que utilicé un ArrayList, fue para poder almacenar también el valor 0 dentro de nuestros posibles valores.

<code>
package PrimerA;

import java.util.ArrayList;
import java.util.List;

public class Queue {

	private static final int SIZE = 5;

	List<Integer> values = new ArrayList<>(SIZE);
	
	public int front = -1, rear = -1, init = 0;

	public void enqueue(int value) {
		if (rear == SIZE - 1) {
			System.out.println("Nuestro queue está lleno");
		} else {
			if (front == -1) {
				front = 0;
			}
			rear++;
			

			if (init == 0) {
				values.add(rear, value);
			} else {

				values.set(rear, value);
			}
			System.out.println("Se insertó el valor " + value + " correctamente");

		}

	}

	public void dequeue() {

		if (front == -1) {
			System.out.println("Nuestra Queue está vacía");
		} else {
			System.out.println("Se eliminó el valor " + values.get(front));
			
			values.set(front, null);

			if (values.get(0) == null) {
				values.set(0, values.get(1));
				values.set(1, null);
			}
			if (values.get(1) == null) {
				values.set(1, values.get(2));
				values.set(2, null);
			}
			if (values.get(2) == null) {
				values.set(2, values.get(3));
				values.set(3, null);
			}
			if (values.get(3) == null) {
				values.set(3, values.get(4));
				values.set(4, null);
			}
			if (values.get(4) == null) {
				values.set(4, null);
			}

		}

		rear--;

		init = 1;

		if (front > rear) {
			front = rear = -1;
		}
	}

	public static void main(String args[]) {

		Queue queue1 = new Queue();

		queue1.enqueue(1);

	
		queue1.enqueue(2);
		queue1.enqueue(3);
		queue1.enqueue(4);
		queue1.enqueue(5);
		queue1.dequeue();
		queue1.dequeue();
		queue1.dequeue();
		queue1.dequeue();
		queue1.dequeue();
		queue1.dequeue();
		queue1.enqueue(19);
		queue1.enqueue(23);
		queue1.enqueue(34);

	
	}

}

Saludos.

Hola! Yo busque como podria hacerse para sacar un elemento de un array, pero no encontre lo que buscaba.

Lo unico que encontre fueron bucles que cambian de lugar los valores de los indices para que parezca que el elemento se elimino, pero el array tiene la misma cantidad de elementos.

for (c = position - 1; c < n - 1; c++){
         array[c] = array[c+1];
         printf("El valor de C %d \n", array[c]);
        }
      printf("Resultant array:\n");
 
      for (c = 0; c < n - 1; c++)
         printf("%d\n", array[c]);

- 

Nos da a elegir una posicion que queremos eliminar, pero como la posicion es de 1 a 5 y no de 0 a 4
lo que hace es restarle 1 a position para que sea el indice correcto y no se pase de 4.

Luego compara c con n - 1, (n es la cantidad de numeros) al restarle 1 a n obtenemos la cantidad de indices.
Iguala el valor del indice que queremos “eliminar” con el valor del indice siguiente.
Luego de la igualacion se hace un bucle que imprima todos los numeros menos el ultimo para que parezca que se elimino el numero que queriamos.
¿Por que no se imprimen todos los numeros?
Solo imprime 4 numeros porque cuando C vale 4 no se imprime nada, porque C seria igual a n y no menor como la condicion lo pide.

pues yo todavía no se programar en “c”, pero no se tan complejo como dicen xd

Mi solucion

#include "stdlib.h"
// #include "stdio.h"
#define SIZE_ARRAY 5

int values[SIZE_ARRAY], front = -1, rear  = -1, total = -1;

void enQueue(int value){
    if (total == SIZE_ARRAY - 1)
        printf("Nuestro Queue esta lleno\n"); 
    else{
        if (front == -1)
            front = 0;
        rear+=1;
        total+=1;
        values[rear] = value;
        printf("se ha insertado el valor %d correctamente:\n ", value);
    }
}

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

int main(int argc, char const *argv[])
{
    enQueue(1);
    enQueue(2);
    enQueue(3);
    enQueue(4);
    enQueue(5);
    deQueue();
    enQueue(10);

    
    return 0;
}