Pop Operation on Stack in DSA Go

Mental Model

A stack is like a pile of plates where you only take the top plate off. Pop removes the top item from the stack.

Analogy: Imagine a stack of books on a table. You can only remove the book on the top, not the ones below it.

Top -> [3] -> [2] -> [1] -> null
          ↑

Dry Run Walkthrough

Input: stack: 1 -> 2 -> 3 (top is 3), pop operation

Goal: Remove the top element (3) from the stack and update the top pointer

Step 1: Check if stack is empty

Top -> [3] -> [2] -> [1] -> null

Why: We must ensure there is something to pop

Step 2: Save the top node (3) to remove

Top -> [3] -> [2] -> [1] -> null

Why: We need to return or use the popped value

Step 3: Move top pointer to next node (2)

Top -> [2] -> [1] -> null

Why: Removing the top means the next node becomes the new top

Step 4: Return popped value 3

Top -> [2] -> [1] -> null

Why: Pop operation returns the removed top element

Result:

Top -> [2] -> [1] -> null
Popped value: 3

Annotated Code

DSA Go

package main

import "fmt"

type Node struct {
	value int
	next  *Node
}

type Stack struct {
	top *Node
}

func (s *Stack) Push(val int) {
	newNode := &Node{value: val, next: s.top}
	s.top = newNode
}

func (s *Stack) Pop() (int, bool) {
	if s.top == nil {
		return 0, false // stack empty
	}
	poppedValue := s.top.value
	s.top = s.top.next // move top down
	return poppedValue, true
}

func (s *Stack) Print() {
	curr := s.top
	for curr != nil {
		fmt.Printf("%d -> ", curr.value)
		curr = curr.next
	}
	fmt.Println("null")
}

func main() {
	stack := &Stack{}
	stack.Push(1)
	stack.Push(2)
	stack.Push(3)

	fmt.Print("Stack before pop: ")
	stack.Print()

	val, ok := stack.Pop()
	if ok {
		fmt.Printf("Popped value: %d\n", val)
	} else {
		fmt.Println("Stack is empty, cannot pop")
	}

	fmt.Print("Stack after pop: ")
	stack.Print()
}

if s.top == nil {

check if stack is empty to avoid popping from empty stack

poppedValue := s.top.value

save the top value to return after pop

s.top = s.top.next // move top down

update top pointer to next node, effectively removing the top

return poppedValue, true

return the popped value and success flag

Output

Stack before pop: 3 -> 2 -> 1 -> null

Popped value: 3

Stack after pop: 2 -> 1 -> null

Complexity Analysis

Time: O(1) because pop only changes the top pointer without traversing the stack

Space: O(1) because no extra space is used during pop operation

vs Alternative: Compared to arrays where removing last element is O(1), linked list stack pop is also O(1) but avoids resizing overhead

Edge Cases

empty stack

pop returns false and zero value, no crash

DSA Go

if s.top == nil {

stack with one element

pop removes the only element and top becomes nil

DSA Go

s.top = s.top.next // move top down

When to Use This Pattern

When you see a problem requiring last-in-first-out removal, reach for the stack pop pattern because it efficiently removes the top element in constant time.

Common Mistakes

Mistake: Not checking if the stack is empty before popping
Fix: Add a check for empty stack (top == nil) before removing the top

Mistake: Not updating the top pointer after pop
Fix: Set top to top.next to remove the top node

Summary

Removes the top element from the stack and returns it.

Use when you need to retrieve and remove the most recently added item.

The key is to move the top pointer down to the next node to remove the current top.

Practice

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

easy

A. Clears all elements from the stack

B. Adds an element to the bottom of the stack

C. Returns the bottom element without removing it

D. Removes and returns the top element of the stack

Solution

1. Step 1: Understand stack behavior

   A stack follows Last In First Out (LIFO) principle, so the last added element is removed first.

2. Step 2: Define pop operation

   The pop operation removes and returns the top element of the stack, which is the last inserted item.

3. Final Answer:

   Removes and returns the top element of the stack -> Option D

4. Quick Check:

   Pop = remove top element [OK]

Hint: Pop always removes the last added item from the stack [OK]

Common Mistakes:

• Thinking pop removes from bottom
• Confusing pop with peek
• Assuming pop clears the stack

2. Which of the following is the correct Go syntax to pop an element from a stack represented as a slice named stack?

easy

A. element := stack[0]; stack = stack[1:]

B. element := stack[len(stack)-1]; stack = stack[:len(stack)-1]

C. element := stack[len(stack)]; stack = stack[:len(stack)-1]

D. element := stack[len(stack)-1]; stack = stack[1:]

Solution

1. Step 1: Identify top element index in slice

   In Go, the top of the stack is the last element: index len(stack)-1.

2. Step 2: Correctly slice to remove top element

   To pop, get element at len(stack)-1, then slice stack up to len(stack)-1 to remove it.

3. Final Answer:

   element := stack[len(stack)-1]; stack = stack[:len(stack)-1] -> Option B

4. Quick Check:

   Pop syntax = element last, slice off last [OK]

Hint: Pop last element with slice[:len(slice)-1] [OK]

Common Mistakes:

• Using index len(stack) which is out of range
• Removing from front instead of end
• Not updating the stack slice after pop

3. What is the output of the following Go code?

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

medium

A. 30
[10 20]

B. 20
[10 20 30]

C. 30
[10 20 30]

D. 10
[20 30]

Solution

1. Step 1: Identify popped element

   element = stack[len(stack)-1] = stack[2] = 30

2. Step 2: Update stack after pop

   stack = stack[:2] = [10, 20]

3. Final Answer:

   30 [10 20] -> Option A

4. Quick Check:

   Pop returns 30, stack left [10 20] [OK]

Hint: Pop returns last element, stack shrinks by one [OK]

Common Mistakes:

• Printing old stack without slicing
• Confusing index for popped element
• Not updating stack slice after pop

4. Consider this Go code snippet for popping from a stack:

stack := []int{5, 15, 25}
element := stack[len(stack)]
stack = stack[:len(stack)-1]
fmt.Println(element)

What is the error in this code?

medium

A. Index out of range error due to accessing stack[len(stack)]

B. Stack slice is not updated correctly after pop

C. Variable element is not declared

D. No error, code runs fine

Solution

1. Step 1: Check index used for popping

   Accessing stack[len(stack)] is invalid because slice indices go from 0 to len(stack)-1.

2. Step 2: Identify runtime error

   This causes an index out of range runtime error when trying to access stack[len(stack)].

3. Final Answer:

   Index out of range error due to accessing stack[len(stack)] -> Option A

4. Quick Check:

   Index must be len(stack)-1, not len(stack) [OK]

Hint: Slice indices max at len(slice)-1, not len(slice) [OK]

Common Mistakes:

• Using len(stack) as index
• Ignoring runtime errors
• Assuming slice indexing is inclusive of len

5. You have a stack implemented as a slice in Go: stack := []int{1, 2, 3, 4, 5}. You want to pop two elements and then push 10 and 20. What will be the final stack?

hard

A. [10 20]

B. [1 2 3 4 5 10 20]

C. [1 2 3 10 20]

D. [1 2 10 20]

Solution

1. Step 1: Pop two elements from stack

   Pop removes last two elements: 5 and 4. Stack becomes [1, 2, 3].

2. Step 2: Push 10 and 20 onto stack

   Appending 10 and 20 results in [1, 2, 3, 10, 20].

3. Final Answer:

   [1 2 3 10 20] -> Option C

4. Quick Check:

   Pop twice, then push twice = [1 2 3 10 20] [OK]

Hint: Pop removes last; push adds at end [OK]

Common Mistakes:

• Not popping twice before pushing
• Appending instead of replacing popped elements
• Confusing order of push and pop