Queue basada en dos stacks

una anotacion en este tipo de queues basados en stacks, es que la operacion de pop es supremamente lenta cuando aumenta el numero de elementos drasticamenta

Les dejo un articulo que escribi sobre esto:
https://ricardoromo.co/2020/aprende-7-trucos-que-quizas-no-conocias-de-python/

Me hubiera hustado que estas clases, de stack y queues se hubieran hecho antes que las de nodos y linked list que por mi parte considero más complicados.

Les compartó el código vistos en la clase.

class Queue:
    def __init__(self) -> None:
        self.inboud_stack = []
        self.outbound_stack = []

    def enqueue(self, data):
        self.inboud_stack.append(data)

    def dequeue(self):
        if not self.outbound_stack:
            while self.inboud_stack:
                self.outbound_stack.append(self.inboud_stack.pop())

        return self.outbound_stack.pop()

from stack_based_queue import Queue

numbers = Queue()

numbers.enqueue(5)
numbers.enqueue(6)
numbers.enqueue(7)

print(numbers.inboud_stack)
print(numbers.dequeue())

print(numbers.inboud_stack)
print(numbers.outbound_stack)

print(numbers.dequeue())
print(numbers.outbound_stack)

print(numbers.dequeue())
print(numbers.outbound_stack)
print(numbers.inboud_stack)

[5, 6, 7]
5
[]
[7, 6]
6
[7]
7
[]
[]

Este tipo de código no es muy óptimo a largo plazo, por el hecho de que en caso de que nuestra data aumente, simplemente el tiempo que nos topa recorrerlo también lo hará.

Este código tiene una notación de O(n elevado a 2).

Hay un error en el código implementado en esta clase ya que este no permite hacer un enqueue correcto después del dequeue, así es como corregí el problema

    def dequeue(self):
        while self.inbound_stack:
            self.outbound_stack.append(self.inbound_stack.pop())
        return self.outbound_stack.pop(0) if self.outbound_stack else None

En el método dequeue(), antes de hacer el pop de self.outbound_stack habría que comprobar si existe algo dentro de ese campo, para que no lance una excepción.

Muy intuitiva la clase profesor.

COLAS CON DOS STACK’s
(Correccion de outbound_stack Vacio)

class Queue:
def init(self):
self.inbound_stack = []
self.outbound_stack = []

# Encola
def enqueue(self, data):
    self.inbound_stack.append(data)

# Desencola
def dequeue(self):
    if not self.outbound_stack:
        while self.inbound_stack:
            self.outbound_stack.append(self.inbound_stack.pop())
    return self.outbound_stack.pop()

def dequeue(self):
    while self.inbound_stack:
        self.outbound_stack.append(self.inbound_stack.pop())
    if self.outbound_stack:
        return self.outbound_stack.pop()

'''stack_base_queue.py'''

class Queue:
    def __init__(self):
        self.inboud_stack = []
        self.outbound_stack = []
        
    def enqueue(self, data):
        self.inboud_stack.append(data)
        
    def dequeue(self):
        if not self.outbound_stack: # si no esta vacio
            print(f'Iniciamos while, nuestra lista inboud {self.inboud_stack}')
            while self.inboud_stack:
                self.outbound_stack.append(self.inboud_stack.pop())
                print(f'Lista inboud {self.inboud_stack}')
                print(f'Lista outbound {self.outbound_stack}')
                
        return self.outbound_stack.pop()
    
    
if __name__ == '__main__':
    numbers = Queue()
    numbers.enqueue(5)
    numbers.enqueue(6)
    numbers.enqueue(7)
    print(numbers.inboud_stack)
    print(numbers.dequeue())
    print(numbers.inboud_stack)
    print(numbers.outbound_stack)

Implementación de una cola basada en dos stacks en Python:

class Queue:
    def __init__(self):
        self.inbound_stack = []
        self.outbound_stack = []

    def is_empty(self):
        return len(self.inbound_stack) == 0 and len(self.outbound_stack) == 0

    def enqueue(self, item):
        self.inbound_stack.append(item)

    def dequeue(self):
        if self.is_empty():
            raise IndexError("Queue is empty")

        if len(self.outbound_stack) == 0:
            while len(self.inbound_stack) > 0:
                self.outbound_stack.append(self.inbound_stack.pop())

        return self.outbound_stack.pop()

    def front(self):
        if self.is_empty():
            raise IndexError("Queue is empty")

        if len(self.outbound_stack) == 0:
            while len(self.inbound_stack) > 0:
                self.outbound_stack.append(self.inbound_stack.pop())

        return self.outbound_stack[-1]

    def size(self):
        return len(self.inbound_stack) + len(self.outbound_stack)


'''
En esta implementación, utilizamos dos stacks: inbound_stackpara agregar (agregar elementos) y `outbound_stackoutbound_stackpara desencolar (eliminar elementos).

El método is_empty()verifica si ambas pilas están vacías.
El metodo enqueue(item)agregainbound_stack.
El metodo dequeue()extrae youtbound_stack. Si la pila 
outbound_stackestá vacía, transferimos los elementos 
delinbound_stackal outbound_stacken orden inverso antes de realizar la operación de desencolar.
El metodo `front()devuelve el elemento del frente del stack outbound_stacksin eliminarlo. 
Si el stack outbound_stackestá vacío, transferimos los elementos del 
`ininbound_stack al outbound_stacken orden inverso antes de obtener el elemento del frente.
El método size()devuelve el tamaño total de la cola.
Puedes utilizar la'''

# Crear una instancia de la cola
my_queue = Queue()

# Verificar si la cola está vacía
print(my_queue.is_empty())  # Resultado: True

# Agregar elementos a la cola
my_queue.enqueue(1)
my_queue.enqueue(2)
my_queue.enqueue(3)

# Obtener el elemento del frente de la cola
print(my_queue.front())  # Resultado: 1

# Eliminar y obtener el elemento del frente de la cola
print(my_queue.dequeue())  # Resultado: 1

# Obtener el tamaño actual de la cola
print(my_queue.size())  # Resultado: 2

# Verificar si la cola está vacía nuevamente
print(my_queue.is_empty())  # Resultado: False

No le veo utilidad al codigo pues a la final no esta diciendo lo que dice que en algunas entrevistas pueden pedir algo asi, y es pasar de LIFO a FIFO

Misma estructura, distinto funcionamiento

Me habría gustado que en este curso se nombrara la complejidad de cada operación en las estructuras de datos estudiadas, y también la complejidad de las implementaciones utilizadas. Me parece importante apredener con base en lo aplicable y realmente escalable en la vida real. Gracias por el curso.

es extraño que print(not []) sea igual a False
o not None sea igual a True en python