Delete Node Linked List LeetCode 237

LeetCode 237 — Delete Node in a Linked List presents an unusual twist on the classic deletion problem. You are given access only to the node you want to delete — not the head of the list. Your task is to delete that node from the singly linked list. The node is guaranteed not to be the tail, so it always has a next node.

In a standard linked list deletion you find the previous node and set previous.next = target.next, effectively bypassing the target. That approach requires traversal from the head. Here, traversal is impossible because the head is not provided — you must solve the problem using only the reference to the target node itself.

The constraint that the node is not the tail is critical: it guarantees a next node always exists, which makes the trick described below possible in every valid input case.

Because you cannot access the previous node, the usual bypass (previous.next = node.next) is off the table. The insight is to flip the problem: instead of deleting the current node, delete the next node — but first copy the next node's value into the current node.

After the copy, the current node holds what the next node used to hold. Setting current.next = current.next.next then removes the next node from the chain. From any external perspective, the value that was originally in the target node has disappeared, and the list flows correctly.

This is a two-step operation: (1) node.val = node.next.val — overwrite current value with successor's value; (2) node.next = node.next.next — bypass the successor. Both steps run in O(1) time with no extra memory.

The complete solution is two lines: node.val = node.next.val followed by node.next = node.next.next. That is the entire function body. No loops, no conditionals, no helper methods. This is one of the shortest valid solutions on LeetCode.

Time complexity is O(1): both operations are direct pointer or value assignments with no iteration. Space complexity is O(1): no auxiliary data structures are allocated.

In Python the method receives self and node as parameters and returns nothing. In Java the method is void and receives the node directly. Both implementations are two statements and return implicitly.

A linked list is defined entirely by its values and its next-pointers. Observers of the list only see (value, next) pairs; they have no knowledge of the physical node objects. By copying next's value into the current node and updating next to skip the old next, the sequence of (value, next) pairs seen by any traversal is exactly what it would be if the original node had been removed normally.

Concretely: before the operation the traversal sees ... → [A] → [B] → [C] → ... where A is the node to delete. After the operation the traversal sees ... → [B'] → [C] → ... where B' is the original A node now holding B's value and pointing to C. The node object for B no longer appears in any reachable path.

This works because the problem guarantees unique values and no external references to node.next that would expose the "deleted" successor object. In a production system with shared references, this trick could leave dangling pointers, but under LeetCode's constraints it is perfectly correct.

Consider the list 4 → 5 → 1 → 9 and the instruction to delete the node with value 5. You receive a reference to the node holding 5. You cannot reach the node holding 4 (the head is not given).

Step one: copy the next node's value (1) into the current node. The list now looks like 4 → 1 → 1 → 9 — there are temporarily two nodes with value 1, but this is an intermediate state visible only within the function.

Step two: bypass the successor by setting node.next = node.next.next. The second 1-node is removed from the chain. The final list is 4 → 1 → 9, which is exactly the expected result after deleting the node with value 5.

Python: def deleteNode(self, node): node.val = node.next.val; node.next = node.next.next. Two lines. No return value needed — the list is modified in place through the node reference. This is the shortest possible correct implementation.

Java: public void deleteNode(ListNode node) { node.val = node.next.val; node.next = node.next.next; }. Identical logic, two statements. The method is void; the mutation is visible to the caller through the shared object reference.

Both run in O(1) time and O(1) space. There is no iteration, no recursion, no extra data structure. This is likely the shortest solution for any LeetCode medium or easy problem you will encounter.

LeetCode 237 belongs to the linked list deletion family. The closest relative is LeetCode 2095 Delete the Middle Node of a Linked List, which requires finding the middle using the slow-fast pointer technique and then removing it — that problem requires head access and uses the standard previous.next = node.next bypass.

LeetCode 19 Remove Nth Node From End of List also requires head access and uses the two-pointer gap technique to position a pointer exactly N steps ahead of the deletion point. LeetCode 82 and 83 Remove Duplicates from Sorted List use repeated bypass operations while traversing from the head.

The common thread across the deletion family is maintaining the previous pointer or using a dummy head node to simplify edge cases. LeetCode 237 is unique in that the previous pointer is deliberately withheld, forcing the copy-next trick. Understanding why each deletion variant requires the approach it does deepens your linked list intuition significantly.