Queue vs Stack When to Use Which in DSA Rust - Key Differences

Recall & Review

beginner

What is the main difference between a stack and a queue?

A stack follows Last In First Out (LIFO) order, meaning the last item added is the first to be removed. A queue follows First In First Out (FIFO) order, meaning the first item added is the first to be removed.

beginner

When should you use a stack?

Use a stack when you need to reverse things or track recent actions, like undo features, backtracking, or parsing expressions.

beginner

When is a queue the better choice?

Use a queue when you want to process items in the order they arrive, like in task scheduling, printing jobs, or breadth-first search.

intermediate

How does a stack help in function calls?

A stack keeps track of function calls and returns in the correct order, so the last called function finishes first before returning to the previous one.

beginner

What real-life example can explain a queue?

A queue is like a line at a grocery store checkout: the first person to get in line is the first to be served.

Which data structure would you use to implement an undo feature?

A Stack

B Queue

C Linked List

D Hash Map

Undo features require reversing recent actions, which fits the Last In First Out (LIFO) behavior of a stack.

Which data structure processes elements in the order they arrive?

A Stack

B Graph

C Tree

D Queue

A queue processes elements in First In First Out (FIFO) order, so items are handled in the order they arrive.

What order does a stack follow?

A FIFO

B Sorted

C LIFO

D Random

Stack follows Last In First Out (LIFO) order.

Which data structure is best for breadth-first search (BFS)?

A Queue

B Stack

C Set

D Heap

BFS explores nodes level by level, which requires processing nodes in the order they are discovered, so a queue is used.

If you want to reverse a list of items, which data structure helps most?

A Queue

B Stack

C Array

D Graph

Stack reverses the order because it removes the last added item first.

Explain when you would choose a stack over a queue and give two real-life examples.

Think about situations where the last action needs to be undone or processed first.

Describe the main difference between queue and stack and why that difference matters in programming.

Focus on how the order of adding and removing items affects program behavior.

Practice

1. Which data structure should you use when you want to process items in the exact order they arrive, like a line at a ticket counter?

easy

A. Queue

B. Stack

C. HashMap

D. Tree

Solution

1. Step 1: Understand the order requirement

   Processing items in the exact order they arrive means first-in, first-out (FIFO).

2. Step 2: Match order to data structure

   Queue follows FIFO, so it fits the requirement perfectly.

3. Final Answer:

   Queue -> Option A

4. Quick Check:

   FIFO = Queue [OK]

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

Common Mistakes:

• Choosing stack which is last-in, first-out
• Confusing queue with other data structures
• Ignoring the order requirement

2. Which Rust syntax correctly creates an empty stack using a vector?

easy

A. let mut stack: Vec<i32> = Vec::new();

B. let stack = Vec::empty();

C. let stack = new Vec<i32>();

D. let mut stack = Vec<i32>::init();

Solution

1. Step 1: Recall Rust vector creation syntax

   In Rust, Vec::new() creates an empty vector.

2. Step 2: Check mutability and type annotation

   Stack needs to be mutable to push/pop, and type must be specified or inferred.

3. Final Answer:

   let mut stack: Vec<i32> = Vec::new(); -> Option A

4. Quick Check:

   Vec::new() creates empty vector [OK]

Hint: Use Vec::new() with mut for stack in Rust [OK]

Common Mistakes:

• Using Vec::empty() which does not exist
• Using new keyword like other languages
• Missing mut keyword for modification

3. What will be the output of the following Rust code using a stack?

let mut stack = Vec::new();
stack.push(10);
stack.push(20);
stack.push(30);
while let Some(top) = stack.pop() {
    print!("{} ", top);
}

medium

A. 10 20 30

B. Compilation error

C. 30 20 10

D. 20 30 10

Solution

1. Step 1: Understand stack push order

   Items pushed: 10, then 20, then 30. Stack top is 30.

2. Step 2: Pop items prints in last-in, first-out order

   Pop removes 30 first, then 20, then 10, printing "30 20 10 ".

3. Final Answer:

   30 20 10 -> Option C

4. Quick Check:

   LIFO order = 30 20 10 [OK]

Hint: Stack pops in reverse order of pushes [OK]

Common Mistakes:

• Assuming FIFO order for stack
• Confusing push and pop order
• Expecting compilation error

4. The following Rust code tries to implement a queue using a vector. What is the main problem?

let mut queue = Vec::new();
queue.push(1);
queue.push(2);
queue.remove(0);
queue.remove(0);
println!("{:?}", queue);

medium

A. remove(0) causes a compilation error

B. Using remove(0) is inefficient for large queues

C. push() does not add elements to the vector

D. queue is immutable

Solution

1. Step 1: Understand vector remove(0) behavior

   remove(0) deletes first element but shifts all others left, costly for large vectors.

2. Step 2: Identify inefficiency in queue implementation

   Repeated remove(0) causes O(n) shifts, making it inefficient for queues.

3. Final Answer:

   Using remove(0) is inefficient for large queues -> Option B

4. Quick Check:

   remove(0) shifts elements = inefficient [OK]

Hint: remove(0) shifts all elements, slow for queues [OK]

Common Mistakes:

• Thinking remove(0) causes error
• Assuming push() does not add elements
• Ignoring performance impact

5. You need to design a system that processes tasks in the order they arrive but sometimes needs to undo the last task quickly. Which data structure combination is best in Rust?

hard

A. Use only a stack for both processing and undo

B. Use a HashMap to store tasks and undo

C. Use only a queue for both processing and undo

D. Use a queue for tasks and a stack for undo operations

Solution

1. Step 1: Understand processing order requirement

   Tasks must be processed in arrival order, so a queue (FIFO) is needed.

2. Step 2: Understand undo requirement

   Undo last task quickly means last-in, first-out order, so a stack fits undo.

3. Step 3: Combine data structures

   Use queue for normal processing and stack to track tasks for undo.

4. Final Answer:

   Use a queue for tasks and a stack for undo operations -> Option D

5. Quick Check:

   Queue for order + Stack for undo = Use a queue for tasks and a stack for undo operations [OK]

Hint: Queue for order, stack for undo actions [OK]

Common Mistakes:

• Using only stack loses arrival order
• Using only queue cannot undo last task easily
• Choosing HashMap which doesn't preserve order