Delete Node at Specific Position in DSA Java - Deep Dive

Overview - Delete Node at Specific Position

What is it?

Deleting a node at a specific position means removing an element from a linked list at the exact place you choose. A linked list is a chain of connected nodes, each holding data and a link to the next node. When you delete a node, you change the links so the chain stays connected without the removed node. This operation helps manage data efficiently by removing unwanted elements from anywhere in the list.

Why it matters

Without the ability to delete nodes at specific positions, managing data in linked lists would be rigid and inefficient. You would have to remove nodes only from the start or end, limiting flexibility. This would make many programs slower or more complex, especially when dealing with dynamic data like playlists, task lists, or navigation paths. Being able to delete nodes anywhere keeps data structures flexible and responsive to real-world needs.

Where it fits

Before learning this, you should understand what linked lists are and how they work, including basic operations like traversal and insertion. After mastering deletion at specific positions, you can explore more complex linked list types like doubly linked lists or circular linked lists, and advanced operations like reversing or sorting linked lists.

Mental Model

Core Idea

Deleting a node at a specific position means carefully changing the links around that node so it is removed without breaking the chain.

Think of it like...

Imagine a paper chain made of loops linked together. To remove one loop in the middle, you open the loop before it and connect it directly to the loop after it, so the chain stays whole without the removed loop.

Head -> [Node1] -> [Node2] -> [Node3] -> [Node4] -> null

To delete Node3:
Head -> [Node1] -> [Node2] --------> [Node4] -> null
(Node3 is removed by linking Node2 directly to Node4)

Build-Up - 7 Steps

1

Foundation

Understanding Linked List Structure

Concept: Learn what a linked list node is and how nodes connect.

A linked list is made of nodes. Each node has two parts: data and a pointer to the next node. The first node is called the head. The last node points to null, meaning the end of the list. You can move through the list by following these pointers from one node to the next.

Result

You can visualize a chain of nodes connected by pointers, starting at head and ending at null.

Understanding the basic structure of nodes and pointers is essential before changing the list by deleting nodes.

2

Foundation

Traversing to a Specific Position

Concept: Learn how to move through the list to find the node before the one to delete.

To delete a node at position 'pos', you first move from the head node, step by step, until you reach the node just before 'pos'. For example, to delete the 3rd node, you stop at the 2nd node. This is because you need to change the pointer of the previous node to skip the node at 'pos'.

Result

You can reach any node's previous node by moving through the list stepwise.

Knowing how to reach the node before the target is key to safely removing a node without breaking the list.

3

Intermediate

Deleting the Head Node

🤔Before reading on: Do you think deleting the first node requires changing the head pointer or just the next pointer? Commit to your answer.

Concept: Deleting the first node means changing the head pointer to the second node.

If the position to delete is 1 (the head), you simply move the head pointer to the next node. The old head node is then removed or ignored. This is a special case because the head pointer itself changes.

Result

The list starts from the second node, effectively removing the first node.

Recognizing the head node as a special case prevents errors and keeps the list accessible after deletion.

4

Intermediate

Deleting a Middle or Last Node

🤔Before reading on: When deleting a node in the middle, do you think you need to delete the node first or adjust pointers first? Commit to your answer.

Concept: To delete a node in the middle or end, adjust the previous node's pointer to skip the target node.

After reaching the node before the one to delete, change its next pointer to point to the node after the target node. This removes the target node from the chain. If the target is the last node, set the previous node's next pointer to null.

Result

The target node is removed, and the list remains connected without it.

Adjusting pointers before deleting nodes ensures the list stays intact and prevents losing access to remaining nodes.

5

Intermediate

Handling Invalid Positions

🤔Before reading on: What should happen if the position to delete is larger than the list length? Commit to your answer.

Concept: Check if the position is valid before attempting deletion to avoid errors.

If the position is less than 1 or greater than the number of nodes, do not delete anything. You can return the list as is or show an error message. This prevents trying to delete a node that doesn't exist.

Result

The list remains unchanged if the position is invalid.

Validating input positions protects the program from crashes and unexpected behavior.

6

Advanced

Java Code for Deletion at Position

🤔Before reading on: Do you think the code needs to handle the head deletion separately or can one code block handle all cases? Commit to your answer.

Concept: Implement deletion logic in Java handling all cases: head, middle, last, and invalid positions.

public class LinkedList { Node head; static class Node { int data; Node next; Node(int d) { data = d; next = null; } } public void deleteAtPosition(int position) { if (head == null || position < 1) return; if (position == 1) { head = head.next; return; } Node current = head; for (int i = 1; current != null && i < position - 1; i++) { current = current.next; } if (current == null || current.next == null) return; current.next = current.next.next; } public 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.head.next.next = new Node(3); list.head.next.next.next = new Node(4); list.printList(); list.deleteAtPosition(3); list.printList(); list.deleteAtPosition(1); list.printList(); list.deleteAtPosition(10); list.printList(); } }

Result

Initial list: 1 -> 2 -> 3 -> 4 -> null After deleting position 3: 1 -> 2 -> 4 -> null After deleting position 1: 2 -> 4 -> null After deleting invalid position 10: 2 -> 4 -> null

Seeing the full code helps connect theory to practice and shows how to handle all cases cleanly.

7

Expert

Edge Cases and Performance Considerations

🤔Before reading on: Do you think deleting nodes in a singly linked list is always O(n) time? Commit to your answer.

Concept: Understand edge cases like empty lists, single-node lists, and the time complexity of deletion.

Deleting a node at a specific position in a singly linked list requires traversing nodes up to that position, which takes O(n) time in the worst case. Special cases include deleting from an empty list (no action), deleting the only node (head becomes null), and deleting the last node (previous node's next set to null). Optimizations or different data structures like doubly linked lists can improve some operations.

Result

You know when deletion is fast or slow and how to handle tricky cases safely.

Understanding time complexity and edge cases prepares you for real-world scenarios and guides choosing the right data structure.

Under the Hood

Internally, a linked list node holds a reference (pointer) to the next node. Deleting a node means changing the previous node's pointer to skip the target node and point to the next node instead. The removed node is then no longer reachable and can be cleaned up by the system's memory management. The head pointer is special because it marks the start of the list and must be updated if the first node is deleted.

Why designed this way?

Linked lists were designed to allow dynamic memory use and easy insertion or deletion without shifting elements like arrays. The pointer-based structure lets you change connections between nodes quickly. Deletion at a specific position requires pointer updates to maintain the chain. Alternatives like arrays require moving many elements, which is slower. This design balances flexibility and performance.

┌───────┐     ┌───────┐     ┌───────┐     ┌───────┐
│ Head  │ --> │ Node1 │ --> │ Node2 │ --> │ Node3 │ --> null
└───────┘     └───────┘     └───────┘     └───────┘

To delete Node2:

Change Node1's next pointer:
Node1.next = Node2.next (which is Node3)

Result:
Head -> Node1 -> Node3 -> null

Myth Busters - 3 Common Misconceptions

Quick: Does deleting a node automatically delete its data from memory? Commit to yes or no.

Common Belief: Deleting a node removes its data from memory immediately.

Reality: Deleting a node only removes references to it; actual memory cleanup depends on the system's garbage collector or manual deallocation.

Why it matters: Assuming immediate memory cleanup can cause memory leaks or dangling pointers in languages without automatic garbage collection.

Quick: Can you delete a node without knowing the previous node in a singly linked list? Commit to yes or no.

Common Belief: You can delete any node directly if you have a pointer to it, without needing the previous node.

Reality: In singly linked lists, you must know the previous node to change its next pointer; otherwise, you cannot remove the target node safely.

Why it matters: Trying to delete without the previous node leads to broken links and lost parts of the list.

Quick: Is deleting the last node in a singly linked list as simple as setting its pointer to null? Commit to yes or no.

Common Belief: You can delete the last node by setting its pointer to null.

Reality: You must update the previous node's next pointer to null; the last node itself does not have a pointer to change.

Why it matters: Misunderstanding this causes the list to still reference the deleted node, leading to errors.

Expert Zone

1

Deleting nodes in a singly linked list always requires traversal from the head, which can be costly for large lists; caching previous nodes or using doubly linked lists can optimize this.

2

When deleting nodes in multi-threaded environments, synchronization is crucial to avoid corrupting the list during concurrent modifications.

3

In languages without garbage collection, failing to free the deleted node's memory causes memory leaks, so manual deallocation is necessary.

When NOT to use

Deleting nodes at specific positions in singly linked lists is inefficient for frequent random deletions; arrays or balanced trees may be better. For fast deletions anywhere, doubly linked lists or skip lists are preferred.

Production Patterns

In real systems, deletion at position is often combined with search or condition checks. For example, removing expired sessions from a linked list or deleting tasks by priority. Efficient implementations handle edge cases and avoid memory leaks, often using helper functions or sentinel nodes.

Connections

Doubly Linked List

Builds-on

Understanding deletion in singly linked lists helps grasp how doubly linked lists simplify deletion by having backward pointers, removing the need to find the previous node.

Garbage Collection

Depends-on

Knowing how deletion removes references but relies on garbage collection clarifies memory management differences between languages like Java and C.

Supply Chain Management

Analogous process

Deleting a node in a linked list is like removing a supplier from a supply chain by rerouting orders directly to the next supplier, ensuring the chain stays intact without disruption.

Common Pitfalls

#1 Trying to delete a node without checking if the position is valid.

Wrong approach:

public void deleteAtPosition(int position) {
Node current = head;
for (int i = 1; i < position - 1; i++) {
current = current.next;
}
current.next = current.next.next;
}

Correct approach:

public void deleteAtPosition(int position) {
if (head == null || position < 1) return;
if (position == 1) {
head = head.next;
return;
}
Node current = head;
for (int i = 1; current != null && i < position - 1; i++) {
current = current.next;
}
if (current == null || current.next == null) return;
current.next = current.next.next;
}

Root cause:

Not validating position leads to null pointer exceptions or crashes when position is out of range.

#2 Deleting the head node like any other node without updating the head pointer.

Wrong approach:

public void deleteAtPosition(int position) {
Node current = head;
for (int i = 1; i < position - 1; i++) {
current = current.next;
}
current.next = current.next.next;
}

Correct approach:

public void deleteAtPosition(int position) {
if (position == 1) {
head = head.next;
return;
}
Node current = head;
for (int i = 1; current != null && i < position - 1; i++) {
current = current.next;
}
if (current == null || current.next == null) return;
current.next = current.next.next;
}

Root cause:

Treating head deletion like other nodes ignores that head pointer must be updated to keep list accessible.

#3 Assuming deleting a node frees its memory immediately in Java.

Wrong approach:

public void deleteAtPosition(int position) {
// delete node
// assume memory freed immediately
}

Correct approach:

public void deleteAtPosition(int position) {
// remove references to node
// rely on Java garbage collector to free memory
}

Root cause:

Misunderstanding Java's memory management leads to incorrect assumptions about resource cleanup.

Key Takeaways

Deleting a node at a specific position in a linked list means changing pointers to remove the node without breaking the chain.

The head node is a special case because deleting it requires updating the head pointer itself.

Always validate the position before deletion to avoid errors or crashes.

In singly linked lists, you must find the previous node to delete a target node safely.

Understanding deletion helps choose the right data structure and write robust, efficient code.

Practice

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

Solution

1. Step 1: Understand position 1 in linked list

   Position 1 refers to the head node of the list.

2. Step 2: Delete the head node

   Removing the head means the next node becomes the new head.

3. Final Answer:

   The head node is removed and the next node becomes the new head -> Option C

4. Quick Check:

   Deleting position 1 removes head [OK]

Hint: Deleting position 1 means removing the head node [OK]

Common Mistakes:

• Thinking position 1 means last node
• Assuming list stays same after deletion
• Deleting all nodes instead of one

2. Which of the following is the correct Java syntax to delete a node at position pos in a singly linked list starting with head?

easy

A. if (pos == 1) head = head.next;

B. head = head.next.next;

C. head.next = null;

D. head = null;

Solution

1. Step 1: Check deletion at position 1

   If position is 1, we remove the head by pointing head to head.next.

2. Step 2: Validate syntax correctness

   if (pos == 1) head = head.next; correctly assigns head = head.next; others either skip nodes or nullify incorrectly.

3. Final Answer:

   if (pos == 1) head = head.next; -> Option A

4. Quick Check:

   Correct syntax for deleting head node [OK]

Hint: Deleting head means head = head.next [OK]

Common Mistakes:

• Skipping two nodes instead of one
• Setting head.next to null incorrectly
• Setting entire head to null without condition

3. Given the linked list: 10 -> 20 -> 30 -> 40 -> null, what is the list after deleting the node at position 3?

medium

A. 10 -> 20 -> 40 -> null

B. 10 -> 30 -> 40 -> null

C. 20 -> 30 -> 40 -> null

D. 10 -> 20 -> 30 -> null

Solution

1. Step 1: Identify node at position 3

   Position 3 node is 30 in the list 10 -> 20 -> 30 -> 40 -> null.

2. Step 2: Remove node 30 and link previous to next

   Link node 20's next to node 40, skipping 30.

3. Final Answer:

   10 -> 20 -> 40 -> null -> Option A

4. Quick Check:

   Deleted 3rd node 30 correctly [OK]

Hint: Skip the node at position by linking previous to next [OK]

Common Mistakes:

• Deleting wrong node position
• Not updating previous node's next pointer
• Removing head instead of position 3

4. Consider this code snippet to delete a node at position pos in a singly linked list:

Node temp = head;
for (int i = 1; i < pos - 1; i++) {
    temp = temp.next;
}
temp.next = temp.next.next;

What error can occur if pos is 1?

medium

A. ArrayIndexOutOfBoundsException

B. NullPointerException because temp.next is null

C. The head node is deleted correctly

D. No error, deletion works fine

Solution

1. Step 1: Analyze loop for pos = 1

   Loop runs from i=1 to pos-2 = -1, so it does not run; temp = head.

2. Step 2: Access temp.next when pos=1

   temp.next is head.next, but deletion logic expects previous node; deleting head this way causes NullPointerException.

3. Final Answer:

   NullPointerException because temp.next is null -> Option B

4. Quick Check:

   Deleting position 1 needs special handling [OK]

Hint: Deleting head needs separate code; loop fails for pos=1 [OK]

Common Mistakes:

• Assuming loop runs for pos=1
• Not handling head deletion separately
• Expecting no error for pos=1

5. You have a singly linked list: 5 -> 10 -> 15 -> 20 -> 25 -> null. Write the resulting list after deleting the node at position 5, then position 1, and finally position 2 in that order.

hard

A. 10 -> 20 -> 25 -> null

B. 10 -> 15 -> 25 -> null

C. 5 -> 15 -> 20 -> 25 -> null

D. 10 -> 20 -> null

Solution

1. Step 1: Delete node at position 5

   Position 5 node is 25; after deletion list: 5 -> 10 -> 15 -> 20 -> null.

2. Step 2: Delete node at position 1

   Delete head (5); new list: 10 -> 15 -> 20 -> null.

3. Step 3: Delete node at position 2

   Position 2 node is 15; after deletion list: 10 -> 20 -> null.

4. Final Answer:

   10 -> 20 -> null -> Option D

5. Quick Check:

   Sequential deletions update list correctly [OK]

Hint: Delete from end, then head, then middle stepwise [OK]

Common Mistakes:

• Deleting wrong nodes after list changes
• Not updating head after first deletion
• Confusing positions after deletions