Queue Using Two Stacks in DSA C++ - Build from Scratch

Queue Using Two Stacks

📖 Scenario: Imagine you are managing a line of customers waiting for service. You want to keep track of who comes first and who comes next. But instead of using a simple line, you only have two stacks (like two piles of plates). Your task is to use these two stacks to create a queue that works just like a real line.

🎯 Goal: Build a queue using two stacks in C++. You will add people to the line and serve them in the order they arrived, using only stack operations.

📋 What You'll Learn

Create two stacks named stack_in and stack_out

Add a function enqueue to add elements to stack_in

Add a function dequeue to remove elements from stack_out, transferring elements from stack_in if needed

Print the queue elements in order after all operations

💡 Why This Matters

🌍 Real World

Queues are used in many places like customer service lines, task scheduling, and buffering data streams. Using two stacks to build a queue shows how different data structures can work together.

💼 Career

Understanding how to implement queues with stacks helps in coding interviews and improves problem-solving skills for software development roles.

1

Create Two Empty Stacks

Create two empty stacks of integers named stack_in and stack_out using std::stack<int>.

DSA C++

#include 
#include 

int main() {
    // Create two empty stacks named stack_in and stack_out
    // Your code here

    return 0;
}

Hint

Use std::stack<int> to declare the two stacks named stack_in and stack_out.

2

Add Enqueue Function

Add a function named enqueue that takes an integer value and pushes it onto stack_in. Call this function three times in main to add the values 10, 20, and 30.

DSA C++

#include 
#include 

// Add enqueue function here

int main() {
    std::stack stack_in;
    std::stack stack_out;

    // Call enqueue to add 10, 20, 30
    // Your code here

    return 0;
}

Hint

Define enqueue to push value onto stack_in. Then call it three times with 10, 20, and 30.

3

Add Dequeue Function

Add a function named dequeue that removes and returns the front element of the queue. If stack_out is empty, move all elements from stack_in to stack_out first. Call dequeue twice in main and store the returned values in variables first and second.

DSA C++

#include 
#include 

void enqueue(std::stack& stack_in, int value) {
    stack_in.push(value);
}

// Add dequeue function here

int main() {
    std::stack stack_in;
    std::stack stack_out;

    enqueue(stack_in, 10);
    enqueue(stack_in, 20);
    enqueue(stack_in, 30);

    // Call dequeue twice and store in first and second
    // Your code here

    return 0;
}

Hint

In dequeue, if stack_out is empty, move all elements from stack_in to stack_out. Then pop and return the top of stack_out.

4

Print Remaining Queue Elements

Print the remaining elements in the queue in order by moving any remaining elements from stack_in to stack_out if needed, then popping all elements from stack_out. Print the elements separated by spaces on one line.

DSA C++

#include 
#include 

void enqueue(std::stack& stack_in, int value) {
    stack_in.push(value);
}

int dequeue(std::stack& stack_in, std::stack& stack_out) {
    if (stack_out.empty()) {
        while (!stack_in.empty()) {
            stack_out.push(stack_in.top());
            stack_in.pop();
        }
    }
    int front = stack_out.top();
    stack_out.pop();
    return front;
}

int main() {
    std::stack stack_in;
    std::stack stack_out;

    enqueue(stack_in, 10);
    enqueue(stack_in, 20);
    enqueue(stack_in, 30);

    int first = dequeue(stack_in, stack_out);
    int second = dequeue(stack_in, stack_out);

    // Print remaining queue elements
    // Your code here

    return 0;
}

Hint

Move remaining elements from stack_in to stack_out if stack_out is empty. Then print all elements from stack_out separated by spaces.

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