How would you determine whether two singly linked lists intersect by reference, and how would you locate the intersection node?

• A. Align by length and walk until node references are equal; intersection exists if pointers meet
• B. Compare values at each node until a match occurs
• C. Swap next pointers to join lists; intersection exists if pointers equal
• D. Use a hash set of visited nodes; intersection exists if you revisit

Answer: (A)

The idea being tested is detecting and locating an intersection by reference, meaning the two lists share node objects from a certain point onward, not just equal values. To find the intersection node, first determine how long each list is. If one list is longer, advance its head by the difference in lengths so both pointers are the same distance from their ends. Then move both pointers forward together; the first time they reference the same node is the intersection node. If you reach the end (null) without a match, there is no intersection. This approach runs in linear time, O(n + m), and uses constant extra space, since you only track two pointers.

Why other ideas don’t fit: comparing values at nodes can falsely claim an intersection when two distinct nodes happen to hold the same value, which isn’t about shared references. swapping next pointers is destructive and corrupts the lists, so it’s not a safe or correct method. using a hash set of visited nodes can detect an intersection by reference, but it requires additional space, whereas the alignment-by-length method achieves the result with O(1) extra space.