Delete Node in a Linked List

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

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

✓ Copy Next Node's Value (Clever Trick)

⏱️ Time: O(1) Space: O(1)

Since we can't delete the current node directly, we copy the next node's value into the current node and then delete the next node. This effectively removes the original value while maintaining list structure.

Impossible Brute Force

⏱️ Time: O(1) Space: O(1)

In a typical deletion, we'd find the previous node and update its next pointer. However, since we don't have access to the head or any previous nodes, this approach is impossible.

Copy Next Node's Value (Clever Trick) — Algorithm Steps

Copy next node's value to current node
Copy next node's next pointer to current node's next
The next node is now bypassed and effectively deleted

Visualization

Tap to expand

Step-by-Step Walkthrough

Original State

We have node with value 5 to delete

Copy Next Value

Copy value 1 from next node to current node

Skip Next Node

Update pointer to bypass the next node

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
    // and we cannot traverse backwards in a singly-linked list
    // Do nothing
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

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)

Only performs constant number of assignments

✓ Linear Growth

Space Complexity

O(1)

No extra data structures needed

✓ 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

Copy Next Node's Value (Clever Trick) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler