Peek Front Element of Queue in DSA Rust - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output after peeking the front element of the queue?

Consider the following Rust code that uses a queue implemented with VecDeque. What will be printed after peeking the front element?

DSA Rust

use std::collections::VecDeque;

fn main() {
    let mut queue: VecDeque<i32> = VecDeque::new();
    queue.push_back(10);
    queue.push_back(20);
    queue.push_back(30);
    if let Some(front) = queue.front() {
        println!("{}", front);
    }
}

A 10

B 30

C 20

D None

💡 Hint

Remember, front() returns the first element added to the queue.

The VecDeque stores elements in order. The front() method returns the first element, which is 10.

❓ Predict Output

intermediate

What happens if the queue is empty when peeking the front element?

What will the following Rust code print?

DSA Rust

use std::collections::VecDeque;

fn main() {
    let queue: VecDeque<i32> = VecDeque::new();
    match queue.front() {
        Some(value) => println!("{}", value),
        None => println!("Empty queue"),
    }
}

A Runtime error

B Empty queue

C None

D 0

💡 Hint

Check what front() returns when the queue has no elements.

front() returns None if the queue is empty, so the code prints "Empty queue".

🔧 Debug

advanced

Why does this code cause a borrow error when peeking the front element?

Identify the cause of the borrow checker error in the following Rust code:

DSA Rust

use std::collections::VecDeque;

fn main() {
    let mut queue: VecDeque<i32> = VecDeque::new();
    queue.push_back(5);
    let front = queue.front();
    queue.push_back(10);
    println!("{:?}", front);
}

A The immutable borrow from front() conflicts with the mutable borrow from push_back()

B The queue is empty when front() is called

C push_back() cannot be called after front()

D front() returns None causing a panic

💡 Hint

Think about Rust's borrowing rules when holding references and mutating the collection.

The variable front holds an immutable reference to the queue's front element. Calling push_back() requires a mutable borrow, which conflicts with the existing immutable borrow, causing a compile-time error.

❓ Predict Output

advanced

What is the state of the queue after peeking and popping the front element?

Given the following Rust code, what will be printed after the operations?

DSA Rust

use std::collections::VecDeque;

fn main() {
    let mut queue: VecDeque<i32> = VecDeque::new();
    queue.push_back(1);
    queue.push_back(2);
    queue.push_back(3);
    if let Some(front) = queue.front() {
        println!("Front: {}", front);
    }
    queue.pop_front();
    println!("Queue after pop: {:?}", queue);
}

A

Front: 1
Queue after pop: [1, 2, 3]

B

Front: 3
Queue after pop: [1, 2]

C

Front: 1
Queue after pop: [2, 3]

D

Front: 2
Queue after pop: [3]

💡 Hint

Remember that pop_front() removes the first element.

The front element is 1. After popping it, the queue contains [2, 3].

🧠 Conceptual

expert

Why is peeking the front element of a queue efficient with VecDeque in Rust?

Choose the best explanation for why VecDeque allows efficient peeking of the front element.

A Because <code>VecDeque</code> sorts elements internally for quick access

B Because <code>VecDeque</code> stores elements in a linked list allowing fast front access

C Because <code>VecDeque</code> copies elements to a new vector when peeking

D Because <code>VecDeque</code> uses a ring buffer allowing O(1) access to front and back elements

💡 Hint

Think about the internal data structure of VecDeque.

VecDeque uses a ring buffer (circular buffer) which allows constant time access to both front and back elements without shifting elements.

Practice

1. What does the peek() method do in a queue data structure?

easy

A. Adds a new element to the back of the queue

B. Returns the front element without removing it

C. Removes the front element from the queue

D. Checks if the queue is empty

Solution

1. Step 1: Understand the purpose of peek()

   The peek() method is used to look at the front element of the queue without changing the queue.

2. Step 2: Differentiate peek() from other queue operations

   Unlike dequeue which removes the front element, peek() only returns it without removal.

3. Final Answer:

   Returns the front element without removing it -> Option B

4. Quick Check:

   peek() = front element [OK]

Hint: Peek means look without removing [OK]

Common Mistakes:

• Confusing peek() with dequeue()
• Thinking peek() adds elements
• Assuming peek() checks emptiness

2. Which of the following is the correct Rust syntax to peek the front element of a VecDeque named queue?

easy

A. let front = queue.front();

B. let front = queue.peek_front();

C. let front = queue.peek();

D. let front = queue[0];

Solution

1. Step 1: Recall VecDeque front method

   In Rust, VecDeque provides front() to look at the front element without removing it.

2. Step 2: Check other options

   peek_front() and peek() are not valid VecDeque methods; queue[0] is invalid because VecDeque does not implement Index<usize>.

3. Final Answer:

   let front = queue.front(); -> Option A

4. Quick Check:

   VecDeque peek front = front() [OK]

Hint: Use front() to peek front in VecDeque [OK]

Common Mistakes:

• Using peek_front() which does not exist on VecDeque
• Using peek() which does not exist
• Trying queue[0] without Index implementation

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);
    if let Some(front) = queue.front() {
        println!("{}", front);
    }
}

medium

A. 10

B. 20

C. 30

D. None

Solution

1. Step 1: Understand queue contents after push_back

   Elements added in order: 10 (front), 20, 30 (back).

2. Step 2: Peek front element

   front() returns reference to 10, the first element.

3. Final Answer:

   10 -> Option A

4. Quick Check:

   Front element = 10 [OK]

Hint: front() returns first pushed element [OK]

Common Mistakes:

• Confusing front() with pop_front()
• Expecting last element instead of first
• Ignoring Option handling with if let

4. Identify the error in this Rust code that tries to peek the front element of a queue:

use std::collections::VecDeque;

fn main() {
    let mut queue = VecDeque::new();
    queue.push_back(5);
    let front = queue.peek();
    println!("{}", front.unwrap());
}

medium

A. Cannot unwrap Option returned by peek()

B. push_back() does not add elements

C. VecDeque has no method named peek()

D. println! macro syntax is incorrect

Solution

1. Step 1: Check VecDeque methods

   VecDeque does not have a method named peek(); it uses front() to peek front element.

2. Step 2: Analyze other parts

   push_back() correctly adds elements; unwrap() is valid if Option is Some; println! syntax is correct.

3. Final Answer:

   VecDeque has no method named peek() -> Option C

4. Quick Check:

   peek() method missing in VecDeque [OK]

Hint: Use front(), not peek(), on VecDeque [OK]

Common Mistakes:

• Using peek() instead of front()
• Ignoring method availability in VecDeque
• Assuming unwrap() always safe without checking

5. You have a queue implemented using VecDeque in Rust. You want to peek the front element safely and print it or print "Empty" if the queue is empty. Which code snippet correctly does this?

hard

A. if queue.is_empty() { println!("Empty"); } else { println!("{}", queue.pop_front().unwrap()); }

B. println!("{}", queue.front().unwrap());

C. println!("{}", queue[0]);

D. if let Some(front) = queue.front() { println!("{}", front); } else { println!("Empty"); }

Solution

1. Step 1: Understand safe peek usage

   front() returns Option<&T>. Using if let Some(front) safely handles empty queue.

2. Step 2: Check other options

   The unwrap version panics if empty (unsafe), direct indexing is invalid on VecDeque, the version with pop_front() removes the element instead of peeking.

3. Final Answer:

   if let Some(front) = queue.front() { println!("{}", front); } else { println!("Empty"); } -> Option D

4. Quick Check:

   Safe peek with if let Some(front) = queue.front() { println!("{}", front); } else { println!("Empty"); } [OK]

Hint: Use if let Some(front) = front() for safe peek [OK]

Common Mistakes:

• Unwrapping Option without checking
• Using pop_front() instead of front()
• Indexing VecDeque like a vector