Why Peek Top Element of Stack in DSA Rust?

The Big Idea

What if you could see the top of your stack without touching it at all?

The Scenario

Imagine you have a stack of books on your desk. You want to see the title of the book on the very top without removing it. If you had to take off each book one by one just to see the top, it would be tiring and slow.

The Problem

Manually checking the top means removing items, which can cause mistakes like losing track of the order or dropping books. It wastes time and effort, especially if you only want to peek quickly.

The Solution

With the peek operation, you can look at the top item instantly without changing the stack. It's like having a transparent cover on the stack that shows the top book's title without moving anything.

Before vs After

✗ Before

if !stack.is_empty() {
    let top = stack.pop();
    println!("Top element: {:?}", top);
    stack.push(top.unwrap());
}

✓ After

if let Some(top) = stack.last() {
    println!("Top element: {:?}", top);
}

What It Enables

Peek lets you quickly check the top item without disturbing the stack, making your code cleaner and safer.

Real Life Example

When undoing actions in a text editor, peek helps to see the last action without removing it, so you can decide whether to undo or not.

Key Takeaways

Manual checking requires removing and re-adding items, which is slow and risky.

Peek shows the top element instantly without changing the stack.

It helps keep the stack intact and your program error-free.

Practice

1. What does the peek operation do in a stack data structure?

easy

A. Returns the top element without removing it

B. Removes the top element and returns it

C. Adds a new element to the top

D. Checks if the stack is empty

Solution

1. Step 1: Understand stack operations

   A stack stores elements in a last-in, first-out order. Common operations include push, pop, and peek.

2. Step 2: Define peek operation

   Peek returns the top element without removing it, allowing you to see the current top value safely.

3. Final Answer:

   Returns the top element without removing it -> Option A

4. Quick Check:

   Peek = top element without removal [OK]

Hint: Peek shows top without changing stack [OK]

Common Mistakes:

• Confusing peek with pop operation
• Thinking peek adds elements
• Assuming peek checks emptiness

2. Which of the following Rust code snippets correctly peeks the top element of a stack implemented as a Vec<i32> named stack?

easy

A. let top = stack.last();

B. let top = stack[0];

C. let top = stack.pop();

D. let top = stack.first();

Solution

1. Step 1: Understand Rust Vec methods for stack

   In Rust, Vec can be used as a stack. pop() removes and returns the last element, last() returns a reference to the last element without removing it.

2. Step 2: Identify correct peek method

   Peek means to see the top element without removing it, so stack.last() is correct. stack.pop() removes it, stack[0] accesses the first element, and stack.first() returns the first element, not the top.

3. Final Answer:

   let top = stack.last(); -> Option A

4. Quick Check:

   Peek = stack.last() [OK]

Hint: Use .last() to peek top element in Rust Vec stack [OK]

Common Mistakes:

• Using pop() which removes element
• Accessing first() instead of last()
• Using index 0 which is bottom of stack

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

let mut stack = vec![10, 20, 30];
if let Some(top) = stack.last() {
    println!("{}", top);
} else {
    println!("Stack is empty");
}

medium

A. 20

B. 30

C. 10

D. Stack is empty

Solution

1. Step 1: Understand stack contents and last()

   The stack vector contains [10, 20, 30]. The last element is 30.

2. Step 2: Trace the if let statement

   The stack.last() returns Some(&30), so the if block prints 30.

3. Final Answer:

   30 -> Option B

4. Quick Check:

   stack.last() = 30 [OK]

Hint: stack.last() returns top element reference [OK]

Common Mistakes:

• Printing bottom element instead of top
• Confusing last() with pop() output
• Assuming stack is empty

4. Identify the error in the following Rust code that tries to peek the top element of a stack and fix it:

let stack = vec![1, 2, 3];
let top = stack.pop().unwrap();
println!("Top element: {}", top);

medium

A. No error, code works correctly

B. pop() removes element; use last() to peek instead

C. unwrap() causes panic; use expect() instead

D. stack should be mutable to use pop()

Solution

1. Step 1: Check mutability for pop()

   pop() removes the last element, so the vector must be mutable. Here, stack is immutable.

2. Step 2: Fix by making stack mutable

   Change let stack = vec![1, 2, 3]; to let mut stack = vec![1, 2, 3]; to allow pop().

3. Final Answer:

   stack should be mutable to use pop() -> Option D

4. Quick Check:

   pop() needs mutable stack [OK]

Hint: pop() requires mutable stack variable [OK]

Common Mistakes:

• Ignoring mut keyword error
• Confusing pop() with peek operation
• Assuming unwrap() always safe

5. Given a stack implemented as Vec<i32>, write a Rust function peek_top that returns the top element as Option<i32> without removing it. What is the correct implementation?

hard

A. fn peek_top(stack: &mut Vec<i32>) -> Option<i32> { stack.pop() }

B. fn peek_top(stack: &Vec<i32>) -> i32 { *stack.last().unwrap() }

C. fn peek_top(stack: &Vec<i32>) -> Option<i32> { stack.last().copied() }

D. fn peek_top(stack: Vec<i32>) -> Option<i32> { stack.first().copied() }

Solution

1. Step 1: Understand function requirements

   The function must peek without removing, so it should borrow stack immutably and return Option<i32>.

2. Step 2: Analyze options

   fn peek_top(stack: &Vec<i32>) -> Option<i32> { stack.last().copied() } uses stack.last().copied() which returns Option<i32> by copying the reference. fn peek_top(stack: &mut Vec<i32>) -> Option<i32> { stack.pop() } removes element (pop), fn peek_top(stack: &Vec<i32>) -> i32 { *stack.last().unwrap() } unwraps and returns i32 (not Option), fn peek_top(stack: Vec<i32>) -> Option<i32> { stack.first().copied() } uses first() which is bottom element.

3. Final Answer:

   fn peek_top(stack: &Vec<i32>) -> Option<i32> { stack.last().copied() } -> Option C

4. Quick Check:

   Peek returns Option with copied last element [OK]

Hint: Use last().copied() for safe peek returning Option<i32> [OK]

Common Mistakes:

• Using pop() which removes element
• Returning i32 instead of Option<i32>
• Accessing first() instead of last()