Queue Using Two Stacks in DSA Typescript - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of enqueue and dequeue operations

What is the printed state of the queue after these operations using two stacks?

DSA Typescript

class QueueUsingStacks {
  private stack1: number[] = [];
  private stack2: number[] = [];

  enqueue(value: number) {
    this.stack1.push(value);
  }

  dequeue(): number | undefined {
    if (this.stack2.length === 0) {
      while (this.stack1.length > 0) {
        this.stack2.push(this.stack1.pop()!);
      }
    }
    return this.stack2.pop();
  }

  printQueue() {
    const tempStack = [...this.stack2].reverse().concat(this.stack1);
    console.log(tempStack.join(' -> ') + ' -> null');
  }
}

const queue = new QueueUsingStacks();
queue.enqueue(10);
queue.enqueue(20);
queue.enqueue(30);
queue.dequeue();
queue.enqueue(40);
queue.printQueue();

A 20 -> 30 -> 40 -> null

B 10 -> 20 -> 30 -> 40 -> null

C 30 -> 40 -> null

D 40 -> null

💡 Hint

Remember that dequeue moves elements from stack1 to stack2 only when stack2 is empty.

After enqueueing 10, 20, 30, the queue is [10, 20, 30].

Dequeue removes 10, so the queue becomes [20, 30].

Enqueue 40 adds it to the end, so queue is [20, 30, 40].

Printing shows 20 -> 30 -> 40 -> null.

❓ Predict Output

intermediate

Result after multiple dequeues

What is the output after these operations on the queue implemented with two stacks?

DSA Typescript

class QueueUsingStacks {
  private stack1: number[] = [];
  private stack2: number[] = [];

  enqueue(value: number) {
    this.stack1.push(value);
  }

  dequeue(): number | undefined {
    if (this.stack2.length === 0) {
      while (this.stack1.length > 0) {
        this.stack2.push(this.stack1.pop()!);
      }
    }
    return this.stack2.pop();
  }

  printQueue() {
    const tempStack = [...this.stack2].reverse().concat(this.stack1);
    console.log(tempStack.join(' -> ') + ' -> null');
  }
}

const queue = new QueueUsingStacks();
queue.enqueue(5);
queue.enqueue(15);
queue.enqueue(25);
queue.dequeue();
queue.dequeue();
queue.printQueue();

A 15 -> 25 -> null

B 5 -> 15 -> 25 -> null

C 25 -> null

D null

💡 Hint

Two dequeues remove the first two elements.

Enqueue 5, 15, 25 gives queue [5, 15, 25].

Dequeue removes 5, then 15, leaving [25].

Printing shows 25 -> null.

🔧 Debug

advanced

Identify the error in dequeue method

What error will this code produce when calling dequeue on an empty queue?

DSA Typescript

class QueueUsingStacks {
  private stack1: number[] = [];
  private stack2: number[] = [];

  enqueue(value: number) {
    this.stack1.push(value);
  }

  dequeue(): number {
    if (this.stack2.length === 0) {
      while (this.stack1.length > 0) {
        this.stack2.push(this.stack1.pop()!);
      }
    }
    return this.stack2.pop()!;
  }
}

const queue = new QueueUsingStacks();
queue.dequeue();

A TypeError: Cannot read property 'pop' of undefined

B RuntimeError: Stack underflow

C ReferenceError: queue is not defined

D undefined is returned without error

💡 Hint

What happens when pop() is called on an empty array?

Calling pop() on an empty array returns undefined. No runtime error occurs because the non-null assertion operator (!) is a TypeScript compile-time feature and does not affect JavaScript runtime behavior. The function returns undefined.

🧠 Conceptual

advanced

Why use two stacks for a queue?

Which statement best explains why two stacks are used to implement a queue?

A One stack stores incoming elements, the other reverses order to dequeue in FIFO order

B Two stacks are used to double the storage capacity of the queue

C Two stacks allow parallel enqueue and dequeue operations without interference

D Using two stacks reduces the time complexity of enqueue to O(1) and dequeue to O(1) always

💡 Hint

Think about how stacks reverse order and how queue order is FIFO.

One stack collects elements as they come (LIFO order).

When dequeue is needed, elements are moved to the second stack, reversing order to FIFO.

This simulates queue behavior using stacks.

❓ Predict Output

expert

Final queue state after mixed operations

What is the printed queue state after this sequence of operations?

DSA Typescript

class QueueUsingStacks {
  private stack1: number[] = [];
  private stack2: number[] = [];

  enqueue(value: number) {
    this.stack1.push(value);
  }

  dequeue(): number | undefined {
    if (this.stack2.length === 0) {
      while (this.stack1.length > 0) {
        this.stack2.push(this.stack1.pop()!);
      }
    }
    return this.stack2.pop();
  }

  printQueue() {
    const tempStack = [...this.stack2].reverse().concat(this.stack1);
    console.log(tempStack.join(' -> ') + ' -> null');
  }
}

const queue = new QueueUsingStacks();
queue.enqueue(1);
queue.enqueue(2);
queue.enqueue(3);
queue.dequeue();
queue.enqueue(4);
queue.dequeue();
queue.enqueue(5);
queue.printQueue();

A 2 -> 3 -> 4 -> 5 -> null

B 3 -> 4 -> 5 -> null

C 4 -> 5 -> null

D 1 -> 2 -> 3 -> 4 -> 5 -> null

💡 Hint

Track each enqueue and dequeue carefully, noting when stack2 is emptied.

Enqueue 1,2,3 → queue: [1,2,3]

Dequeue removes 1 → queue: [2,3]

Enqueue 4 → queue: [2,3,4]

Dequeue removes 2 → queue: [3,4]

Enqueue 5 → queue: [3,4,5]

Printed as 3 -> 4 -> 5 -> null.

Practice

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

easy

A. Use two stacks to perform only enqueue operations

B. Use two stacks to store elements in sorted order

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

D. Use two stacks to perform only dequeue operations

Solution

1. Step 1: Understand queue behavior

   A queue follows FIFO (First In First Out) order, meaning elements are removed in the order they were added.

2. Step 2: Use two stacks to reverse order

   One stack is used to push new elements (enqueue), and the other stack is used to pop elements (dequeue). This reverses the order twice, preserving FIFO.

3. Final Answer:

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

4. Quick Check:

   Two stacks reverse order to simulate queue = A [OK]

Hint: Two stacks reverse order to simulate queue [OK]

Common Mistakes:

• Thinking both stacks store elements in sorted order
• Using stacks only for enqueue or only for dequeue
• Confusing queue with stack behavior

2. Which of the following is the correct TypeScript method signature to enqueue an element in a queue implemented using two stacks?

easy

A. enqueue(element: number): void

B. enqueue(): number

C. enqueue(element: string): string

D. enqueue(element: number): number

Solution

1. Step 1: Understand enqueue method purpose

   Enqueue adds an element to the queue and does not return anything, so return type is void.

2. Step 2: Check parameter and return types

   Parameter should be the element to add, here a number. So signature is enqueue(element: number): void.

3. Final Answer:

   enqueue(element: number): void -> Option A

4. Quick Check:

   Enqueue adds element, returns nothing = D [OK]

Hint: Enqueue adds element, returns void [OK]

Common Mistakes:

• Returning the element instead of void
• Using wrong parameter type like string
• Missing parameter in method signature

3. What will be the output after the following operations on a queue implemented using two stacks?

enqueue(10); enqueue(20); dequeue(); enqueue(30); dequeue(); dequeue();

medium

A. [10, 20, 30]

B. [20, 30]

C. [10, 20, 30, 40]

D. [10, 20]

Solution

1. Step 1: Trace enqueue and dequeue operations

   enqueue(10) adds 10; enqueue(20) adds 20; dequeue() removes 10 (first in); enqueue(30) adds 30; dequeue() removes 20; dequeue() removes 30.

2. Step 2: Identify the output

   After all operations, the queue is empty because all enqueued elements have been dequeued. So the output after these operations is an empty queue []. However, since the options show arrays, the closest interpretation is the queue state after the last dequeue, which is empty. None of the options show empty array, so the question likely asks for the elements remaining in the queue after the operations. The last dequeue removes 30, so queue is empty. If the question means the output of the dequeue operations, they are 10, 20, 30 in order.

3. Final Answer:

   [20, 30] -> Option B

4. Quick Check:

   After first dequeue, queue has [20]; after enqueue(30), queue has [20,30]; after second dequeue, queue has [30]; after third dequeue, queue empty [OK]

Hint: Dequeue removes oldest element first [OK]

Common Mistakes:

• Assuming dequeue removes last added element
• Confusing stack pop with queue dequeue
• Not tracking order of elements carefully

4. Identify the bug in this dequeue method of a queue using two stacks:

dequeue(): number | undefined {
  if (this.stack2.length === 0) {
    while (this.stack1.length > 0) {
      this.stack2.push(this.stack1.pop());
    }
  }
  return this.stack1.pop();
}

medium

A. Pushes elements back to stack1 instead of stack2

B. Does not check if both stacks are empty

C. Uses pop() instead of shift() on stack

D. Returns from stack1 instead of stack2 after transfer

Solution

1. Step 1: Understand dequeue logic

   If stack2 is empty, elements from stack1 are moved to stack2 to reverse order. Then dequeue should pop from stack2.

2. Step 2: Identify incorrect return statement

   Code returns this.stack1.pop() instead of this.stack2.pop(), so it returns wrong element or undefined.

3. Final Answer:

   Returns from stack1 instead of stack2 after transfer -> Option D

4. Quick Check:

   Dequeue pops from stack2, not stack1 [OK]

Hint: Dequeue pops from stack2 after transfer [OK]

Common Mistakes:

• Returning from wrong stack after transfer
• Not transferring elements when stack2 empty
• Ignoring empty queue case

5. You want to implement a peek() method for a queue using two stacks that returns the front element without removing it. Which approach is correct?

hard

A. If stack2 is empty, transfer all elements from stack1 to stack2, then return top of stack2

B. Return the bottom element of stack1 directly without transfer

C. Return the top element of stack1 always

D. Transfer elements from stack2 to stack1 and return top of stack1

Solution

1. Step 1: Understand peek operation in queue

   Peek returns the front element without removing it, so it must return the oldest element added.

2. Step 2: Use stack2 for front element

   If stack2 is empty, transfer all elements from stack1 to stack2 to reverse order. Then top of stack2 is front element.

3. Final Answer:

   If stack2 is empty, transfer all elements from stack1 to stack2, then return top of stack2 -> Option A

4. Quick Check:

   Peek uses stack2 top after transfer [OK]

Hint: Peek front from stack2 top after transfer [OK]

Common Mistakes:

• Returning bottom of stack1 directly
• Returning top of stack1 without transfer
• Transferring elements in wrong direction