Creando tu primera Queue: implementación.

Muchachos comparto esta foto porque solo así yo logré entender la idea del algoritmo…sé que ya los arrays vienen con funciones integradas que podrían facilitar esto, pero siempre es bueno conocer “algoritmicamente” hablando como funcionan las cosas desde adentro.
 
Espero que esta foto ayude a muchos.

Los arrays (y cualquier otro dato en programación) tienen la capacidad de contar sus elementos. Por ejemplo, el string "fulano" tiene 6 elementos (f, u, l, a, n y o) y el siguiente array tiene 3 elementos: ["pepito", "pizza", "pablito"].

Sin embargo, si queremos acceder a la primera posición de nuestras variables no buscamos la posición 1, sino la posición 0. Y, por lo mismo, la segunda posición en realidad es la posición 1:

Esta es la famosa confusión de la que habla el profe en la clase 😄. Ejemplo:

array[0] // pepito
array[1] // pizza
string[0] // f
string[1] // u
string[2] // l

TRABAJAREMOS CON QUEUE:
PASOS:

1. Crear un pointer para saber que hay en el front y rear
2. Colocar estos valores en -1 al inicializar
3. Incrementar en 1 el valor de rear cuando agreguemos algún elemento
4. Retornar el valor de front al quitar algún elemento, y incrementar en 1 el valor de front al usar dequeue
5. Ante de agregar algún elemento revisar si hay espacio (ISEMPTY()) importante, ya que si no revisamos se puede estar perdiendo información importante.
6. Antes de remover algún elemento revisamos que existan elementos (ISEMPTY()) se debe revisar, ya que al no haber elementos nos dirá que removió algún elemento cuando realmente no ha hecho nada
7. Asegurarnos de que al remover todos los elementos resetear nuestro front y rear a -1. Importantísimo, ya que si no reseteamos cuando retomemos algún valor nos puede dar 5, el cual no existe, ya que tenemos solo 5 posiciones iniciando en cero (0,1,2,3,4).
   Este queue lo vamos a realizar con un Array, ya que sabemos el numero de elementos que se van a guardar en el Array.
   Lo mejor es inicializar en -1, ya que siempre en programación se utiliza la posición 0 (cero).


Hola compañeros aqui les dejo un video para en tender un poco mejor los queue. Solo vean los 4 primeros minutos 😃

queue

Si empezamos estudiando lista ADT, stack ADT y queue, en videos anteriores. ¿Por qué empezamos analizando un ejemplo de Queue?. Saludos!

Entiendo el posicionamiento 0,1,2,3,4 para cinco locaciones
No me es claro el comportamiento del QUEUE
Pero mi interpretación es:

• El pointer siempre leerá el campo cero (0)
• Cuando se atiende el campo cero, este sale y debe hacer un reset para actualizar el campo 0 moviendo los ocupantes del 1 al cero, el 2 al 1, el 3 al 2, … y si el rear lee una posición 5, moverla al 4, para mantener las y locaciones ocupadas y evitar perder información.
• Si el rear no encuentra mas ocupantes en cola, quedará vacía la posición 4, luego, la 3 hasta agotar las ocupaciones en el campo 0

Por favor colaborarme con ese concepto. Gracias

Tener claro lo que vamos a programar es esencial:

/* 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 de front al quitar un elemento */
/* 5- Incrementar en 1 el valor de front al usar dequeue */
/* 6- Antes de agregar un elemento revisar si hay espacio */
/* 7- Antes de remover un elemento revisar que existan elementos */
/* 8- Asegurarnos de que al remover todos los elementos asignemos -1 a front y rear */

• Implementación de cola básica en python
• Cabe destacar que en python hay un módulo que implementa una cola de manera eficiente este se llama collections.deque más info en la documentación

class QueueExample:
    def __init__(self, max_length:int):
        self.queue = []
        self.max_length = max_length

    def is_queue_empty(self) -> bool:
        return len(self.queue) == 0
    
    def is_queue_full(self) -> bool:
        return len(self.queue) == self.max_length

    def enqueue(self, element_to_enter):
        """ encolar  """
        if not self.is_queue_full():
            self.queue.append( element_to_enter )
        else:
            raise Exception("La Cola está llena")
            
    def dequeue(self):
        """ desencolar  """
        if not self.is_queue_empty():
            return self.queue.pop(0)
        else:
            raise Exception("La Cola está vacía")

    def show_queue(self):
        for x in self.queue:
            print(f'[{x}]') 

new_queue = QueueExample(2)
print(new_queue.is_queue_empty())
print(new_queue.is_queue_full())
new_queue.enqueue("elemento1")
new_queue.enqueue("elemento2")
new_queue.show_queue()
new_queue.dequeue()
new_queue.show_queue()
new_queue.dequeue()
new_queue.dequeue() # Error cola vacía

class Cola:
    
    def __init__(self, max_e):
        self.max_element = max_e
        self.cola = list()
        
    
    def encolar(self, e):
        if (len(self.cola) < self.max_element):
            self.cola.append(e)
        else:
            print("Cola llena")
            
    def desencolar(self):
        return self.cola.pop(0)
    
    
    def imprimir(self):
        return self.cola
        
        
    def disponibles(self):
        return self.max_element - len(self.cola)
    
    
    def llena(self):
        if (len(self.cola) == self.max_element):
            return True
        else:
            return self.disponibles()
        

if __name__ == '__main__':
    reserva = Cola(5)
    reserva.encolar("Pedro")
    reserva.encolar("Juan")
    reserva.encolar("Alicia")
    print("Imprimimos reservas pendientes {}".format(reserva.imprimir()))
    print("Quedan {} disponibles".format(reserva.disponibles()))
    print("El siguiente es {}".format(reserva.desencolar()))
    print("Imprimimos reservas pendientes {}".format(reserva.imprimir()))```

Python con funciones

fila = ["juan", "pepe", "alan", "chucho", "daniel"]

def formarse():
    if len(fila) == 5:
        print("Fila llena vuelva despues")
        return fila
    else:
        formado = input("Quien se va a formar?: ")
        fila.append(formado)
        return fila

def quitar_lista():
    if len(fila) == 0:
        print("Fila vacia")
        return fila
    else:
        fila.pop(0)
        return fila

def run():
    return fila


if __name__ == "__main__":
    while True:
        to_do = input("""
**********************
Elije una accion:
1 - ver fila
2 - formarse en la fila
3 - salir de la fila
0 - Salir del programa
""")
        if to_do == "0":
            break
        elif to_do == "1":
            print(run())
        elif to_do == "2":
            print(formarse())
        elif to_do == "3":
            print(quitar_lista())
        else:
            print("comando no conocido")

pues que empiece con 0 como que te acostumbras, si empieza con 1 ya se te hace raro

Claramente que los arrays empiezen en 0 hace más dificil de comprender para el iniciado, pero te facilita entender la relación entre array y pointer, y la memoria dinámica.

En los queue el primer elemento que entra es el primero en salir.
Enqueue: Utiliza el comando Enqueue para agregar un elemento al final de la estructura.
Dequeue: Utiliza el comando Dequeue para remover un elemento al principio de la estructura.

Buen paso a paso, un poco de dudas porque queda con la imaginación pero esperamos quede más claro implementando.

Gracias por resaltar la importancia de trabajar bien con la información

Yo pensé que aquí íbamos a implementar código, pero no fue así

Memory leak: es un error de software que ocurre cuando un bloque de memoria reservada no es liberada en un programa de computación. Comúnmente ocurre porque se pierden todas las referencias a esa área de memoria antes de haberse liberado.

• front puntero que apunta al inicio de la cola.
• rear puntero que apunta al final de la cola.

Entiendo que en este ejemplo la sólo se puede llenar una vez, ya que si una vez llenada relizamos la accion de dequeue(), ya no podremos hacer mas enqueue(), cierto?

![Comportamiento de QUEUE](

el primero en llegar el primero en salir, tambien es un algoritmo de planificacion de procesos, hablando de sistemas operativos

Siempre cuidar la información

Todo es mejor con buenos ejemplos.

muy buena explicación, en la siguiente clase creo que será más concreto todos los pasos.

Muy buena explicación antes de pasar a Código.

Veamos todo esto en la práctica

comenzar del 0 al 4 puede resultar extraño pero tendrá una razón de ser

Entiendo que para las colas, usamos las 5 posiciones del Array las cuales inicializan en 0 a 4.

Gracias!!!

Esta pregunta no tiene mucho que ver con la clase pero cuando abro VS code desde ubuntu me lo considera como un remoto. No tengo problema porque de hecho me facilita algunas cosas pero quiero saber por qué es así mientras que en la clase no

para mi es mas confuso cuando en los arrays empiezan con 1

muy buena y sensilla explicacion tengo bastantes problemas al programar porque no agarro una ideologia por donde empezar

Todo bien hasta aquí! 😃

Pienso que es la programación moderna el uso de arrays tiene muchas ventajas y suficiente rendimiento para almacenar grandes cantidades de datos, además… se pueden hacer operaciones con arrayMethods que fácilmente permiten manipular cada uno de los datos. Todo depende de las funcionalidades del lenguaje. Mi opinión es respecto a javascript.

El video anterior era de POO, era publicidad? de momento me emocioné…

La palabra resetear no existe en nuestro idioma

Me pregunto si existe la función equivalente a la situación de la vida real de: “esto está tardando mucho, mejor me voy de la fila”.

Importancia de la estructura de datos y ADT: Su importancia es tener un correcto manejo de la informacion ya sea dentro de las variables funciones objetos, todo lo que maneje informacion, de forma de evitar (buffOverFlow) y otros errores como memory leaks, etc etc etc…

Por que en -1… no inicia la secuencia en 0?

Super… a la practica!! 😃

Para poder tomar este curso tuve que tomar dos antes, ya que algunos conceptos me confundían :S

Porque en los Arrays el primer indice es 0?

Esto es por un tema convención. La logica detrás de esto es la siguiente:
Los demás elementos del array estan a N posiciones del principio/del indice 0.
Cuando tu declaras un arreglo como este

//Ejemplo en Java
int array [ ] = new int [100];

La variable array contiene la dirección en memoria donde comienza el array; es decir la dirección del indice 0.
Cuando hacemos algo como esto:

//ejemplo en Java
array [1] = 20;

Basicamente lo que le estamos diciendo es “A la dirección de memoria que esta 1 posición lejos del inicio asignale 20”.
Por lo tanto esto hace que el proceso para encontrar una posicion en un array sea una funcion constante ( O(1) ).

¡A implementarlo en código! 😃