How would you split a singly linked list into two lists containing nodes at odd and even positions, respectively?

• A. Traverse once and detach every other node using a boolean flag; O(n)
• B. Create two new lists and append odd/even nodes during a single pass; O(n)
• C. Iterate with an index counter, append odd-position nodes to one list and even-position nodes to another; O(n)
• D. Use a stack to partition nodes and then pop into two lists; O(n)

Answer: (C)

This tests distributing nodes into two lists in a single traversal by position, reusing the existing nodes rather than creating new ones.

A clean way is to walk the list once and build two separate lists on the fly: one for odd-positioned nodes and one for even-positioned nodes. Keep two pair of pointers for each list: head and tail. Start with position counting from 1 for the first node (odd). As you visit each node, detach it from the remainder (save its next pointer first, then set current.next to null), and append it to the appropriate list by updating the tail and, if needed, the head. Move to the saved next node and increment the position counter.

Why this is effective: it achieves the split in linear time with a single pass, and it uses constant extra space beyond the two resulting lists, since you only maintain a few pointers. It also avoids creating new nodes or requiring additional data structures.

Facing other approaches: using a stack adds extra memory overhead, and detaching with a simple boolean flag can be error-prone if you don’t carefully manage the next pointers and ends of the two lists. Creating two new lists could be correct but implies extra allocations or copying the data, which is less efficient. The in-place, counter-based distribution is straightforward, robust, and mirrors the intuitive idea of “alternate” assignment by position.