Queue Concept and FIFO Principle in DSA Rust - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this queue operation sequence?

Consider a queue implemented with the following operations in Rust:

let mut queue = VecDeque::new();
queue.push_back(10);
queue.push_back(20);
queue.push_back(30);
queue.pop_front();
queue.push_back(40);

What is the printed state of the queue after these operations?

DSA Rust

use std::collections::VecDeque;

fn main() {
    let mut queue = VecDeque::new();
    queue.push_back(10);
    queue.push_back(20);
    queue.push_back(30);
    queue.pop_front();
    queue.push_back(40);
    for val in &queue {
        print!("{} -> ", val);
    }
    print!("null\n");
}

A 20 -> 30 -> 40 -> null

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

C 30 -> 40 -> null

D 40 -> null

💡 Hint

Remember, queue removes elements from the front (FIFO).

The first element (10) is removed by pop_front(). The remaining elements are 20, 30, then 40 is added at the back.

🧠 Conceptual

intermediate

Which property best describes a queue?

Choose the property that correctly describes how a queue works.

A Random Access

B Last In, First Out (LIFO)

C First In, First Out (FIFO)

D Sorted Order

💡 Hint

Think about the order in which people line up in a queue.

A queue follows FIFO: the first element added is the first to be removed.

🔧 Debug

advanced

Identify the error in this queue implementation snippet

What error will this Rust code cause when run?

use std::collections::VecDeque;

fn main() {
    let mut queue = VecDeque::new();
    queue.push_back(1);
    queue.push_back(2);
    let front = queue.pop_front().unwrap();
    let front_again = queue.pop_front().unwrap();
    let front_third = queue.pop_front().unwrap();
    println!("{}", front_third);
}

A Runtime panic due to unwrap on None

B Prints 3

C Compilation error: missing semicolon

D Prints 1

💡 Hint

Check how many elements are in the queue before popping.

After popping twice, the queue is empty. The third pop_front returns None. Calling unwrap() on None causes a runtime panic.

❓ Predict Output

advanced

What is the output after these queue operations?

Given this Rust code:

use std::collections::VecDeque;

fn main() {
    let mut queue = VecDeque::new();
    for i in 1..=5 {
        queue.push_back(i);
    }
    queue.pop_front();
    queue.pop_front();
    queue.push_back(6);
    queue.push_back(7);
    for val in &queue {
        print!("{} -> ", val);
    }
    print!("null\n");
}

What is printed?

A 1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 -> null

B 3 -> 4 -> 5 -> 6 -> 7 -> null

C 6 -> 7 -> null

D 2 -> 3 -> 4 -> 5 -> 6 -> 7 -> null

💡 Hint

Remember that pop_front removes from the front in FIFO order.

Initially queue has 1 to 5. Two pops remove 1 and 2. Then 6 and 7 are added at the back. Remaining elements are 3,4,5,6,7.

🧠 Conceptual

expert

Why is a queue preferred over a stack for breadth-first search (BFS)?

Choose the best reason why BFS uses a queue instead of a stack.

A Stack allows random access to nodes

B Queue uses less memory than stack

C Stack processes nodes in FIFO order, which BFS requires

D Queue processes nodes in FIFO order, exploring neighbors level by level

💡 Hint

Think about the order BFS visits nodes in a graph.

BFS explores nodes level by level, which requires FIFO order. Queue provides FIFO, stack provides LIFO.

Practice

1. What does the FIFO principle mean in the context of a queue?

easy

A. First In, Last Out - the first element added is the last removed

B. Last In, Last Out - the last element added is the last removed

C. Last In, First Out - the last element added is the first removed

D. First In, First Out - the first element added is the first removed

Solution

1. Step 1: Understand FIFO principle

   FIFO means the first element added to the queue will be the first one to leave.

2. Step 2: Match FIFO with queue behavior

   Queues follow FIFO, so the first inserted element is removed first.

3. Final Answer:

   First In, First Out - the first element added is the first removed -> Option D

4. Quick Check:

   FIFO = First In, First Out [OK]

Hint: Remember queue = line; first come, first served [OK]

Common Mistakes:

• Confusing FIFO with LIFO
• Thinking queue removes last added first
• Mixing stack behavior with queue

2. Which of the following is the correct way to create an empty queue using Rust's standard library?

easy

A. let mut queue = Queue::new();

B. let mut queue = VecDeque::new();

C. let queue = Queue::empty();

D. let queue = Vec::queue();

Solution

1. Step 1: Identify Rust queue type

   Rust's standard library uses VecDeque for queue operations.

2. Step 2: Check correct syntax for empty VecDeque

   VecDeque::new() creates an empty queue correctly.

3. Final Answer:

   let mut queue = VecDeque::new(); -> Option B

4. Quick Check:

   VecDeque::new() creates empty queue [OK]

Hint: Use VecDeque::new() for empty queue in Rust [OK]

Common Mistakes:

• Using non-existent Queue::empty() method
• Confusing Vec with queue type
• Missing mut keyword for mutable queue

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

use std::collections::VecDeque;

fn main() {
    let mut queue = VecDeque::new();
    queue.push_back(10);
    queue.push_back(20);
    queue.push_back(30);
    let first = queue.pop_front();
    println!("{:?}", first);
    println!("{:?}", queue);
}

medium

A. Some(10)
[20, 30]

B. Some(30)
[10, 20]

C. None
[10, 20, 30]

D. Some(20)
[10, 30]

Solution

1. Step 1: Trace queue insertions

   Elements 10, 20, 30 are added to the back in order.

2. Step 2: Pop front element

   pop_front() removes and returns the first element, which is 10.

3. Step 3: Print results

   first prints Some(10), queue now contains [20, 30].

4. Final Answer:

   Some(10) [20, 30] -> Option A

5. Quick Check:

   pop_front() returns first element [OK]

Hint: pop_front() removes first inserted element [OK]

Common Mistakes:

• Thinking pop_front() removes last element
• Confusing push_back with push_front
• Expecting None when queue is not empty

4. Identify the error in the following Rust code that tries to implement a queue using VecDeque:

use std::collections::VecDeque;

fn main() {
    let mut queue = VecDeque::new();
    queue.push_front(1);
    queue.push_back(2);
    let first = queue.pop_back();
    println!("{:?}", first);
}

medium

A. Error: push_front() is invalid method for VecDeque

B. No error; code works and prints Some(2)

C. Error: pop_back() should be pop_front() to follow FIFO

D. Error: queue must be immutable for pop_back()

Solution

1. Step 1: Analyze queue operations

   push_front(1) adds 1 at front, push_back(2) adds 2 at back.

2. Step 2: Check pop_back() usage

   pop_back() removes last element (2), but FIFO requires removing first element.

3. Step 3: Correct method for FIFO

   pop_front() should be used to remove the first inserted element.

4. Final Answer:

   Error: pop_back() should be pop_front() to follow FIFO -> Option C

5. Quick Check:

   FIFO needs pop_front(), not pop_back() [OK]

Hint: Use pop_front() to remove first element in queue [OK]

Common Mistakes:

• Using pop_back() instead of pop_front() for FIFO
• Thinking push_front() is invalid
• Forgetting mut keyword for mutable queue

5. You want to simulate a queue in Rust that processes tasks in order. Given this code snippet, what will be the final state of the queue after all operations?

use std::collections::VecDeque;

fn main() {
    let mut queue = VecDeque::new();
    queue.push_back("task1");
    queue.push_back("task2");
    queue.push_back("task3");
    queue.pop_front();
    queue.push_back("task4");
    queue.pop_front();
    println!("{:?}", queue);
}

hard

A. ["task3", "task4"]

B. ["task2", "task3", "task4"]

C. ["task1", "task4"]

D. ["task4"]

Solution

1. Step 1: Trace queue after initial pushes

   Queue after pushes: ["task1", "task2", "task3"]

2. Step 2: First pop_front()

   Removes "task1", queue: ["task2", "task3"]

3. Step 3: Push "task4"

   Queue: ["task2", "task3", "task4"]

4. Step 4: Second pop_front()

   Removes "task2", queue: ["task3", "task4"]

5. Final Answer:

   ["task3", "task4"] -> Option A

6. Quick Check:

   FIFO removes oldest tasks first [OK]

Hint: Pop front removes oldest; push back adds newest [OK]

Common Mistakes:

• Removing wrong elements with pop_back()
• Forgetting order of operations
• Assuming pop_front() removes last element