Queue Using Two Stacks in DSA C++ - Execution Trace

Concept Flow - Queue Using Two Stacks

Enqueue Operation

↓

Push element onto Stack1

↓

Done

↓

Dequeue Operation

↓

Is Stack2 empty?

No→Pop from Stack2

Yes↓

Transfer all elements from Stack1 to Stack2

↓

Pop from Stack2

↓

Done

Enqueue pushes elements onto Stack1. Dequeue pops from Stack2; if Stack2 is empty, transfer all from Stack1 to Stack2 first.

Execution Sample

DSA C++

push(1)
push(2)
pop()
push(3)
pop()
pop()

Perform enqueue of 1 and 2, dequeue one element, enqueue 3, then dequeue two elements.

Execution Table

Step	Operation	Stack1 State	Stack2 State	Action	Queue Visual State
1	push(1)	[1]	[]	Push 1 to Stack1	1
2	push(2)	[1, 2]	[]	Push 2 to Stack1	1 -> 2
3	pop()	[]	[1, 2]	Transfer all elements from Stack1 to Stack2, pop 1 from Stack2	2
4	push(3)	[3]	[2]	Push 3 to Stack1	2 -> 3
5	pop()	[3]	[]	Pop from Stack2	3
6	pop()	[]	[]	Transfer all from Stack1 to Stack2, pop 3 from Stack2	empty
7	pop()	[]	[]	Both stacks empty, queue empty	empty

💡 Step 7 stops because both stacks are empty, queue is empty.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	After Step 5	After Step 6	After Step 7
Stack1	[]	[1]	[1, 2]	[]	[3]	[3]	[]	[]
Stack2	[]	[]	[]	[1, 2]	[2]	[]	[]	[]
Queue Size	0	1	2	1	2	1	0	0

Key Moments - 3 Insights

Why do we transfer all elements from Stack1 to Stack2 during dequeue?

Because Stack2 holds elements in reverse order to simulate queue's FIFO. When Stack2 is empty, transferring reverses Stack1's order so popping from Stack2 gives the oldest element (see Step 3 and Step 6 in execution_table).

What happens if we try to dequeue when both stacks are empty?

The queue is empty, so no element can be dequeued. This is shown in Step 7 where both stacks are empty and the operation stops.

Why do we push new elements only to Stack1?

Pushing to Stack1 keeps new elements in insertion order. Stack2 is only used for dequeue to reverse order. This separation keeps enqueue O(1) and dequeue amortized O(1) (see Steps 1, 2, and 4).

Visual Quiz - 3 Questions

Look at the execution_table at Step 3, what is the state of Stack2 after transferring elements?

A []

B [2]

C [1, 2]

D [1]

💡 Hint

Check the 'Stack2 State' column at Step 3 in execution_table.

At which step does the queue become empty?

A Step 6

B Step 5

C Step 7

D Step 4

💡 Hint

Look at the 'Queue Visual State' column in execution_table for 'empty'.

If we skip transferring elements from Stack1 to Stack2 during dequeue, what happens?

A Dequeue returns the oldest element correctly

B Dequeue returns the newest element incorrectly

C Queue size increases

D Stack1 becomes empty

💡 Hint

Refer to the 'Action' column in execution_table Steps 3 and 6 about transferring elements.

Concept Snapshot

Queue Using Two Stacks:
- Enqueue: push element onto Stack1
- Dequeue: if Stack2 empty, transfer all from Stack1 to Stack2
- Then pop from Stack2
- This simulates FIFO using two LIFO stacks
- Enqueue O(1), Dequeue amortized O(1)

Full Transcript

This visualization shows how a queue can be implemented using two stacks. Enqueue operations push elements onto Stack1. Dequeue operations pop elements from Stack2. If Stack2 is empty during dequeue, all elements from Stack1 are transferred to Stack2 to reverse their order, ensuring the oldest element is dequeued first. The execution table traces each step, showing the states of both stacks and the queue's visual state. Key moments clarify why transferring is necessary and what happens when the queue is empty. The visual quiz tests understanding of stack states and queue emptiness during operations.

Practice

1. What is the main idea behind implementing a Queue Using Two Stacks?

easy

A. Use two stacks to store elements in sorted order

B. Use one stack for enqueue and another for dequeue to reverse order

C. Use two stacks to store elements in parallel for faster access

D. Use one stack to store elements and another to count them

Solution

1. Step 1: Understand queue behavior

   A queue follows FIFO (First In First Out), so the first element added should be the first removed.

2. Step 2: Use two stacks to reverse order

   One stack stores elements as they come (enqueue). The second stack reverses the order to allow dequeue in FIFO order.

3. Final Answer:

   Use one stack for enqueue and another for dequeue to reverse order -> Option B

4. Quick Check:

   Two stacks reverse order to simulate queue FIFO [OK]

Hint: Remember: two stacks reverse order to mimic queue [OK]

Common Mistakes:

• Thinking both stacks store elements in the same order
• Assuming stacks keep elements sorted
• Using one stack only for all operations

2. Which of the following is the correct syntax to push an element x into a stack named stack1 in C++?

easy

A. stack1.push(x);

B. stack1.add(x);

C. stack1.insert(x);

D. stack1.enqueue(x);

Solution

1. Step 1: Recall C++ stack push syntax

   The standard C++ stack uses the method push() to add elements.

2. Step 2: Match correct method name

   Only push is the correct method; others like add, insert, or enqueue are invalid for stack.

3. Final Answer:

   stack1.push(x); -> Option A

4. Quick Check:

   Stack push method = push() [OK]

Hint: Stack insertion uses push() method in C++ [OK]

Common Mistakes:

• Using enqueue() which is for queues
• Using add() or insert() which are not stack methods
• Confusing stack with vector methods

3. Consider the following C++ code implementing a queue using two stacks:

std::stack<int> s1, s2;

// Enqueue 1, 2, 3
s1.push(1);
s1.push(2);
s1.push(3);

// Dequeue operation
while (!s1.empty()) {
  s2.push(s1.top());
  s1.pop();
}
int front = s2.top();
s2.pop();

// What is the value of front?

medium

A. 2

B. 3

C. 1

D. Stack empty error

Solution

1. Step 1: Trace enqueue operations

   Elements pushed into s1 in order: 1 (bottom), 2, 3 (top).

2. Step 2: Transfer elements to s2 to reverse order

   Moving all from s1 to s2 reverses order: s2 top is 1, bottom is 3.

3. Step 3: Identify front element

   Front of queue is s2.top() which is 1, then popped.

4. Final Answer:

   1 -> Option C

5. Quick Check:

   Queue front after transfer = 1 [OK]

Hint: Transfer stacks reverses order; front is bottom of first stack [OK]

Common Mistakes:

• Assuming top of s1 is front (3 instead of 1)
• Not reversing stack order before dequeue
• Confusing stack top with queue front

4. The following code snippet is intended to implement dequeue operation in a queue using two stacks. Identify the error:

void dequeue() {
  if (s2.empty()) {
    while (!s1.empty()) {
      s2.push(s1.top());
      s1.pop();
    }
  }
  s1.pop();
}

medium

A. Should pop twice from s1

B. Should push elements from s2 to s1 instead

C. Missing check if both stacks are empty

D. Should pop from s2, not s1, after transfer

Solution

1. Step 1: Understand dequeue logic

   Dequeue removes front element, which is on top of s2 after transfer.

2. Step 2: Identify incorrect pop

   Code pops from s1 after transfer, but front is on s2, so s2.pop() is correct.

3. Final Answer:

   Should pop from s2, not s1, after transfer -> Option D

4. Quick Check:

   Dequeue pops from s2 top [OK]

Hint: Pop from s2 after transfer, not s1 [OK]

Common Mistakes:

• Popping from wrong stack after transfer
• Not checking if both stacks are empty before dequeue
• Confusing enqueue and dequeue stacks

5. You want to implement a queue using two stacks with the following operations:

enqueue(x): Push element x to the queue.
dequeue(): Remove and return the front element.

Which approach ensures amortized O(1) time per operation?

hard

A. Push all elements to s1 on enqueue; transfer to s2 only when s2 is empty during dequeue

B. Push elements alternately to s1 and s2; pop from both stacks on dequeue

C. Transfer all elements from s1 to s2 on every enqueue operation

D. Use s1 for enqueue and s2 for dequeue but transfer elements on every dequeue regardless

Solution

1. Step 1: Understand amortized O(1) goal

   We want to minimize costly transfers by doing them only when necessary.

2. Step 2: Analyze each approach

   Push all elements to s1 on enqueue; transfer to s2 only when s2 is empty during dequeue transfers elements from s1 to s2 only when s2 is empty during dequeue, spreading cost over many operations.

3. Step 3: Reject other options

   Options B, C, and D cause frequent or unnecessary transfers increasing time per operation.

4. Final Answer:

   Push all elements to s1 on enqueue; transfer to s2 only when s2 is empty during dequeue -> Option A

5. Quick Check:

   Transfer only when s2 empty = amortized O(1) [OK]

Hint: Transfer stacks only when dequeue stack is empty [OK]

Common Mistakes:

• Transferring elements on every enqueue or dequeue
• Pushing alternately causing imbalance
• Ignoring amortized cost analysis