When should you use a stack versus a queue? Give real examples.

Question

IT Interview Practice · Accepted Answer

Both are linear ADTs with O(1) ends, but the **order of removal** is opposite: a **stack is LIFO** (most recent first), a **queue is FIFO** (oldest first). Match the structure to the order your problem requires.

## The core difference

```text
Stack (LIFO):  push 1,2,3  -> pop order 3,2,1
Queue (FIFO):  enq  1,2,3  -> deq order 1,2,3
```

## Real examples

| Use a STACK when... | Use a QUEUE when... |
|---|---|
| Undo/redo (latest action first) | Job scheduling (arrival order) |
| Browser back button | Print spooler / task queue |
| Function call/recursion | BFS / shortest path on a graph |
| Matching brackets, parsing | Message buffering between services |
| DFS (explore deepest first) | Rate limiting / request handling |

## Code contrast

```python
# DFS uses a stack: explore newest branch first
stack = [start]
while stack:
    node = stack.pop()        # LIFO -> goes deep
    for nb in graph[node]: stack.append(nb)

# BFS uses a queue: explore nearest first
from collections import deque
q = deque([start])
while q:
    node = q.popleft()        # FIFO -> goes level by level
    for nb in graph[node]: q.append(nb)
```

## Why it matters

The LIFO-vs-FIFO choice directly changes algorithm behavior: the *same* graph traversal becomes DFS with a stack or BFS with a queue.

Recognizing whether your problem needs "most recent" or "oldest first" instantly points you to the right structure.

Undo/redo (latest action first)	Job scheduling (arrival order)
Browser back button	Print spooler / task queue
Function call/recursion	BFS / shortest path on a graph
Matching brackets, parsing	Message buffering between services
DFS (explore deepest first)	Rate limiting / request handling

The core difference

Real examples

Code contrast

Why it matters

Related questions