Implementación de la función dequeue en estructuras de datos en C

Clase 18 de 42 • Curso Práctico de Estructuras de Datos y Algoritmos

Clase anteriorSiguiente clase

Resumen

En esta clase estructuramos el código de la función deQueue que nos quita el primer elemento de nuestro Arreglo LIFO.

Emmanuel García

student•

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

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

Más info:

Jared Zena

student•

Muy bien, muchas gracias! solo una correccion: shift() elimian un elemento al principio del arreglo

Andrés Fernando Cortés Pinzón

student•

En la mayoría de los lenguajes de programación existen métodos/funciones para el manejo de arreglos, pero la idea del proyecto en este momento es crear las funciones que hacen esas tareas, asi lograr un poco de agilidad al momento de solucionar problemas y crea su algoritmos.

Emmanuel Guerra Sánchez

student•

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

Ricardo Celis

teacher•

omg! Voy a corregir eso!

Johan Mora

student•

Con cuidado es un héroe

Alex Abel Lerman

student•

En Javascript:

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

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

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

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

Andrés Campuzano Garzón

student•

Es más entendible en JS

Daniel Esteban Santos Mendez

student•

Aquí no estarías sacando el ultimo que ingreso si lo haces con pop() y push()?

Deberíser ser: unshift() para agregar pop() para sacar o push() para agregar shift() para sacar

Jeyson David Vargas Crespo

student•

Hola, la verdad no he entendido nada de esto de los ADT, en este caso los deQueue y enQueue siempre se debe hacer eso o como funcionan, estoy desesperándome...

Gracias por la ayuda.

Ricardo Chacón García

student•

deQueue se usa para extraer un elemento y enQueue se usa para agregar un elemento.

Hector Esau M

student•

Tranquilo es normal estar abrumado por tanta información de un golpe Lo que pasa es que hay funciones predeterminadas y listas para usar caso printf, que aunque no escribes como funciona la puedes utilizar (que simplemente es para imprimir cosas en la pantalla), pero hay otras que puedes crear tu mismo que es el caso enQueue y deQueue Con deQueue es como decirle "Siguinete" en una fila del supermercado y deQueue es darle una ficha a alguien que acaba de llegar

David Santiago González Ramos

student•

Este es mi codigo en JS

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

Efraín Hernández García

student•

Te quedó muy bien David

Youssef Abarca

student•

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

Ricardo Asin

student•

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

Ricardo Celis

teacher•

Hola tocayo, por ejemplo en un proyecto de backend donde tengas que vender boletos puedes implementar un queue para ordenar a las personas que van llegando a comprar, para un sitio web donde importa el orden en el que se registran por ejemplo los usuarios, o medir los primeros diez que terminen x cosa.

Wandy Rafael Santana Evangelista

student•

En JS.

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

Nicolas Restrepo

student•

class Queue:

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

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

                self.queue.append(name)

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

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

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

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

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

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

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

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

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


if __name__ == "__main__":

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

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

            """)

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

Martí Falcón Padró

student•

Muy bueno

David Santiago González Ramos

student•

Comparto con ustedes un repositorio de Github en el que ire subiendo lo que se trabaje en este curso.

Leisy Karina Algarra Fernandez

student•

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

Fernanda Vieira Jófili

student•

¡Es lo que importa! Las cosas por las que más nos esforzamos son las que brindan la mayor satisfacción.

Ricardo García Ortega

student•

Hola Buenas tardes. Estoy trabajando con Visual Studio Code para esta clase pero al momento de escribir lineas de código no me aparecen las lineas onduladas o una advertencia de error en el código. ¿Si me podrían ayudar activar las lineas de advertencia se los agradecería demasiado de ante mano?

Sergio Rubiano

student•

Hola!

Con gusto te ayudo, puedes compartir una captura de la advertencia o de lo que te aparece, de esa manera de podre dar una respuesta clara. gracias

Ricardo García Ortega

student•

Muchas gracias por intentar ayudarme, pero ya resolví mi problema resulta que tenia des-habilitada una opción en la extensión de C/C++, pero agradezco el gesto de intentar ayudarme

Jose Antonio Marín López

student•

Función deQueue

int deQueue() {
    if(front == -1) printf("Empty queue :(\n");
    else {
        front++;
        if(front > rear) rear = front = -1;
        printf("Element %i deleted from queue.", queue[front]);
    }
    return 0;
}

Jonathan Gonzalez Botero

student•

Hola chicos, estoy bien o el metodo deQueue no se implementó nada para eliminar el elemento? hizo falta eliminar el elemento de values, no?

Miguel Bedoya

student•

Hola amigo. Tienes razón, en C lo que falta hacer para eliminar realmente el elemento es liberar el uso de la memoria que ha sido asignada para el elemento que se elimina, lo cual se realiza con la función free.

Luis Franco

student•

En realidad habria sido mejor poner en null denuevo la posicion de memoria liberada, pero en este caso como que no importa porque la idea que quizo dar el profesor es aparentar que la elimino, ya que una vez eliminada no es la idea verificar si la posicion de la estructura fue eliminada.

Alejandro Ramos Entrellardat

student•

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

Emilio Sala

student•

cierto, si no se actualizan las posiciones despues de hacer un dequeue(), ya no tendriamos disponibles las 5 posiciones hasta que llegaramos al caso de que front > rear y reseteamos la cola por completo. una chapuza

Karen Paola Diaz Duarte

student•

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

freddy molleda

student•

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

Johan Nieto

student•

deQueue en Javascript

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

Ignacio Saccomano

student•

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

Javier

student•

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

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

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

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

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

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

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

class Queue:

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

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

                self.queue.append(name)

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

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

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

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

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

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

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

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

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


if __name__ == "__main__":

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

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

            """)

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

int deQueue() {
    if(front == -1) printf("Empty queue :(\n");
    else {
        front++;
        if(front > rear) rear = front = -1;
        printf("Element %i deleted from queue.", queue[front]);
    }
    return 0;
}

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

Implementación de la función dequeue en estructuras de datos en C

Bienvenido al Curso

Algoritmos y Estructuras de Datos: Curso Básico

Introducción a los algoritmos

Cómo Funcionan las Computadoras y el Sistema Binario

Introducción a Lenguajes de Programación: Bajo y Alto Nivel

Estructuras de Datos para Rutas Más Cortas en Mapas

Algoritmo de Dijkstra para encontrar la ruta más corta

Metodología para Resolver Algoritmos Paso a Paso

Variables y Tipos de Datos en Programación

Creación de Tipos de Datos Personalizados en C

Configuración de Ubuntu en Windows 10 para C/C++

Implementación de User Defined Data Type en C: Estructuras paso a paso

Tipos de Datos Abstractos y Estructuras de Datos en Programación

Tipos Abstractos de Datos: Lista, Pila, Cola y Diccionario

Tipos Abstractos de Datos: Listas, Pilas y Colas

Clases y objetos

Colas y estructuras de datos: gestión de pedidos en restaurante

Implementación de Queues con Arrays en Visual Studio Code

Implementación de Abstract Data Type en C: Función enqueue

Implementación de la función dequeue en estructuras de datos en C

Implementación de Colas en C: Declaración y Uso de Funciones Básicas

Algoritmos de ordenamiento

Algoritmos de Ordenamiento: Conceptos y Aplicaciones Básicas

Funcionamiento del Algoritmo de Ordenamiento Burbuja

Implementación de Bubble Sort en C paso a paso

Implementación de Bubble Sort en C y función de impresión

Ordenamiento por Inserción en C: Algoritmo y Ejemplo Práctico

Algoritmos de Ordenamiento Descendente: Implementación Práctica

Recursividad

Recursividad en Programación: Entendiendo el Factorial

Factorial Recursivo en C: Implementación y Ejemplo

Inversión de cadenas con recursividad en Java

Recursividad en Python: Arte con Turtle y Funciones Recursivas

Divide and conquer y programación dinámica

Diseño y análisis de algoritmos: Divide y vencerás

Introducción a Programación Dinámica y Quicksort

Ordenamiento de Arrays con MergeSort en C

Algoritmos de Ordenamiento de Datos de Mayor a Menor

Algoritmo Quicksort en Python: Implementación y Funcionamiento

Ordenamiento Quick Sort en Python paso a paso

Algoritmos 'Greedy'

Algoritmos Voraces: Principios y Aplicaciones Prácticas

Implementación de Algoritmo Greedy para Cambio de Monedas

Cambio de Monedas en C++: Implementación y Ejecución

Grafos y árboles

Introducción a Árboles y Grafos: Estructuras de Datos Básicas

Estructura de Datos: Árboles y sus Componentes Básicos

¿Cómo comparar Algoritmos?

Comparación de Algoritmos: Complejidad y Ritmo de Crecimiento

¿Qué sigue?

Resolución de Problemas Básicos con Algoritmos y Estructuras de Datos