Why Peek Top Element of Stack in DSA Go?

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 all the books to find out, it would be slow and messy.

The Problem

Manually removing each book to see the top one wastes time and risks messing up the order. It's easy to lose track or drop books, causing errors and frustration.

The Solution

The peek operation lets you look at the top item instantly without changing the stack. It's like glancing at the top book's cover without moving anything, saving time and keeping everything neat.

Before vs After

✗ Before

if len(stack) > 0 {
    top := stack[len(stack)-1]
    stack = stack[:len(stack)-1] // removing top to see it
    fmt.Println(top)
    stack = append(stack, top) // putting it back
}

✓ After

if len(stack) > 0 {
    top := stack[len(stack)-1] // peek without removing
    fmt.Println(top)
}

What It Enables

Peek makes it easy to check the current top item quickly without disturbing the stack's order.

Real Life Example

When using a web browser's back button, peek helps check the last visited page without leaving it, so you can decide if you want to go back.

Key Takeaways

Manual checking of the top element is slow and risky.

Peek lets you see the top instantly without removing it.

This keeps the stack safe and operations efficient.

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