Delete Node in a Linked List

Delete node in a linked list is unusual: you are given only the node to delete, with no access to the head and no way to reach the previous node. The standard deletion — relinking the predecessor past the target — is simply unavailable. Since the previous node cannot be found, the node itself cannot truly be removed from the chain. The trick is to change what "deleting" means: - Copy the next node's value into this node, then delete the next node instead. The node object stays in the list, but the value it held is gone and every value after it shifts back one position. From the outside, the list reads exactly as though the target had been removed — which is what the problem actually checks. Concretely: node.val = node.next.val, then node.next = node.next.next. The second line unlinks the successor, whose value now lives in the current node. The reason this is guaranteed to work is stated in the constraints — the node to delete is never the tail. Without that guarantee the approach would fail, since a tail node has no successor to copy from and no way to reach its predecessor. Recognising that the constraint is what makes the trick legal is the real insight. In languages with manual memory management, the orphaned successor node should be freed after unlinking. The genuinely instructive part is realising that when the usual mechanism is unavailable, redefining the operation in terms of values rather than structure solves it.

Delete node in a linked list without head: a puzzle about reframing, since you're given only the node to delete, with no access to its predecessor, so you cannot unlink it in the usual way. The move is to stop thinking about deleting this node and instead overwrite it with its successor's data, then unlink the successor. The node object survives; the value disappears, which is all anyone can observe.