Peek Top Element of Stack in DSA Go

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 stack.

Top -> [5] -> 4 -> 3 -> null
Stack grows downward, top points to the last added element.

Dry Run Walkthrough

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

Goal: To see the top element of the stack without removing it

Step 1: push 3 onto empty stack

Top -> [3] -> null

Why: We add the first element; it becomes the top

Step 2: push 4 onto stack

Top -> [4] -> 3 -> null

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

Step 3: push 5 onto stack

Top -> [5] -> 4 -> 3 -> null

Why: Again, new element becomes the top

Step 4: peek top element

Top -> [5] -> 4 -> 3 -> null

Why: We look at the top element without changing the stack

Result:

Top -> [5] -> 4 -> 3 -> null
Peeked element: 5

Annotated Code

DSA Go

package main

import (
	"errors"
	"fmt"
)

type Stack struct {
	elements []int
}

func (s *Stack) Push(val int) {
	s.elements = append(s.elements, val) // add element at the end (top)
}

func (s *Stack) Peek() (int, error) {
	if len(s.elements) == 0 {
		return 0, errors.New("stack is empty") // handle empty stack
	}
	return s.elements[len(s.elements)-1], nil // return last element without removing
}

func main() {
	stack := &Stack{}
	stack.Push(3)
	stack.Push(4)
	stack.Push(5)

	val, err := stack.Peek()
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Printf("Stack top element: %d\n", val)
}

s.elements = append(s.elements, val) // add element at the end (top)

push new element on top of stack

if len(s.elements) == 0 {

check if stack is empty before peek

return s.elements[len(s.elements)-1], nil // return top element without removing

return top element without removing it

Output

Stack top element: 5

Complexity Analysis

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

Space: O(n) because stack stores n elements

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

Edge Cases

empty stack

peek returns error indicating stack is empty

DSA Go

if len(s.elements) == 0 {

When to Use This Pattern

When you need to see 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 during peek
Fix: Return the last element without modifying the stack array

Mistake: Not checking if the stack is empty before peeking
Fix: Add a condition to handle empty stack and return an error

Summary

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

Use peek when you want to check the top item but keep the stack unchanged.

The key is to access the last element safely without modifying the stack.

Practice

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

easy

A. Returns the top element without removing it

B. Removes the top element from the stack

C. Adds a new element to the top of the stack

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 (add), pop (remove), and peek (view top).

2. Step 2: Define peek operation

   Peek returns the top element without removing it, allowing you to see the current top without changing the stack.

3. Final Answer:

   Returns the top element without removing it -> Option A

4. Quick Check:

   Peek = View top element without removal [OK]

Hint: Peek shows top without removing it [OK]

Common Mistakes:

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

2. Which of the following is the correct Go syntax to peek the top element of a stack implemented as a slice named stack?

easy

A. top := stack[len(stack)-1]

B. top := stack[-1]

C. top := stack[0]

D. top := stack[len(stack)]

Solution

1. Step 1: Understand Go slice indexing

   Go slices are zero-indexed. The last element is at index length-1.

2. Step 2: Identify correct top element access

   To peek top, access stack[len(stack)-1]. Using len(stack) is out of range, 0 is bottom, and negative index is invalid.

3. Final Answer:

   top := stack[len(stack)-1] -> Option A

4. Quick Check:

   Last element index = length-1 [OK]

Hint: Use len(stack)-1 to get top index [OK]

Common Mistakes:

• Using len(stack) as index (out of range)
• Using negative index (not supported in Go)
• Accessing stack[0] which is bottom

3. What will be the output of the following Go code snippet?

stack := []int{10, 20, 30}
top := stack[len(stack)-1]
fmt.Println(top)

medium

A. 10

B. Runtime error

C. 20

D. 30

Solution

1. Step 1: Analyze stack contents

   The stack slice contains elements [10, 20, 30], where 30 is the last element (top).

2. Step 2: Evaluate peek operation

   top := stack[len(stack)-1] accesses stack[2], which is 30, then prints it.

3. Final Answer:

   30 -> Option D

4. Quick Check:

   Top element = 30 [OK]

Hint: Last element is top, printed value is 30 [OK]

Common Mistakes:

• Printing bottom element instead of top
• Indexing out of range causing error
• Confusing output with pop operation

4. Identify the error in the following Go code that tries to peek the top element of a stack:

stack := []int{}
top := stack[len(stack)-1]
fmt.Println(top)

medium

A. Syntax error due to missing import

B. Index out of range runtime error

C. top will be zero by default

D. Code runs fine and prints 0

Solution

1. Step 1: Check stack initialization

   The stack is initialized as an empty slice with length 0.

2. Step 2: Analyze peek operation

   Accessing stack[len(stack)-1] means stack[-1], which is invalid and causes runtime panic: index out of range.

3. Final Answer:

   Index out of range runtime error -> Option B

4. Quick Check:

   Empty slice peek causes runtime error [OK]

Hint: Empty stack peek causes index error [OK]

Common Mistakes:

• Assuming peek returns zero on empty stack
• Ignoring runtime panic possibility
• Confusing syntax error with runtime error

5. Given a stack implemented as a slice stack := []int{5, 10, 15}, write the correct Go code snippet to safely peek the top element and handle the case when the stack is empty.

hard

A. top := stack[0]
fmt.Println(top)

B. top := stack[len(stack)]
fmt.Println(top)

C. if len(stack) > 0 {
top := stack[len(stack)-1]
fmt.Println(top)
} else {
fmt.Println("Stack is empty")
}

D. if stack != nil {
top := stack[len(stack)-1]
fmt.Println(top)
}

Solution

1. Step 1: Check stack length before peeking

   To avoid runtime error, verify stack length > 0 before accessing top element.

2. Step 2: Access top element safely and handle empty case

   If stack is not empty, peek top with stack[len(stack)-1]. Otherwise, print "Stack is empty" message.

3. Final Answer:

   if len(stack) > 0 { top := stack[len(stack)-1] fmt.Println(top) } else { fmt.Println("Stack is empty") } -> Option C

4. Quick Check:

   Check length before peek to avoid errors [OK]

Hint: Check length > 0 before peek [OK]

Common Mistakes:

• Not checking length before peek
• Using len(stack) as index
• Assuming nil check is enough