Delete Node at End in DSA Java - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output after deleting last node from a singly linked list

What is the printed state of the linked list after deleting the last node?

DSA Java

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

class LinkedList {
    Node head;

    void deleteAtEnd() {
        if (head == null) return;
        if (head.next == null) {
            head = null;
            return;
        }
        Node temp = head;
        while (temp.next.next != null) {
            temp = temp.next;
        }
        temp.next = null;
    }

    void printList() {
        Node temp = head;
        while (temp != null) {
            System.out.print(temp.data + " -> ");
            temp = temp.next;
        }
        System.out.println("null");
    }

    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        list.head = new Node(10);
        list.head.next = new Node(20);
        list.head.next.next = new Node(30);
        list.deleteAtEnd();
        list.printList();
    }
}

A 10 -> 20 -> null

B 10 -> 20 -> 30 -> null

C 20 -> 30 -> null

D 10 -> null

💡 Hint

Think about how the last node is removed and what remains.

The method deleteAtEnd() removes the last node (30). The list after deletion is 10 -> 20 -> null.

❓ Predict Output

intermediate

Output after deleting last node from a single-node list

What is the printed state of the linked list after deleting the last node when the list has only one node?

DSA Java

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

class LinkedList {
    Node head;

    void deleteAtEnd() {
        if (head == null) return;
        if (head.next == null) {
            head = null;
            return;
        }
        Node temp = head;
        while (temp.next.next != null) {
            temp = temp.next;
        }
        temp.next = null;
    }

    void printList() {
        Node temp = head;
        while (temp != null) {
            System.out.print(temp.data + " -> ");
            temp = temp.next;
        }
        System.out.println("null");
    }

    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        list.head = new Node(100);
        list.deleteAtEnd();
        list.printList();
    }
}

A 100 -> null

B Error: NullPointerException

C null

D 100 -> 100 -> null

💡 Hint

Deleting the only node should leave the list empty.

Since the list has only one node, deleting the last node sets head to null, so the list is empty and prints null.

🔧 Debug

advanced

Identify the error in deleting last node from a linked list

What error will this code produce when deleting the last node from a list with two nodes?

DSA Java

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

class LinkedList {
    Node head;

    void deleteAtEnd() {
        if (head == null) return;
        Node temp = head;
        while (temp.next != null) {
            temp = temp.next;
        }
        temp = null;
    }

    void printList() {
        Node temp = head;
        while (temp != null) {
            System.out.print(temp.data + " -> ");
            temp = temp.next;
        }
        System.out.println("null");
    }

    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        list.head = new Node(1);
        list.head.next = new Node(2);
        list.deleteAtEnd();
        list.printList();
    }
}

A 1 -> 2 -> null

B 1 -> null

C NullPointerException

D Compilation error

💡 Hint

Check if the last node is actually removed from the list.

The code sets the local variable temp to null but does not change the previous node's next pointer. So the list remains unchanged.

🧠 Conceptual

advanced

Why is a previous pointer needed to delete the last node in singly linked list?

In a singly linked list, why do we need to keep track of the node before the last node to delete the last node?

A Because the last node stores the address of the previous node

B Because we need to set the previous node's next pointer to null to remove the last node

C Because the head pointer always points to the last node

D Because the last node cannot be accessed without a tail pointer

💡 Hint

Think about how links between nodes are updated when deleting.

In singly linked lists, nodes only know their next node. To remove the last node, we must update the previous node's next to null, so we need to track it.

🚀 Application

expert

Resulting list after multiple deletions at end

Given the list 5 -> 10 -> 15 -> 20 -> null, what is the printed list after deleting the last node three times?

DSA Java

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

class LinkedList {
    Node head;

    void deleteAtEnd() {
        if (head == null) return;
        if (head.next == null) {
            head = null;
            return;
        }
        Node temp = head;
        while (temp.next.next != null) {
            temp = temp.next;
        }
        temp.next = null;
    }

    void printList() {
        Node temp = head;
        while (temp != null) {
            System.out.print(temp.data + " -> ");
            temp = temp.next;
        }
        System.out.println("null");
    }

    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        list.head = new Node(5);
        list.head.next = new Node(10);
        list.head.next.next = new Node(15);
        list.head.next.next.next = new Node(20);
        list.deleteAtEnd();
        list.deleteAtEnd();
        list.deleteAtEnd();
        list.printList();
    }
}

A null

B 10 -> 15 -> 20 -> null

C 5 -> 10 -> null

D 5 -> null

💡 Hint

Each deletion removes the last node, so track the list after each step.

Deleting last node three times removes 20, then 15, then 10. The remaining list is 5 -> null.

Practice

1. What does the operation Delete Node at End do in a singly linked list?

easy

A. Removes the last node from the list

B. Removes the first node from the list

C. Adds a new node at the end of the list

D. Adds a new node at the beginning of the list

Solution

1. Step 1: Understand the operation meaning

   Deleting a node at the end means removing the last node in the linked list.

2. Step 2: Identify the correct description

   Removing the last node matches Removes the last node from the list, while others describe adding or removing nodes at different positions.

3. Final Answer:

   Removes the last node from the list -> Option A

4. Quick Check:

   Delete Node at End = Removes last node [OK]

Hint: Deleting at end always removes the last node [OK]

Common Mistakes:

• Confusing delete at end with delete at beginning
• Thinking it adds a node instead of removing
• Mixing up first and last node operations

2. Which of the following is the correct Java syntax to delete the last node in a singly linked list named list assuming you have a method deleteAtEnd()?

easy

A. list.deleteAtEnd();

B. deleteAtEnd.list();

C. list.deleteAtEnd;

D. list.deleteAtEnd[];

Solution

1. Step 1: Identify method call syntax in Java

   Calling a method on an object uses dot notation with parentheses: object.methodName();

2. Step 2: Match correct syntax

   list.deleteAtEnd(); uses correct syntax: list.deleteAtEnd(); others have syntax errors or wrong usage.

3. Final Answer:

   list.deleteAtEnd(); -> Option A

4. Quick Check:

   Method call syntax = object.method() [OK]

Hint: Method calls need parentheses after name [OK]

Common Mistakes:

• Omitting parentheses when calling methods
• Using brackets [] instead of parentheses ()
• Reversing object and method names

3. Consider the following Java code for a singly linked list:

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

class LinkedList {
  Node head;

  void deleteAtEnd() {
    if (head == null) return;
    if (head.next == null) {
      head = null;
      return;
    }
    Node temp = head;
    while (temp.next.next != null) {
      temp = temp.next;
    }
    temp.next = null;
  }

  void printList() {
    Node temp = head;
    while (temp != null) {
      System.out.print(temp.data + " -> ");
      temp = temp.next;
    }
    System.out.println("null");
  }
}

public class Main {
  public static void main(String[] args) {
    LinkedList list = new LinkedList();
    list.head = new Node(1);
    list.head.next = new Node(2);
    list.head.next.next = new Node(3);
    list.deleteAtEnd();
    list.printList();
  }
}

What is the output after running this code?

medium

A. 1 -> 2 -> 3 -> null

B. 1 -> 2 -> null

C. 2 -> 3 -> null

D. null

Solution

1. Step 1: Understand initial list and deleteAtEnd()

   The list starts as 1 -> 2 -> 3 -> null. The deleteAtEnd() removes the last node (3).

2. Step 2: Trace deleteAtEnd() method

   It traverses to node with data 2, sets its next to null, removing node 3.

3. Final Answer:

   1 -> 2 -> null -> Option B

4. Quick Check:

   Last node removed, list ends at 2 [OK]

Hint: Deleting end removes last node, list shortens by one [OK]

Common Mistakes:

• Forgetting to update the second last node's next to null
• Assuming head changes when list has multiple nodes
• Printing old list without deletion

4. The following Java method is intended to delete the last node of a singly linked list. What is the error?

void deleteAtEnd() {
  if (head == null) return;
  Node temp = head;
  while (temp.next != null) {
    temp = temp.next;
  }
  temp = null;
}

medium

A. It causes a NullPointerException

B. It does not handle empty list

C. It deletes the head node incorrectly

D. It does not update the second last node's next pointer

Solution

1. Step 1: Analyze the loop and pointer updates

   The loop moves temp to the last node (where temp.next is null). Setting temp = null only changes local pointer, not list links.

2. Step 2: Identify missing update to second last node

   The second last node's next pointer is not set to null, so the last node remains linked.

3. Final Answer:

   It does not update the second last node's next pointer -> Option D

4. Quick Check:

   Must update second last node's next to null [OK]

Hint: Set second last node's next to null, not just temp = null [OK]

Common Mistakes:

• Setting temp = null only changes local variable
• Not handling single-node list case
• Ignoring list head update if only one node

5. You have a singly linked list with nodes containing values: 10 -> 20 -> 30 -> 40 -> null. You want to delete the last node and then add a new node with value 50 at the end. Which sequence of operations correctly achieves this?

hard

A. Call addAtEnd(50) only

B. Call addAtEnd(50), then call deleteAtEnd()

C. Call deleteAtEnd(), then call addAtEnd(50)

D. Call deleteAtEnd() twice, then addAtEnd(50)

Solution

1. Step 1: Delete the last node

   Calling deleteAtEnd() removes node with value 40, list becomes 10 -> 20 -> 30 -> null.

2. Step 2: Add new node with value 50 at end

   Calling addAtEnd(50) appends node 50, list becomes 10 -> 20 -> 30 -> 50 -> null.

3. Final Answer:

   Call deleteAtEnd(), then call addAtEnd(50) -> Option C

4. Quick Check:

   Delete last, then add new node [OK]

Hint: Delete old last node before adding new one [OK]

Common Mistakes:

• Adding new node before deleting old last node
• Deleting twice unnecessarily
• Not deleting at all before adding