Delete Node in a Linked List - Practice Coding Problems

Delete Node in a Linked List - Problem

Linked List Medium

Imagine you're given a mysterious mission: delete a specific node from a singly-linked list, but here's the twist - you don't have access to the head of the list!

You are given only the node to be deleted, and it's guaranteed that this node is not the last node in the list. All values in the linked list are unique.

Your goal: Make this node "disappear" from the linked list without having access to the previous nodes or the head. The list should maintain its structure and order, just without the target node.

Note: We don't mean removing it from memory completely - we mean the node's value should no longer exist in the logical structure of the list, and the list length should decrease by one.

Example: If the list is 4 -> 5 -> 1 -> 9 and you need to delete node with value 5, the result should be 4 -> 1 -> 9.

Input & Output

example_1.py — Basic Deletion

$ Input: head = [4,5,1,9], node = 5

› Output: [4,1,9]

💡 Note: We're given the node with value 5. We copy the next node's value (1) to this node, making it [4,1,1,9], then skip the next node to get [4,1,9]. The value 5 has been effectively removed.

example_2.py — Middle Node Deletion

$ Input: head = [4,5,1,9], node = 1

› Output: [4,5,9]

💡 Note: We're given the node with value 1. We copy the next node's value (9) to this node, making it [4,5,9,9], then skip the next node to get [4,5,9]. The original value 1 has been removed.

example_3.py — Two Node List

$ Input: head = [1,2], node = 1

› Output: [2]

💡 Note: In a two-node list, we delete the first node by copying the second node's value (2) to the first node, then skipping the second node. Result is just [2].

Constraints

The number of nodes in the given list is in the range [2, 1000]
-1000 <= Node.val <= 1000
The value of each node in the list is unique
The node to be deleted is in the list and is not a tail node

Visualization

Tap to expand

Understanding the Visualization

The Problem

You need to delete yourself from a line, but you can't leave your position and can't ask people in front to help

The Trick

Copy the identity (name tag) of the person behind you

The Swap

Now you have their identity, and you can make them leave instead

Mission Complete

Your original identity has vanished from the line!

Key Takeaway

🎯 Key Insight: When you can't delete a node traditionally, make it become the next node and delete that one instead!

Asked in

Ae Adobe 15 Apple 12 ⊞ Microsoft 8 G Google 6

The optimal solution uses a clever identity swap technique in O(1) time and space. Since we can't access the previous node, we copy the next node's value into the current node, then skip the next node. This effectively deletes the original value while maintaining the list structure.

Common Approaches

Approach	Time	Space	Notes
✓ Impossible Brute Force Approach	O(n)	O(1)	Try to traverse from the head to find the previous node - but we don't have access to head!
Value Copying - The Identity Swap (Optimal)	O(1)	O(1)	Copy the next node's value to current node, then delete the next node

Impossible Brute Force Approach — Algorithm Steps

Start from head (but we don't have access to it!)
Traverse until we find the node before our target
Update the previous node's next pointer
This approach is impossible given the constraints

Visualization

Tap to expand

Step-by-Step Walkthrough

Traditional Deletion

Normally we'd traverse from head to find the previous node

Problem Constraint

But we don't have access to head - only the node to delete!

Impossible

We can't traverse backwards in a singly-linked list

Code -

solution.c — C

// This approach is IMPOSSIBLE for this problem
// We don't have access to head, so we can't traverse
void deleteNode(struct ListNode* node) {
    // This is what we WOULD do if we had head:
    // struct ListNode* current = head;
    // while (current->next != node) {
    //     current = current->next;
    // }
    // current->next = node->next;
    
    // But we DON'T have head, so this won't work!
    printf("Error: Cannot delete node without access to head or previous node\n");
    exit(1);
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Would need to traverse the list to find the previous node

✓ Linear Growth

Space Complexity

O(1)

No extra space needed besides pointers

✓ Linear Space

125.0K Views

Medium Frequency

~8 min Avg. Time

2.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Impossible Brute Force Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler