Peek Top Element of Stack in DSA Go - Deep Dive

Overview - Peek Top Element of Stack

What is it?

A stack is a collection where you add and remove items only from the top. Peeking means looking at the top item without removing it. This helps you see what is next to be removed without changing the stack. It's like checking the top book on a pile without taking it off.

Why it matters

Peeking lets you check the next item to use without changing the stack. Without peeking, you would have to remove the item to see it, which could lose data or change the order. This is important in many programs like undo actions, expression evaluation, and backtracking.

Where it fits

You should know what a stack is and how push and pop work before learning peek. After peek, you can learn about stack applications like balancing symbols, depth-first search, and implementing other data structures.

Mental Model

Core Idea

Peeking a stack means looking at the top item without removing it, so you know what's next without changing the stack.

Think of it like...

It's like looking at the top book on a stack without taking it off, so you know which book is next to read.

Stack (top at the right):
┌─────┐
│  5  │  <- top (peek shows 5)
├─────┤
│  3  │
├─────┤
│  1  │
└─────┘

Build-Up - 6 Steps

1

Foundation

Understanding Stack Basics

Concept: Learn what a stack is and how push and pop work.

A stack is like a pile of plates. You add (push) plates on top and remove (pop) plates from the top. The last plate you put on is the first one you take off. This is called Last-In-First-Out (LIFO).

Result

You can add and remove items only from the top of the stack.

Understanding push and pop is essential because peek works with the same top element without removing it.

2

Foundation

Stack Representation in Go

Concept: How to represent a stack using a slice in Go.

In Go, we can use a slice to hold stack items. The last element in the slice is the top of the stack. For example, stack := []int{1, 3, 5} means 5 is on top.

Result

You have a simple stack where you can add or remove items at the end of the slice.

Using slices for stacks is simple and efficient because Go slices grow and shrink easily.

3

Intermediate

Implementing Peek Function

🤔Before reading on: do you think peek should remove the top item or just show it? Commit to your answer.

Concept: Peek returns the top item without removing it.

To peek, check if the stack is empty. If not, return the last element of the slice. Do not change the slice. Example: func Peek(stack []int) (int, bool) { if len(stack) == 0 { return 0, false } return stack[len(stack)-1], true }

Result

Peek returns the top element and a boolean indicating if the stack is not empty.

Knowing peek does not remove the item helps prevent accidental data loss or stack changes.

4

Intermediate

Handling Empty Stack in Peek

🤔Before reading on: what should peek return if the stack is empty? Commit to your answer.

Concept: Peek must handle empty stacks safely to avoid errors.

If the stack is empty, peek cannot return a valid item. So, it returns a default value and false to show no item is present. This prevents runtime errors like index out of range.

Result

Peek safely returns false when the stack is empty, signaling no top element.

Handling empty stacks prevents crashes and makes peek reliable in all situations.

5

Advanced

Peek in Stack with Custom Types

🤔Before reading on: do you think peek works the same for stacks of any data type? Commit to your answer.

Concept: Peek works similarly for stacks holding any data type, using Go generics.

With Go generics, you can write a peek function that works for any type. For example: func Peek[T any](stack []T) (T, bool) { var zero T if len(stack) == 0 { return zero, false } return stack[len(stack)-1], true } This returns the top element of any stack type safely.

Result

Peek can be used for stacks of ints, strings, structs, etc., without rewriting code.

Using generics makes peek reusable and type-safe across many stack uses.

6

Expert

Performance and Safety of Peek

🤔Before reading on: does peek change the stack or affect performance significantly? Commit to your answer.

Concept: Peek is a fast, safe operation that does not modify the stack or cause overhead.

Peek only reads the last element of the slice, which is a constant-time operation. It does not copy or modify the stack. This makes peek very efficient. Also, by returning a boolean, it safely handles empty stacks without panics.

Result

Peek is a lightweight, safe way to inspect the stack top in production code.

Understanding peek's efficiency and safety helps write robust, high-performance stack code.

Under the Hood

Internally, the stack is a slice in Go, which is a dynamic array. The top element is the last item in the slice. Peek accesses this last element by index without changing the slice length or contents. The slice header holds a pointer to the array, length, and capacity. Peek reads the element at length-1 index directly.

Why designed this way?

Stacks are designed for simple last-in-first-out access. Using slices leverages Go's built-in dynamic arrays for easy resizing and indexing. Peek is designed to be a non-destructive read to avoid unintended side effects and errors. Returning a boolean alongside the value is a Go idiom for safe access.

Stack slice structure:
┌───────────────┐
│ Pointer to arr│
├───────────────┤
│ Length = 3    │
├───────────────┤
│ Capacity = 5  │
└───────────────┘

Array elements:
Index: 0   1   2
Value: 1 | 3 | 5 <- top (peek reads here)

Myth Busters - 4 Common Misconceptions

Quick: Does peek remove the top element from the stack? Commit yes or no.

Common Belief: Peek removes the top element just like pop.

Reality: Peek only shows the top element without removing it.

Why it matters: If you think peek removes the element, you might lose data or change stack order unintentionally.

Quick: Can peek return a valid element when the stack is empty? Commit yes or no.

Common Belief: Peek always returns a valid element, even if the stack is empty.

Reality: Peek must handle empty stacks by returning a failure indicator; no valid element exists.

Why it matters: Ignoring empty stack checks causes runtime errors like index out of range.

Quick: Is peek slower than pop or push operations? Commit yes or no.

Common Belief: Peek is slower because it needs to copy or process the element.

Reality: Peek is a constant-time operation that only reads the last element without copying.

Why it matters: Misunderstanding peek's efficiency might lead to unnecessary optimizations or avoiding peek.

Quick: Does peek only work for stacks of integers? Commit yes or no.

Common Belief: Peek only works for integer stacks.

Reality: Peek works for any data type, especially with Go generics.

Why it matters: Limiting peek to integers restricts code reuse and flexibility.

Expert Zone

1

Peek does not change the stack but can expose internal state that should not be modified externally.

2

Returning a boolean with peek is a Go idiom that prevents panics and improves error handling.

3

Using generics for peek avoids code duplication and ensures type safety across stack implementations.

When NOT to use

Peek is not suitable when you need to remove the top element; use pop instead. Also, if you need to inspect deeper elements, consider other data structures like queues or deques.

Production Patterns

Peek is used in parsing expressions to check the next operator, in undo systems to preview the last action, and in algorithms like depth-first search to inspect the current node without removing it.

Connections

Queue

Opposite data structure with first-in-first-out order.

Understanding peek in stacks helps contrast with peek in queues, which shows the front element, highlighting different access patterns.

Function Call Stack

Real-world system stack that uses peek to check the current function context.

Knowing peek helps understand how programming languages manage function calls and returns without removing frames prematurely.

Inventory Management

Stacks model last-in-first-out inventory usage, peek helps check the next item to use.

Seeing peek in stacks connects to real-world inventory where you check the top item without removing it, aiding planning and decision-making.

Common Pitfalls

#1 Trying to peek without checking if the stack is empty causes errors.

Wrong approach:

func Peek(stack []int) int {
return stack[len(stack)-1]
}

Correct approach:

func Peek(stack []int) (int, bool) {
if len(stack) == 0 {
return 0, false
}
return stack[len(stack)-1], true
}

Root cause:

Not handling empty stack cases leads to index out of range runtime errors.

#2 Modifying the stack inside peek, which should only read the top element.

Wrong approach:

func Peek(stack []int) (int, bool) {
if len(stack) == 0 {
return 0, false
}
val := stack[len(stack)-1]
stack = stack[:len(stack)-1] // wrong: removes element
return val, true
}

Correct approach:

func Peek(stack []int) (int, bool) {
if len(stack) == 0 {
return 0, false
}
return stack[len(stack)-1], true
}

Root cause:

Confusing peek with pop causes unintended stack modification.

#3 Writing separate peek functions for each data type without generics.

Wrong approach:

func PeekInt(stack []int) (int, bool) { ... }
func PeekString(stack []string) (string, bool) { ... }

Correct approach:

func Peek[T any](stack []T) (T, bool) { ... }

Root cause:

Not using generics leads to code duplication and maintenance issues.

Key Takeaways

Peek lets you see the top item of a stack without removing it, preserving the stack's state.

Always check if the stack is empty before peeking to avoid runtime errors.

In Go, slices represent stacks efficiently, and peek accesses the last element safely.

Using generics allows peek to work with any data type, improving code reuse.

Peek is a fast, safe operation essential for many algorithms and real-world applications.

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