Implement Stack Using Queue in DSA C - Execution Trace

Concept Flow - Implement Stack Using Queue

Initialize empty queue

↓

Push operation: enqueue new element

↓

Rotate queue to move new element to front

↓

Pop operation: dequeue front element

↓

Top operation: peek front element

↓

Check if queue is empty for isEmpty

Use one queue to simulate stack by pushing elements and rotating queue so last pushed is always at front.

Execution Sample

DSA C

void push(int x) {
  enqueue(x);
  for (int i = 0; i < size - 1; i++) {
    enqueue(dequeue());
  }
}

int pop() {
  return dequeue();
}

Push adds element then rotates queue to front; pop removes front element simulating stack pop.

Execution Table

Step	Operation	Queue State Before	Pointer Changes	Queue State After	Visual State
1	Initialize queue	[]	head=0, tail=0	[]	[]
2	push(10)	[]	enqueue 10	[10]	[10]
3	rotate after push	[10]	no rotation needed	[10]	[10]
4	push(20)	[10]	enqueue 20	[10, 20]	[10 -> 20]
5	rotate after push	[10, 20]	dequeue 10, enqueue 10	[20, 10]	[20 -> 10]
6	push(30)	[20, 10]	enqueue 30	[20, 10, 30]	[20 -> 10 -> 30]
7	rotate after push	[20, 10, 30]	dequeue 20, enqueue 20; dequeue 10, enqueue 10	[30, 20, 10]	[30 -> 20 -> 10]
8	pop()	[30, 20, 10]	dequeue 30	[20, 10]	[20 -> 10]
9	top()	[20, 10]	peek front	[20, 10]	top = 20
10	pop()	[20, 10]	dequeue 20	[10]	[10]
11	pop()	[10]	dequeue 10	[]	[]
12	pop() on empty	[]	no dequeue	[]	stack empty

💡 All operations complete; stack simulated by queue rotations.

Variable Tracker

Variable	Start	After push(10)	After push(20)	After push(30)	After pop()	After pop()	After pop()
queue	[]	[10]	[20, 10]	[30, 20, 10]	[20, 10]	[10]	[]
size	0	1	2	3	2	1	0

Key Moments - 3 Insights

Why do we rotate the queue after each push?

Rotating moves the newly added element to the front, so pop() can dequeue it first, simulating stack's LIFO order (see steps 4-7 in execution_table).

What happens if we pop when the queue is empty?

No dequeue happens; the stack is empty and pop returns nothing or error (see step 12 in execution_table).

Why does pop() just dequeue the front element?

Because after rotation, the last pushed element is always at the front, so dequeue simulates stack pop (see step 8 in execution_table).

Visual Quiz - 3 Questions

Look at the execution_table, what is the queue state after push(20) and rotation?

A [20]

B [10, 20]

C [20, 10]

D [10]

💡 Hint

Check step 5 in execution_table for queue state after push(20) rotation.

At which step does the queue first contain three elements?

A Step 4

B Step 6

C Step 5

D Step 7

💡 Hint

Look at queue state before and after push(30) in execution_table steps 6 and 7.

If we skip the rotation after push, what would pop() remove first?

A The first pushed element

B The last pushed element

C An error occurs

D The middle element

💡 Hint

Without rotation, queue order is FIFO, so pop removes oldest element (see concept_flow).

Concept Snapshot

Use one queue to build stack:
- push: enqueue then rotate queue to front
- pop: dequeue front element
- top: peek front
- isEmpty: check queue empty
Rotation ensures last pushed is always front for LIFO behavior.

Full Transcript

This concept shows how to use a single queue to behave like a stack. When pushing, we add the element to the queue and then rotate the queue so that the new element moves to the front. This way, when we pop, we just dequeue the front element, which is the last pushed, simulating stack's last-in-first-out order. The execution table traces each step, showing queue states and pointer changes. Key moments clarify why rotation is needed and what happens on empty pop. The visual quiz tests understanding of queue states and operation effects. The snapshot summarizes the approach for quick recall.