# Implementing Queues Using Stacks in Python: A Comprehensive Guide

Rate this post

π‘ Problem Formulation: Queues and stacks are fundamental data structures in computer science. A queue typically follows the First In First Out (FIFO) protocol, meaning the first element added is the first one to be removed. In contrast, a stack follows the Last In First Out (LIFO) protocol. The challenge is to simulate the behavior of a queue using only stack operations (push and pop). We want to input elements in the order [1, 2, 3, 4] and ensure that the queue will output them in the same order when dequeued.

## Method 1: Two Stacks enQueue Costly

This method uses two stacks, hereafter called `s1` and `s2`. For the enQueue operation, the existing elements are popped from `s1` and pushed onto `s2`, and the new element is pushed onto `s1`. Then, all elements from `s2` are moved back to `s1`. DeQueue simply pops an element from `s1`. This approach moves all elements twice for each enQueue operation, making it costly.

Here’s an example:

```class QueueUsingStacks:
def __init__(self):
self.s1 = []
self.s2 = []

def enQueue(self, element):
while self.s1:
self.s2.append(self.s1.pop())
self.s1.append(element)
while self.s2:
self.s1.append(self.s2.pop())

def deQueue(self):
if not self.s1:
return None
return self.s1.pop()

# Example usage
queue = QueueUsingStacks()
queue.enQueue(1)
queue.enQueue(2)
queue.enQueue(3)
print(queue.deQueue())
queue.enQueue(4)
print(queue.deQueue())
```

Output:

```1
2
```

After enqueuing elements 1, 2, and 3 to the queue and dequeuing once, the output is ‘1’, which is the first element enqueued. Then we enqueued ‘4’ and dequeued again, outputting ‘2’. This demonstrates the FIFO nature of the queue we created using two stacks.

## Method 2: Two Stacks deQueue Costly

Contrary to Method 1, Method 2 makes deQueue operation costly. Elements are pushed onto `s1` for enQueue. For deQueue, if `s2` is empty, all elements are transferred from `s1` to `s2` and the top element of `s2` is popped; if `s2` is not empty, the top element is simply popped. This method incurs the cost of moving elements only when `s2` is empty.

Here’s an example:

```class QueueUsingStacks:
def __init__(self):
self.s1 = []
self.s2 = []

def enQueue(self, element):
self.s1.append(element)

def deQueue(self):
if not self.s2:
while self.s1:
self.s2.append(self.s1.pop())
return self.s2.pop() if self.s2 else None

# Example usage
queue = QueueUsingStacks()
queue.enQueue(1)
queue.enQueue(2)
queue.enQueue(3)
print(queue.deQueue())
queue.enQueue(4)
print(queue.deQueue())
```

Output:

```1
2
```

This snippet demonstrates how to reduce the number of times elements are moved between stacks. The deQueue operation is only costly when `s2` is empty, offering a more efficient approach when there are multiple consecutive deQueue operations with no intervening enQueues.

## Method 3: Recursion

Using recursion, we can simulate a queue with a single stack for storage. The recursion stack implicitly becomes the second stack. During `deQueue`, if the storage stack has more than one element, we use recursion to store the popped item temporarily and push it back after we reach the base case. The last element popped (during the base case) is not pushed back, effectively dequeuing it.

Here’s an example:

```class QueueUsingStacks:
def __init__(self):
self.s1 = []

def enQueue(self, element):
self.s1.append(element)

def deQueue(self):
if len(self.s1) == 1:
return self.s1.pop()
elem = self.s1.pop()
dequeued = self.deQueue()
self.s1.append(elem)
return dequeued

# Example usage
queue = QueueUsingStacks()
queue.enQueue(1)
queue.enQueue(2)
queue.enQueue(3)
print(queue.deQueue())
queue.enQueue(4)
print(queue.deQueue())
```

Output:

```1
2
```

This code uses the call stack as an implicit second stack to reverse the order of elements for dequeuing, demonstrating a clever use of recursion. However, it’s not the most efficient approach for large queues due to recursion depth limits and overhead.

## Method 4: Amortized Two Stacks Approach

This optimization combines Methods 1 and 2 to offer an amortized time complexity. We enQueue by pushing onto `s1`, and we only move elements to `s2` when `s2` is empty during deQueue, leaving remaining elements in `s2` for future deQueues. The expensive transfer operation is spread over multiple deQueues, amortizing the cost.

Here’s an example:

```class QueueUsingStacks:
def __init__(self):
self.s1 = []
self.s2 = []

def enQueue(self, element):
self.s1.append(element)

def deQueue(self):
if not self.s2:
while self.s1:
self.s2.append(self.s1.pop())
return self.s2.pop() if self.s2 else None

# Example usage
queue = QueueUsingStacks()
queue.enQueue(1)
queue.enQueue(2)
queue.enQueue(3)
print(queue.deQueue())
print(queue.deQueue())
queue.enQueue(4)
print(queue.deQueue())
```

Output:

```1
2
3
```

This example illustrates the efficient handling of multiple deQueue operations. By amortizing the transfer cost, the method becomes efficient for sequences with many deQueue operations following enQueue operations.

## Bonus One-Liner Method 5: Using List Slicing

This one-liner Pythonic approach uses list slicing to achieve queue functionality. It is not a typical stack-based implementation but achieves the same result with minimal code, using the underlying list mechanisms in Python. It is, however, less efficient for large queues.

Here’s an example:

```queue = []
enqueue = queue.append
dequeue = lambda: queue.pop(0)

# Example usage
enqueue(1)
enqueue(2)
enqueue(3)
print(dequeue())
enqueue(4)
print(dequeue())
```

Output:

```1
2
```

This succinct example uses the list append and pop operations to simulate a queue in a Pythonic way. However, the pop operation has a linear time complexity because it requires shifting all subsequent elements, making this method inefficient for large data sets.

## Summary/Discussion

• Method 1: Two Stacks enQueue Costly. Provides a straightforward way to implement a queue using two stacks but is inefficient due to the high cost of enQueue operations.
• Method 2: Two Stacks deQueue Costly. Offers better performance when there are multiple dequeues, as the expensive transfer of elements only happens when `s2` is empty.
• Method 3: Recursion. A novel approach that does not require a second data structure but has limitations due to recursion stack depth and performance for large queues.
• Method 4: Amortized Two Stacks Approach. Balances the cost of operations across multiple enQueues and deQueues, offering improved average-case performance.
• Method 5: Using List Slicing. A Pythonic one-liner that is suitable for small data sets but not recommended for performance-critical or large-scale applications due to linear time complexities for dequeueing.