Delete Node in a Linked List - Practice Coding Problems

Delete Node in a Linked List - Problem

Linked List Medium

Given a singly-linked list and a reference to a specific node to be deleted, write a function to delete that node from the linked list.

Important constraints:

You are only given the node to be deleted - you do NOT have access to the head of the list
All values in the linked list are unique
The given node is guaranteed NOT to be the last node in the list
The given node is guaranteed to be a valid node in the list

The goal is to make it so that:

The value of the given node no longer exists in the linked list
The number of nodes decreases by one
All other values remain in the same relative order

Input & Output

Example 1 — Delete Middle Node

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

› Output: [4,1,9]

💡 Note: The node with value 5 should be deleted. We copy the next node's value (1) to the current node, making it [4,1,1,9], then skip the next node to get [4,1,9].

Example 2 — Delete First Node

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

› Output: [5,1,9]

💡 Note: Delete the first node by copying next node's value (5) to current node, then skipping the next node. Result: [5,1,9].

Example 3 — Two Node List

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

› Output: [2]

💡 Note: In a two-node list, deleting the first node leaves only the second node. We copy value 2 to the first node and remove the second.

Constraints

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

Visualization

Tap to expand

Understanding the Visualization

Input

Linked list [4,5,1,9] and node with value 5 to delete

Process

Copy next node's value and skip next node

Output

List becomes [4,1,9] with value 5 removed

Key Takeaway

🎯 Key Insight: When you can't delete yourself, become the next person and delete them instead

Asked in

Ad Adobe 15 🍎 Apple 12 M Microsoft 18 f Facebook 25

The key insight is that since we can't access the previous node, we copy the next node's value to the current node and then skip the next node. This effectively deletes the original value in O(1) time. Time: O(1), Space: O(1)

Common Approaches

Approach	Time	Space	Notes
✓ Impossible Brute Force	O(1)	O(1)	Try to traverse from head to find previous node
Copy Next Node's Value (Clever Trick)	O(1)	O(1)	Copy the next node's value to current node, then delete the next node

Impossible Brute Force — Algorithm Steps

Try to find the previous node
Realize we have no way to traverse backwards
Conclude this approach won't work

Visualization

Tap to expand

Step-by-Step Walkthrough

Traditional Approach

Find previous node to update its next pointer

Problem

We only have the node to delete, no access to previous

Conclusion

Impossible to delete without previous node reference

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct ListNode {
    int val;
    struct ListNode* next;
};

void solution(struct ListNode* node) {
    // This approach is impossible!
    // We cannot delete a node without access to its previous node
}

int main() {
    char listStr[1000], targetStr[20];
    fgets(listStr, sizeof(listStr), stdin);
    fgets(targetStr, sizeof(targetStr), stdin);
    
    listStr[strcspn(listStr, "\n")] = 0;
    targetStr[strcspn(targetStr, "\n")] = 0;
    
    int targetVal = atoi(targetStr);
    
    // Simple parsing for [1,2,3,4,5] format
    int values[100];
    int count = 0;
    
    if (strlen(listStr) > 2) {
        char* token = strtok(listStr + 1, ",]");
        while (token != NULL) {
            values[count++] = atoi(token);
            token = strtok(NULL, ",]");
        }
    }
    
    if (count == 0) {
        printf("[]\n");
        return 0;
    }
    
    struct ListNode* head = malloc(sizeof(struct ListNode));
    head->val = values[0];
    head->next = NULL;
    
    struct ListNode* current = head;
    struct ListNode* targetNode = NULL;
    
    if (values[0] == targetVal) {
        targetNode = head;
    }
    
    for (int i = 1; i < count; i++) {
        current->next = malloc(sizeof(struct ListNode));
        current = current->next;
        current->val = values[i];
        current->next = NULL;
        if (values[i] == targetVal) {
            targetNode = current;
        }
    }
    
    solution(targetNode);
    
    printf("[");
    current = head;
    int first = 1;
    while (current) {
        if (!first) printf(",");
        printf("%d", current->val);
        first = 0;
        current = current->next;
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

No actual traversal possible

✓ Linear Growth

Space Complexity

O(1)

No extra space needed for the impossible attempt

✓ Linear Space

98.2K Views

Medium Frequency

~15 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 — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler