Given the head pointer and a value to delete, what is the standard procedure?

• A. Traverse with a previous pointer to find the node, then prev.next = curr.next; deallocate curr; O(n)
• B. Copy data from next node into current node and delete next; O(1)
• C. Set head = curr.next; deallocate curr; O(1)
• D. Remove the tail node and update pointers; O(n)

Answer: (A)

The key idea is that deleting a node by value in a singly linked list requires finding that node and unlinking it by updating the previous node’s next pointer to skip over it, then freeing the target node. Since there’s no backward link, you must keep a reference to the node just before the one you’re deleting as you traverse. If you reach the node to delete and you have a previous node, you set previous.next to current.next and deallocate the current node. If the node to delete is the head, you update the head pointer to head.next and free the old head. This approach works for any position in the list and has a worst-case time of O(n) because you may need to examine every node, with O(1) extra space.

The other methods aren’t the standard approach in general. Copying data from the next node into the current one and deleting the next node can fail if you’re trying to delete the last node or if external references rely on the node’s identity, so it’s not a reliable universal delete-by-value technique. Simply setting the head to head.next only handles deletion when the target is the first node, not when it’s somewhere in the middle. Removing the tail requires locating it and its predecessor anyway, so it’s not the general solution for deleting by value.