DSA Javaprogramming

Delete Node at Specific Position in DSA Java

Choose your learning style10 modes available

Learn Why Deep Visual Try Challenge Project Recall Time

Mental Model

To remove a node from a linked list, find the node just before it and change its pointer to skip the node to delete.

Analogy: Imagine a chain of paper clips linked together. To remove one clip in the middle, you unhook the clip before it and link it directly to the clip after the one you want to remove.

head -> 1 -> 2 -> 3 -> 4 -> null

Dry Run Walkthrough

Input: list: 1 -> 2 -> 3 -> 4 -> null, delete node at position 3

Goal: Remove the node at position 3 (value 3) and keep the list connected

Step 1: Check if position is 1 (head), it is not, so proceed

head -> 1 -> 2 -> 3 -> 4 -> null

Why: We only change head if deleting first node

Step 2: Move to node before position 3, which is node 2

head -> 1 -> [curr->2] -> 3 -> 4 -> null

Why: We need the node before the one to delete to change its pointer

Step 3: Change curr.next to skip node 3 and point to node 4

head -> 1 -> 2 -> 4 -> null

Why: Skipping node 3 removes it from the list

Result:

head -> 1 -> 2 -> 4 -> null

Annotated Code

DSA Java

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

public class DeleteNodeAtPosition {
    static Node deleteAtPosition(Node head, int position) {
        if (head == null) return null; // empty list
        if (position == 1) {
            return head.next; // remove head
        }
        Node curr = head;
        for (int i = 1; i < position - 1; i++) {
            if (curr.next == null) return head; // position out of bounds
            curr = curr.next; // move to node before target
        }
        if (curr.next != null) {
            curr.next = curr.next.next; // skip target node
        }
        return head;
    }

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

    public static void main(String[] args) {
        Node head = new Node(1);
        head.next = new Node(2);
        head.next.next = new Node(3);
        head.next.next.next = new Node(4);

        System.out.print("Original list: ");
        printList(head);

        int position = 3;
        head = deleteAtPosition(head, position);

        System.out.print("After deleting position " + position + ": ");
        printList(head);
    }
}

if (head == null) return null; // empty list

handle empty list edge case

if (position == 1) {
    return head.next; // remove head
}

remove first node by returning second node as new head

for (int i = 1; i < position - 1; i++) {
    if (curr.next == null) return head; // position out of bounds
    curr = curr.next; // move to node before target
}

move to node before the one to delete, stop if position invalid

if (curr.next != null) {
    curr.next = curr.next.next; // skip target node
}

skip the node at position by linking previous node to next of target

OutputSuccess

Original list: 1 -> 2 -> 3 -> 4 -> null After deleting position 3: 1 -> 2 -> 4 -> null

Complexity Analysis

Time: O(n) because we may need to traverse up to n nodes to reach the position

Space: O(1) because we only use a few pointers and no extra data structures

vs Alternative: Compared to rebuilding the list or using arrays, this is efficient as it changes pointers directly without copying

Edge Cases

empty list

returns null without error

DSA Java

if (head == null) return null; // empty list

delete head node (position 1)

head moves to next node

DSA Java

if (position == 1) {
    return head.next; // remove head
}

position out of bounds (greater than list length)

list remains unchanged

DSA Java

if (curr.next == null) return head; // position out of bounds

When to Use This Pattern

When you need to remove an element from a linked list at a given position, use this pattern to adjust pointers and keep the list connected.

Common Mistakes

Mistake: Not handling deletion of the head node separately
Fix: Add a check for position 1 and return head.next to update the head

Mistake: Not checking if position is out of bounds causing null pointer errors
Fix: Check if curr.next is null before moving forward and return original head if position invalid

Mistake: Changing the pointer of the node to delete instead of the previous node
Fix: Always change the next pointer of the node before the one to delete

Summary

Deletes a node at a specific position by changing pointers to skip it.

Use when you want to remove an element from anywhere in a linked list by position.

The key is to find the node before the target and link it to the node after the target.

Practice

(1/5)

1. What happens when you delete a node at position 1 in a singly linked list?

easy

A. The list remains unchanged

B. The last node is removed

C. The head node is removed and the next node becomes the new head

D. All nodes are deleted

Recommended

Ready to prove it?

Pass the test and this pattern moves unknown strong while earning +1 Grip toward your certificate.

10 questions~5 mineasy hard

Delete Node at Specific Position in DSA Java

Practice

Solution

Step 1: Understand position 1 in linked list

Step 2: Delete the head node

Final Answer:

Quick Check:

Solution

Step 1: Check deletion at position 1

Step 2: Validate syntax correctness

Final Answer:

Quick Check:

Solution

Step 1: Identify node at position 3

Step 2: Remove node 30 and link previous to next

Final Answer:

Quick Check:

Solution

Step 1: Analyze loop for pos = 1

Step 2: Access temp.next when pos=1

Final Answer:

Quick Check:

Solution

Step 1: Delete node at position 5

Step 2: Delete node at position 1

Step 3: Delete node at position 2

Final Answer:

Quick Check:

Ready to prove it?