Which approach is commonly used to merge two sorted singly linked lists into a single sorted list?

• A. Attach the lists end-to-end without comparing values.
• B. Attach the larger node first.
• C. Use a dummy head and repeatedly attach the smaller node from either list.
• D. First reverse both lists, then concatenate.

Answer: (C)

Merging two sorted lists by always choosing the smaller next node preserves the overall order as you build the result. Using a dummy head makes this process clean and robust because you don’t need special handling for the first node—you simply attach nodes to a tail as you go.

Here's how it works: create a dummy node and a tail pointer that starts at the dummy. Have pointers to the current nodes of both lists. Compare their values; attach the smaller node to tail.next, and advance that list’s pointer. Move the tail forward. Repeat until one list runs out, then link the remaining non-empty list to tail.next. Finally, return dummy.next as the head of the merged list.

This approach is optimal for correctness and efficiency: it maintains sorted order by always picking the smaller current value, handles edge cases smoothly with the dummy head, runs in linear time proportional to the total number of nodes (O(n + m)), and uses constant extra space since it reuses existing nodes. Attaching without comparisons would break order, and reversing lists before concatenation would not yield a sorted result without extra steps.