Queue vs Stack When to Use Which in DSA Typescript - Compare & Choose

Challenge - 5 Problems

🧠 Conceptual

intermediate

Choosing Between Queue and Stack for Task Scheduling

You have a list of tasks that must be processed in the exact order they arrive. Which data structure is best to use?

A Queue, because it processes tasks in the order they arrive.

B Stack, because it processes the most recent task first.

C Stack, because it allows random access to tasks.

D Queue, because it processes tasks in reverse order.

💡 Hint

Think about which data structure follows the 'first come, first served' rule.

A queue processes elements in the order they arrive (FIFO), which is perfect for task scheduling where order matters. A stack processes elements in reverse order (LIFO), which is not suitable here.

❓ Predict Output

intermediate

Output of Stack Operations

What is the printed output after running this TypeScript code that uses a stack?

DSA Typescript

class Stack<T> {
  private items: T[] = [];
  push(item: T) { this.items.push(item); }
  pop(): T | undefined { return this.items.pop(); }
  print() { console.log(this.items.join(' -> ') + ' -> null'); }
}

const stack = new Stack<number>();
stack.push(1);
stack.push(2);
stack.push(3);
stack.pop();
stack.print();

A 3 -> 2 -> 1 -> null

B 1 -> 2 -> null

C 1 -> 3 -> null

D 2 -> 1 -> null

💡 Hint

Remember that pop removes the last pushed item.

The stack pushes 1, 2, 3. Then pop removes 3. Remaining items are 1 and 2 in that order. Printing shows '1 -> 2 -> null'.

❓ Predict Output

advanced

Queue Behavior with Enqueue and Dequeue

What is the printed output after running this TypeScript code that uses a queue?

DSA Typescript

class Queue<T> {
  private items: T[] = [];
  enqueue(item: T) { this.items.push(item); }
  dequeue(): T | undefined { return this.items.shift(); }
  print() { console.log(this.items.join(' -> ') + ' -> null'); }
}

const queue = new Queue<number>();
queue.enqueue(10);
queue.enqueue(20);
queue.enqueue(30);
queue.dequeue();
queue.print();

A 10 -> 30 -> null

B 10 -> 20 -> 30 -> null

C 20 -> 30 -> null

D 30 -> 20 -> null

💡 Hint

Remember that dequeue removes the first item added.

The queue enqueues 10, 20, 30. Dequeue removes 10. Remaining items are 20 and 30. Printing shows '20 -> 30 -> null'.

🔧 Debug

advanced

Identifying Incorrect Use of Stack for Undo Feature

Which option shows a problem when using a stack to implement an undo feature in a text editor?

DSA Typescript

class UndoStack {
  private stack: string[] = [];
  addAction(action: string) { this.stack.push(action); }
  undo(): string | undefined { return this.stack.pop(); }
  print() { console.log(this.stack.join(' -> ') + ' -> null'); }
}

const undoStack = new UndoStack();
undoStack.addAction('type A');
undoStack.addAction('type B');
undoStack.undo();
undoStack.print();

A Undo does not remove any action, causing infinite undo.

B Undo removes the first action, which is incorrect for stack.

C Undo removes all actions at once, losing history.

D Undo removes the last action, which is correct behavior.

💡 Hint

Think about how undo should remove the most recent action.

A stack correctly removes the last action added, which matches undo behavior. Other options describe incorrect behaviors not matching stack operations.

🚀 Application

expert

Choosing Data Structure for Browser History Navigation

You want to implement browser history navigation with back and forward buttons. Which data structure or combination is best suited?

A Use two stacks: one for back history and one for forward history.

B Use a single stack to store all visited pages.

C Use a queue to store visited pages in order.

D Use a linked list with no stacks or queues.

💡 Hint

Consider how back and forward buttons move through history in opposite directions.

Two stacks allow moving back by popping from the back stack and pushing to the forward stack, and vice versa for forward navigation. A single stack or queue cannot handle forward navigation properly.

Practice

1. Which data structure should you use when you need to process tasks in the exact order they arrive, like customers waiting in line at a store?

easy

A. Stack

B. Queue

C. Array

D. Tree

Solution

1. Step 1: Understand the order requirement

   Tasks must be processed in the order they arrive, which means first-in, first-out (FIFO).

2. Step 2: Match the data structure to FIFO

   A queue follows FIFO, so it fits the requirement perfectly.

3. Final Answer:

   Queue -> Option B

4. Quick Check:

   FIFO = Queue [OK]

Hint: Use queue for first-in, first-out order [OK]

Common Mistakes:

• Confusing stack (LIFO) with queue (FIFO)
• Choosing array without order guarantees
• Thinking tree fits linear order

2. Which of the following is the correct TypeScript syntax to add an element to the top of a stack implemented as an array named stack?

easy

A. stack.unshift(element);

B. stack.pop(element);

C. stack.shift(element);

D. stack.push(element);

Solution

1. Step 1: Identify stack operation to add element

   Adding to the top of a stack means pushing an element onto it.

2. Step 2: Match with correct array method

   In TypeScript, push() adds an element to the end (top) of the array acting as a stack.

3. Final Answer:

   stack.push(element); -> Option D

4. Quick Check:

   Push adds to stack top [OK]

Hint: Use push() to add on stack top [OK]

Common Mistakes:

• Using pop() which removes instead of adds
• Using shift() or unshift() which affect queue ends
• Confusing push() with unshift()

3. What will be the output of the following TypeScript code?

const queue: number[] = [];
queue.push(1);
queue.push(2);
queue.push(3);
const first = queue.shift();
console.log(queue);

medium

A. [3, 2]

B. [1, 2, 3]

C. [2, 3]

D. []

Solution

1. Step 1: Trace queue operations

   Elements 1, 2, 3 are added to the queue using push(). Then shift() removes the first element (1).

2. Step 2: Determine queue state after removal

   After removing 1, the queue contains [2, 3].

3. Final Answer:

   [2, 3] -> Option C

4. Quick Check:

   shift() removes first, queue left with [2, 3] [OK]

Hint: shift() removes front in queue [OK]

Common Mistakes:

• Thinking push adds to front instead of back
• Confusing shift() with pop()
• Expecting stack order instead of queue order

4. The following TypeScript code is intended to implement a stack but has a bug. What is the bug?

const stack: number[] = [];
stack.push(10);
stack.push(20);
const top = stack.shift();
console.log(top);

medium

A. Using shift() instead of pop() to remove top element

B. Using push() instead of unshift() to add element

C. Not initializing the stack array

D. Using console.log incorrectly

Solution

1. Step 1: Identify stack removal method

   Stack removes the top element using pop(), not shift().

2. Step 2: Analyze code's removal method

   The code uses shift(), which removes the first element, breaking stack behavior.

3. Final Answer:

   Using shift() instead of pop() to remove top element -> Option A

4. Quick Check:

   Stack removal = pop(), not shift() [OK]

Hint: Stack removes top with pop(), not shift() [OK]

Common Mistakes:

• Confusing shift() with pop()
• Thinking push() adds to front
• Ignoring array initialization

5. You are designing a system to undo and redo user actions. Which data structure combination is best suited for this, and why?

hard

A. Two stacks: one for undo, one for redo, because stacks allow reversing actions easily

B. Two queues: one for undo, one for redo, because queues maintain order of actions

C. One stack only, because redo is not needed

D. One queue only, because undo and redo are processed in order

Solution

1. Step 1: Understand undo/redo requirements

   Undo and redo require reversing and reapplying actions in last-in, first-out order.

2. Step 2: Match data structures to behavior

   Stacks naturally support LIFO, so using two stacks (undo and redo) allows easy push/pop for these operations.

3. Final Answer:

   Two stacks: one for undo, one for redo, because stacks allow reversing actions easily -> Option A

4. Quick Check:

   Undo/Redo = Two stacks (LIFO) [OK]

Hint: Undo/Redo needs two stacks for LIFO action reversal [OK]

Common Mistakes:

• Using queues which do not reverse order easily
• Ignoring redo functionality
• Using only one data structure