Peek Top Element of Stack in DSA Go - Build from Scratch

Peek Top Element of Stack

📖 Scenario: You are building a simple program to manage a stack of books. You want to see which book is currently on top without removing it.

🎯 Goal: Create a stack using a slice, add some books, then peek at the top book without removing it.

📋 What You'll Learn

Create a stack as a slice of strings with exact book titles

Add a variable to hold the top book

Write code to peek the top book from the stack

Print the top book

💡 Why This Matters

🌍 Real World

Stacks are used in many programs like undo features, browser history, and expression evaluation.

💼 Career

Understanding stack operations is essential for software development and technical interviews.

1

Create the stack with books

Create a slice of strings called stack with these exact book titles in order: "Math", "Science", "History"

DSA Go

# Create a slice called stack with "Math", "Science", "History"
# Your code here

Hint

Use a slice literal with the exact book titles in the given order.

2

Add a variable to hold the top book

Add a variable called topBook of type string to hold the top book from the stack

DSA Go

package main

func main() {
    stack := []string{"Math", "Science", "History"}
    // Declare a variable topBook of type string
    // Your code here
}

Hint

Use var topBook string to declare the variable.

3

Peek the top book from the stack

Assign the last element of stack to topBook to peek the top book without removing it

DSA Go

package main

func main() {
    stack := []string{"Math", "Science", "History"}
    var topBook string
    // Assign the last element of stack to topBook
    // Your code here
}

Hint

Use stack[len(stack)-1] to get the last element.

4

Print the top book

Print the value of topBook using fmt.Println

DSA Go

package main

import "fmt"

func main() {
    stack := []string{"Math", "Science", "History"}
    var topBook string
    topBook = stack[len(stack)-1]
    // Print topBook
    // Your code here
}

Hint

Use fmt.Println(topBook) to print the top book.

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