Queue Using Two Stacks in DSA C++ - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the main idea behind implementing a queue using two stacks?

Use one stack to handle incoming elements (push), and the other stack to handle outgoing elements (pop). When the outgoing stack is empty, transfer all elements from the incoming stack to it, reversing their order to maintain queue behavior.

beginner

Why do we transfer elements from the first stack to the second stack in a queue implemented with two stacks?

Transferring elements reverses their order, so the oldest element (which was pushed first) ends up on top of the second stack, allowing us to pop elements in FIFO order like a queue.

intermediate

What is the time complexity of enqueue and dequeue operations in a queue implemented using two stacks?

Enqueue (push) is O(1) because we just push onto the first stack. Dequeue (pop) is amortized O(1) because transferring elements happens only when the second stack is empty, spreading the cost over many operations.

beginner

Show the state of two stacks after enqueueing 1, 2, 3 and then dequeueing one element in a queue using two stacks.

After enqueue 1,2,3: stack1 = [1,2,3] (top is 3), stack2 = []. After dequeue: transfer all from stack1 to stack2, stack1 = [], stack2 = [3,2,1] (top is 1). Then pop from stack2: stack2 = [3,2].

beginner

What happens if you try to dequeue from an empty queue implemented with two stacks?

Both stacks are empty, so there are no elements to dequeue. This should be handled by returning an error or indication that the queue is empty.

In a queue implemented with two stacks, where do new elements get pushed?

A Onto the first stack

B Onto the second stack

C Onto both stacks

D They are not pushed onto any stack

New elements are always pushed onto the first stack to keep track of incoming elements.

When do we transfer elements from the first stack to the second stack?

A When the first stack is empty

B Never

C After every enqueue operation

D When the second stack is empty and we need to dequeue

We transfer elements only when the second stack is empty and we want to dequeue, to reverse the order.

What is the order of elements in the second stack after transferring from the first stack?

A Same order as first stack

B Reversed order of first stack

C Random order

D Sorted order

Transferring elements reverses their order, so the oldest element is on top.

What is the amortized time complexity of dequeue operation in a queue using two stacks?

A O(1)

B O(log n)

C O(n)

D O(n^2)

Dequeue is amortized O(1) because transfers happen only when needed, spreading the cost.

If both stacks are empty, what does that mean for the queue?

A Queue is full

B Queue has one element

C Queue is empty

D Queue is corrupted

Both stacks empty means no elements in the queue.

Explain how a queue can be implemented using two stacks and why this works.

Think about how stacks reverse order and how that helps simulate a queue.

Describe the steps and stack states when enqueueing 3 elements and then dequeueing 2 elements in a queue using two stacks.

Visualize the stacks after each operation to understand the process.

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