Pop Operation on Stack in DSA Java

Mental Model

A stack removes the top item first, like taking the last plate from a stack of plates.

Analogy: Imagine a stack of plates; you always take the top plate off first when you need one.

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 show the new top

Step 1: Check if stack is empty

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

Why: We must ensure there is something to pop

Step 2: Save top element value (3) to return later

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

Why: We need to know which value is removed

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

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

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

Step 4: Return saved value (3)

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

Why: Pop operation returns the removed element

Result:

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

Annotated Code

DSA Java

class StackNode {
    int data;
    StackNode next;
    StackNode(int data) {
        this.data = data;
        this.next = null;
    }
}

class Stack {
    private StackNode top;

    public Stack() {
        this.top = null;
    }

    public void push(int data) {
        StackNode newNode = new StackNode(data);
        newNode.next = top; // link new node to current top
        top = newNode; // update top to new node
    }

    public int pop() {
        if (top == null) {
            throw new RuntimeException("Stack is empty"); // handle empty stack
        }
        int poppedData = top.data; // save top data
        top = top.next; // move top to next node
        return poppedData; // return popped value
    }

    public String toString() {
        StringBuilder sb = new StringBuilder();
        StackNode current = top;
        while (current != null) {
            sb.append(current.data).append(" -> ");
            current = current.next; // advance to next node
        }
        sb.append("null");
        return sb.toString();
    }
}

public class Main {
    public static void main(String[] args) {
        Stack stack = new Stack();
        stack.push(1);
        stack.push(2);
        stack.push(3);
        System.out.println("Stack before pop: " + stack);
        int popped = stack.pop();
        System.out.println("Popped value: " + popped);
        System.out.println("Stack after pop: " + stack);
    }
}

if (top == null) { throw new RuntimeException("Stack is empty"); }

check if stack is empty to avoid errors

int poppedData = top.data;

save the top element's value before removal

top = top.next;

move top pointer to next node to remove current top

return poppedData;

return the removed element's value

current = current.next;

advance through stack nodes to build string representation

Output

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

Popped value: 3

Stack after pop: 2 -> 1 -> null

Complexity Analysis

Time: O(1) because pop removes the top element directly without traversal

Space: O(n) for storing n elements in the stack nodes

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 throws an exception to signal no elements to remove

DSA Java

if (top == null) { throw new RuntimeException("Stack is empty"); }

single element stack

pop removes the only element and top becomes null

DSA Java

top = top.next;

When to Use This Pattern

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

Common Mistakes

Mistake: Not checking if the stack is empty before popping
Fix: Add a check for empty stack and handle it (e.g., throw exception)

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

Summary

Removes and returns the top element from the stack.

Use when you need to process elements in reverse order of insertion.

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

Practice

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

easy

A. Removes and returns the top element of the stack

B. Adds an element to the bottom of the stack

C. Returns the bottom element without removing it

D. Checks if the stack is empty

Solution

1. Step 1: Understand the stack structure

   A stack follows Last In First Out (LIFO) principle, so operations affect the top element.

2. Step 2: Define pop operation

   The pop() removes and returns the top element from the stack.

3. Final Answer:

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

4. Quick Check:

   pop() removes top element [OK]

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

Common Mistakes:

• Thinking pop adds elements
• Confusing pop with peek
• Assuming pop removes bottom element

2. Which of the following is the correct syntax to pop an element from a stack named stack in Java?

easy

A. stack.pop();

B. pop(stack);

C. stack.remove();

D. pop();

Solution

1. Step 1: Recall Java Stack method syntax

   In Java, pop() is a method called on the stack object.

2. Step 2: Identify correct method call

   The correct syntax is calling pop() on the stack instance: stack.pop();

3. Final Answer:

   stack.pop(); -> Option A

4. Quick Check:

   Method call on object = stack.pop() [OK]

Hint: Pop is called as a method on the stack object [OK]

Common Mistakes:

• Using pop() without object
• Using remove() instead of pop()
• Passing stack as argument to pop

3. What will be the output after executing the following Java code?

Stack<Integer> stack = new Stack<>();
stack.push(10);
stack.push(20);
stack.push(30);
int popped = stack.pop();
System.out.println(popped);
System.out.println(stack);

medium

A. 30
[20, 10]

B. 10
[20, 30]

C. 20
[10, 30]

D. 30
[10, 20]

Solution

1. Step 1: Trace push operations

   Elements pushed in order: 10, then 20, then 30. Stack top is 30.

2. Step 2: Apply pop operation

   Pop removes top element 30, so popped = 30. Remaining stack is [10, 20].

3. Final Answer:

   30 [10, 20] -> Option D

4. Quick Check:

   pop() returns last pushed = 30 [OK]

Hint: Pop returns last pushed element, stack shrinks from top [OK]

Common Mistakes:

• Confusing order of elements after pop
• Printing popped element incorrectly
• Assuming pop removes bottom element

4. Consider this Java code snippet:

Stack<String> stack = new Stack<>();
stack.push("A");
stack.push("B");
stack.pop();
stack.pop();
stack.pop();

What error will occur when running this code?

medium

A. No error, code runs fine

B. EmptyStackException at third pop

C. NullPointerException at second pop

D. IndexOutOfBoundsException at first pop

Solution

1. Step 1: Count push and pop calls

   Two elements pushed: "A", "B". Then three pops called.

2. Step 2: Identify error on extra pop

   First two pops remove "B" and "A". Third pop tries to remove from empty stack causing EmptyStackException.

3. Final Answer:

   EmptyStackException at third pop -> Option B

4. Quick Check:

   Pop on empty stack throws EmptyStackException [OK]

Hint: Popping empty stack causes EmptyStackException [OK]

Common Mistakes:

• Assuming pop returns null on empty stack
• Confusing exception types
• Ignoring extra pop call

5. You have a stack with elements [5, 10, 15, 20] (5 at bottom, 20 at top). You perform two pop operations, then push 25, then pop once. What is the final stack content?

hard

A. [5, 10, 25]

B. [5, 10, 15]

C. [5, 10]

D. [5, 10, 15, 25]

Solution

1. Step 1: Perform two pop operations

   Initial stack: bottom 5,10,15, top 20. First pop removes 20, second pop removes 15. Stack now: [5, 10].

2. Step 2: Push 25 and pop once

   Push 25: stack becomes [5, 10, 25]. Pop removes 25, stack returns to [5, 10].

3. Step 3: Verify final stack

   Final stack is [5, 10].

4. Final Answer:

   [5, 10] -> Option C

5. Quick Check:

   Pop removes top, push adds top [OK]

Hint: Track pushes and pops stepwise to find final stack [OK]

Common Mistakes:

• Forgetting last pop removes pushed element
• Mixing order of elements
• Assuming push adds at bottom