Delete Node Without Head | Copy & Skip | Linked List

Overview

Delete node without head reference means you are given a pointer to the node to delete (and no access to the head). In a singly linked list you cannot go backward, so you cannot update the previous node's next pointer directly. The trick: copy the next node's value into the current node, then skip (delete) the next node by setting node.next = node.next.next. This effectively removes the "current" node from the list in O(1) time. The list now has the same values in the same order, but the node you were given has been "replaced" by the next node (which is no longer in the list).

Caveat: This does not work if the node to delete is the tail (it has no next). The problem usually states that the node is not the tail, or you can treat tail as a special case (e.g. you cannot delete the tail with this method without head).

When to Use

Delete when you only have the node — Interview trick; not always applicable (e.g. if external references to nodes must stay valid).
In-place "delete" by value replacement — When you can't access the head.

How It Works

If node.next is null — You cannot delete the tail without the head; problem typically says node is not tail.
Otherwise: node.val = node.next.val; node.next = node.next.next. The next node is effectively removed; the current node now holds the next node's value and points to what was after it.

Example 1: Delete Node (Not Tail)

Problem: Write a function to delete a node in a singly linked list. You will not be given access to the head; instead you will be given access to the node to be deleted directly. It is guaranteed that the node to be deleted is not a tail node.

function deleteNode(node: ListNode): void {
  node.val = node.next!.val;
  node.next = node.next!.next;
}

Time: O(1), Space: O(1).

Edge Cases

Node is tail — Cannot do it without head; problem usually excludes this.
Single node (and it's the one to delete) — Then it would be the tail; excluded.
Second-to-last node — Copy last node's value, set next to null; the last node is no longer reachable. Correct.

Common Mistakes

Deleting the tail — If you have no head, you cannot make the previous node point to null; the problem must state the node is not the tail.
Losing the list — Only update node.val and node.next; don't overwrite the node reference itself in a way that breaks the list.
External references — If other code holds a reference to the "deleted" node, that reference still points to a node that is now in the list (with a different value). If they held a reference to the "next" node, that node is now unreachable. Clarify in interviews if this is acceptable.

Time and Space Complexity

Time: O(1).
Space: O(1).

Summary

Delete without head (singly linked, node not tail): Copy next's value into node; set node.next = node.next.next. The next node is effectively removed.
For Doubly Linked List you can delete any node (including tail) in O(1) with prev/next updates. See Dummy Head when you do have head and want to delete by value or position.

Delete Node Without Head Reference