Peek Top Element of Stack in DSA Rust

Mental Model

A stack is like a pile of plates where you only see and use the top plate. Peeking means looking at the top plate without removing it.

Analogy: Imagine a stack of books on a table. You want to see the title of the top book without taking it off the pile.

Stack top
  ↑
[7] -> [3] -> [5] -> null

Dry Run Walkthrough

Input: stack: push 5, push 3, push 7; peek top element

Goal: See the top element of the stack without removing it

Step 1: push 5 onto empty stack

[5] -> null ↑top

Why: First element becomes the top of the stack

Step 2: push 3 onto stack

[3] -> [5] -> null ↑top

Why: New element goes on top, previous top moves down

Step 3: push 7 onto stack

[7] -> [3] -> [5] -> null ↑top

Why: New element is now the top of the stack

Step 4: peek top element

[7] -> [3] -> [5] -> null ↑top

Why: Look at top without removing it

Result:

[7] -> [3] -> [5] -> null ↑top
Peeked element: 7

Annotated Code

DSA Rust

struct Stack {
    elements: Vec<i32>,
}

impl Stack {
    fn new() -> Self {
        Stack { elements: Vec::new() }
    }

    fn push(&mut self, value: i32) {
        self.elements.push(value); // add element on top
    }

    fn peek(&self) -> Option<i32> {
        self.elements.last().copied() // get top element without removing
    }

    fn print(&self) {
        for &val in self.elements.iter().rev() {
            print!("[{}] -> ", val); // print from top to bottom
        }
        println!("null ↑top");
    }
}

fn main() {
    let mut stack = Stack::new();
    stack.push(5);
    stack.push(3);
    stack.push(7);
    stack.print();
    if let Some(top) = stack.peek() {
        println!("Peeked element: {}", top);
    } else {
        println!("Stack is empty");
    }
}

self.elements.push(value); // add element on top

push new element to the top of the stack

self.elements.last().copied() // get top element without removing

peek returns the top element without changing the stack

for &val in self.elements.iter().rev() { print!("[{}] -> ", val); }

print stack from top to bottom

Output

[7] -> [3] -> [5] -> null ↑top

Peeked element: 7

Complexity Analysis

Time: O(1) because peek accesses the last element directly without traversal

Space: O(n) because the stack stores n elements in a vector

vs Alternative: Compared to popping, peek does not remove elements so it is faster and safer when just viewing the top

Edge Cases

empty stack

peek returns None indicating no top element

DSA Rust

self.elements.last().copied()

When to Use This Pattern

When you need to check the last added item without removing it, use the peek operation on a stack.

Common Mistakes

Mistake: Removing the top element instead of just viewing it when peeking
Fix: Use a method that only reads the top element without popping it, like .last() in Rust Vec

Summary

Peek shows the top element of the stack without removing it.

Use peek when you want to see the current top without changing the stack.

The key is accessing the last added element directly without modifying the stack.

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()