Peek Top Element of Stack in DSA Rust - Execution Trace

Concept Flow - Peek Top Element of Stack

Start with Stack

↓

Check if Stack is Empty?

Yes→Return None or Error

No↓

Access Top Element

↓

Return Top Element Value

↓

End

The flow checks if the stack is empty. If not, it accesses and returns the top element without removing it.

Execution Sample

DSA Rust

fn peek(stack: &Vec<i32>) -> Option<i32> {
    if stack.is_empty() {
        None
    } else {
        Some(*stack.last().unwrap())
    }
}

fn main() {
    let stack = vec![10, 20, 30];
    println!("Peeked: {:?}", peek(&stack));
}

This code returns the top element of the stack if it exists, otherwise None.

Execution Table

Step	Operation	Stack State	Pointer Changes	Visual State
1	Start with stack = [10, 20, 30]	[10, 20, 30]	Top points to index 2	10 -> 20 -> 30 (top)
2	Check if stack is empty	[10, 20, 30]	Top points to index 2	Stack not empty
3	Access top element	[10, 20, 30]	Top points to index 2	Top element is 30
4	Return top element value	[10, 20, 30]	Top points to index 2	Peeked value: 30
5	End	[10, 20, 30]	Top points to index 2	Stack unchanged

💡 Peek ends after returning the top element without modifying the stack.

Variable Tracker

Variable	Start	After Step 2	After Step 3	Final
stack	[10, 20, 30]	[10, 20, 30]	[10, 20, 30]	[10, 20, 30]
top_index	2	2	2	2
peeked_value	None	None	Some(30)	Some(30)

Key Moments - 3 Insights

Why do we check if the stack is empty before peeking?

Because trying to access the top element of an empty stack would cause an error. Step 2 in the execution_table shows this check prevents errors.

Does peeking remove the top element from the stack?

No, peeking only reads the top element without removing it. Step 5 shows the stack remains unchanged after peeking.

What does the function return if the stack is empty?

It returns None to indicate no element is available. This is shown in the concept_flow where the empty check leads to returning None.

Visual Quiz - 3 Questions

Look at the execution_table, what is the top element at Step 3?

A 10

B 30

C 20

D None

💡 Hint

Check the 'Visual State' column at Step 3 in the execution_table.

At which step does the code confirm the stack is not empty?

A Step 2

B Step 4

C Step 1

D Step 5

💡 Hint

Look at the 'Operation' column for the empty check in the execution_table.

If the stack was empty, what would the peek function return?

A Some(0)

B Some(top element)

C None

D Panic/Error

💡 Hint

Refer to the concept_flow and key_moments about empty stack handling.

Concept Snapshot

Peek Top Element of Stack:
- Check if stack is empty
- If empty, return None
- Else, return top element without removing
- Stack remains unchanged
- Useful to see top without pop

Full Transcript

Peeking the top element of a stack means looking at the last added item without removing it. First, we check if the stack is empty to avoid errors. If it is empty, we return None. Otherwise, we return the top element. The stack stays the same after peeking. This is shown step-by-step in the execution table where the stack starts with [10, 20, 30], the top is checked, and the value 30 is returned without changing 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()