Pop Using Linked List Node in DSA Java - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output after popping the top node from the linked list?

Consider a singly linked list with nodes containing values 10 -> 20 -> 30 -> null. The pop operation removes the first node. What is the state of the list after pop?

DSA Java

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

class LinkedList {
    Node head;
    void push(int data) {
        Node newNode = new Node(data);
        newNode.next = head;
        head = newNode;
    }
    int pop() {
        if (head == null) return -1;
        int val = head.data;
        head = head.next;
        return val;
    }
    String printList() {
        StringBuilder sb = new StringBuilder();
        Node current = head;
        while (current != null) {
            sb.append(current.data).append(" -> ");
            current = current.next;
        }
        sb.append("null");
        return sb.toString();
    }
}

public class Main {
    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        list.push(30);
        list.push(20);
        list.push(10);
        list.pop();
        System.out.println(list.printList());
    }
}

A 20 -> 30 -> null

B 10 -> 20 -> 30 -> null

C null

D 30 -> 20 -> null

💡 Hint

Remember, pop removes the first node (head) from the list.

The list is built by pushing 30, then 20, then 10, so the list is 10 -> 20 -> 30 -> null. Popping removes the head node (10), so the new head is 20, resulting in 20 -> 30 -> null.

❓ Predict Output

intermediate

What is the output after popping twice from the linked list?

Given the same linked list built by pushing 30, 20, 10, what is the list state after two pop operations?

DSA Java

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

class LinkedList {
    Node head;
    void push(int data) {
        Node newNode = new Node(data);
        newNode.next = head;
        head = newNode;
    }
    int pop() {
        if (head == null) return -1;
        int val = head.data;
        head = head.next;
        return val;
    }
    String printList() {
        StringBuilder sb = new StringBuilder();
        Node current = head;
        while (current != null) {
            sb.append(current.data).append(" -> ");
            current = current.next;
        }
        sb.append("null");
        return sb.toString();
    }
}

public class Main {
    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        list.push(30);
        list.push(20);
        list.push(10);
        list.pop();
        list.pop();
        System.out.println(list.printList());
    }
}

A 30 -> null

B 20 -> 30 -> null

C 10 -> 30 -> null

D null

💡 Hint

Each pop removes the head node.

First pop removes 10, second pop removes 20, leaving 30 as the head node.

🔧 Debug

advanced

What error occurs when popping from an empty linked list?

Consider the pop method below. What happens if pop is called when the list is empty (head is null)?

DSA Java

int pop() {
    int val = head.data;
    head = head.next;
    return val;
}

A Compilation error

B No error, returns 0

C NullPointerException

D IndexOutOfBoundsException

💡 Hint

Accessing a field on a null object causes an error.

If head is null, accessing head.data causes a NullPointerException at runtime.

❓ Predict Output

advanced

What is the output after popping all nodes from the linked list?

Starting with a linked list built by pushing 1, 2, 3, 4, what is the list state after popping four times?

DSA Java

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

class LinkedList {
    Node head;
    void push(int data) {
        Node newNode = new Node(data);
        newNode.next = head;
        head = newNode;
    }
    int pop() {
        if (head == null) return -1;
        int val = head.data;
        head = head.next;
        return val;
    }
    String printList() {
        StringBuilder sb = new StringBuilder();
        Node current = head;
        while (current != null) {
            sb.append(current.data).append(" -> ");
            current = current.next;
        }
        sb.append("null");
        return sb.toString();
    }
}

public class Main {
    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        list.push(4);
        list.push(3);
        list.push(2);
        list.push(1);
        list.pop();
        list.pop();
        list.pop();
        list.pop();
        System.out.println(list.printList());
    }
}

A Error

B 1 -> 2 -> 3 -> 4 -> null

C 4 -> 3 -> 2 -> null

D null

💡 Hint

Popping all nodes empties the list.

After popping all four nodes, head becomes null, so the list is empty and prints null.

🧠 Conceptual

expert

What is the time complexity of the pop operation on a singly linked list?

Consider a singly linked list where pop removes the head node. What is the time complexity of pop in terms of number of nodes n?

A O(log n) logarithmic time

B O(1) constant time

C O(n) linear time

D O(n^2) quadratic time

💡 Hint

Pop removes the first node without traversal.

Pop removes the head node directly without traversing the list, so it runs in constant time O(1).

Practice

1. What does the pop() operation do in a linked list when implemented using nodes?

easy

A. Removes and returns the first node of the linked list

B. Adds a new node at the end of the linked list

C. Removes the last node without returning it

D. Returns the size of the linked list

Solution

1. Step 1: Understand pop operation in linked list context

   The pop operation removes the top element, which is the first node in a linked list acting like a stack.

2. Step 2: Identify what is returned

   Pop returns the value of the removed first node and updates the head pointer to the next node.

3. Final Answer:

   Removes and returns the first node of the linked list -> Option A

4. Quick Check:

   Pop = Remove first node [OK]

Hint: Pop removes the head node and returns it [OK]

Common Mistakes:

• Thinking pop removes the last node
• Confusing pop with push operation
• Assuming pop returns list size

2. Which of the following is the correct Java syntax to pop a node from the head of a singly linked list?

easy

A. head = head.next; return head.data;

B. Node temp = head; head = head.next; return temp.data;

C. Node temp = head.next; head = temp; return head.data;

D. return head.next.data; head = head.next;

Solution

1. Step 1: Check correct order of operations

   We must save the current head node in a temp variable before moving head to next.

2. Step 2: Return the data of the removed node

   Return the data from the saved temp node, not the new head.

3. Final Answer:

   Node temp = head; head = head.next; return temp.data; -> Option B

4. Quick Check:

   Save head, move head, return old data [OK]

Hint: Save head before moving it to next [OK]

Common Mistakes:

• Returning data from new head instead of old
• Not saving old head before moving
• Returning data before updating head

3. Given the linked list nodes: 10 -> 20 -> 30 -> null, what is the list after one pop operation using this code?

Node pop() {
  if (head == null) return null;
  Node temp = head;
  head = head.next;
  return temp;
}

medium

A. 30 -> null

B. 10 -> 20 -> 30 -> null

C. 20 -> 30 -> null

D. null

Solution

1. Step 1: Identify the node removed by pop()

   Pop removes the head node which has value 10.

2. Step 2: Update head to next node

   Head moves from 10 to 20, so list becomes 20 -> 30 -> null.

3. Final Answer:

   20 -> 30 -> null -> Option C

4. Quick Check:

   Pop removes first node 10 [OK]

Hint: Pop removes first node, head moves next [OK]

Common Mistakes:

• Assuming pop removes last node
• Not updating head pointer
• Returning old list unchanged

4. What is the error in this pop method for a singly linked list?

Node pop() {
  if (head == null) return null;
  Node temp = head.next;
  head = temp;
  return temp;
}

medium

A. It skips the first node and removes the second node instead

B. It causes a null pointer exception when list is empty

C. It returns the old head node instead of new head

D. It does not update the head pointer

Solution

1. Step 1: Analyze which node is assigned to temp

   Temp is assigned head.next, so the first node is skipped.

2. Step 2: Understand effect on head and return

   Head moves to second node, so first node is never removed; second node is removed instead.

3. Final Answer:

   It skips the first node and removes the second node instead -> Option A

4. Quick Check:

   Pop must remove first node, not second [OK]

Hint: Pop must save head, not head.next [OK]

Common Mistakes:

• Assigning temp to head.next instead of head
• Returning the new head instead of the old head
• Returning wrong node

5. You have a linked list: 5 -> 15 -> 25 -> 35 -> null. You perform two pop operations using this method:

Node pop() {
  if (head == null) return null;
  Node temp = head;
  head = head.next;
  return temp;
}

What is the state of the list after these two pops?

hard

A. null

B. 15 -> 25 -> 35 -> null

C. 35 -> null

D. 25 -> 35 -> null

Solution

1. Step 1: First pop removes 5

   After first pop, head moves from 5 to 15, list is 15 -> 25 -> 35 -> null.

2. Step 2: Second pop removes 15

   After second pop, head moves from 15 to 25, list is 25 -> 35 -> null.

3. Final Answer:

   25 -> 35 -> null -> Option D

4. Quick Check:

   Two pops remove first two nodes [OK]

Hint: Each pop removes head, moves head next [OK]

Common Mistakes:

• Removing last nodes instead of first
• Not updating head after each pop
• Confusing pop with push