Reorder List LeetCode 143 — Three Steps

LeetCode 143 — Reorder List — gives you the head of a singly linked list L0→L1→...→Ln-1→Ln and asks you to reorder it to: L0→Ln→L1→Ln-1→L2→Ln-2→... You must do this in-place — no allocating a new list or copying values between nodes. Only node rewiring is allowed.

The resulting list interleaves nodes from the front and back of the original, alternating one from the start then one from the end. For a five-node list 1→2→3→4→5, the answer is 1→5→2→4→3. For a four-node list 1→2→3→4, the answer is 1→4→2→3. The middle node (or the first of two middles for even-length lists) always ends up last.

What makes this problem elegant is that it can be decomposed entirely into three simpler problems you may already know. No new algorithms are required — just the right composition of existing linked list primitives applied in sequence.

The key insight for LeetCode 143 is to stop thinking of it as one problem and start thinking of it as three. Step 1: find the middle of the linked list using the classic slow/fast pointer technique. Step 2: reverse the second half of the list (from middle+1 to the end). Step 3: merge the two halves by interleaving nodes from the first half and the reversed second half.

Each of these three steps corresponds to a well-known LeetCode problem in its own right: finding the middle is LeetCode 876, reversing a linked list is LeetCode 206, and merging two lists alternately is a pattern from LeetCode 21. If you have solved any of those, you already have the building blocks.

The beauty of this decomposition is that each step is independently verifiable. You can write and test each helper function on its own before combining them. This modular approach also means the code stays readable even in an interview — three focused functions rather than one tangled loop.

Use the slow/fast pointer technique to find the middle of the list. Initialize both slow and fast at the head. On each step, move slow one node forward and fast two nodes forward. When fast reaches the end of the list (fast is null or fast.next is null), slow is sitting at the middle node.

For an odd-length list like 1→2→3→4→5, slow lands on node 3 — the true middle. For an even-length list like 1→2→3→4, slow lands on node 2 — the first of the two middle nodes. In both cases, the second half of the list starts at slow.next.

After finding the middle, you split the list: save the head of the second half as slow.next, then set slow.next = null to sever the first half from the second. This disconnection is critical — without it, the merge step in Step 3 will create a cycle in the list.

Apply the standard iterative linked list reversal to the second half. Initialize prev = null and cur = secondHalf. On each iteration: save next = cur.next, then set cur.next = prev, then advance prev = cur and cur = next. Repeat until cur is null. At the end, prev is the new head of the reversed second half.

For the list 1→2→3→4→5 with second half 4→5, this produces 5→4. For the four-node list 1→2→3→4 with second half 3→4, this produces 4→3. After reversal, the last node of the reversed second half will have a null next pointer — which is exactly what you want for clean merging.

This is literally the solution to LeetCode 206 Reverse Linked List applied to a sublist. If you have that problem memorized, Step 2 takes seconds to write. The three-line iterative reversal is one of the most frequently recurring patterns in linked list interviews.

With the first half and the reversed second half in hand, merge them by interleaving: take one node from the first half, then one node from the reversed second half, and repeat until the second half is exhausted. The first half may have one more node than the second (the original middle node for odd-length lists), which becomes the tail naturally.

Use two pointers, first and second, starting at the heads of the two halves. On each iteration: save first.next and second.next, then set first.next = second, then set second.next = saved first.next, then advance both pointers to their saved nexts. Repeat while second is not null.

For 1→2→3 and 5→4: iteration 1 produces 1→5→2→3 (first advances to 2, second advances to 4); iteration 2 produces 1→5→2→4→3 (first advances to 3, second is now null). The loop ends and the list is correctly reordered.

In Python, the three steps map to three helper-like blocks: find middle with slow/fast, reverse second half iteratively, then merge alternating. The full solution runs in O(n) time and O(1) space — no stack, no array, no extra nodes beyond the original list structure.

In Java the logic is identical: ListNode slow = head, fast = head; while (fast != null && fast.next != null) { slow = slow.next; fast = fast.next.next; } — then reverse from slow.next with the three-variable swap loop, then interleave. The structure is clean and modular whether written as one function or three helpers.

Across both languages the total code is under 30 lines. Splitting into three named helper methods (findMiddle, reverseList, mergeAlternating) makes it exceptionally readable and testable. Each function can be unit-tested in isolation, which is a strong signal of clean design in a systems-thinking interview.

Reverse Linked List II (LeetCode 92) is a close relative — instead of reversing the entire second half, it reverses a sublist between given positions. The reversal technique is identical; only the start and end pointers differ. If you have mastered LeetCode 143 step 2, LeetCode 92 follows naturally.

Middle of the Linked List (LeetCode 876) is exactly step 1 of this solution in standalone form. Merge Two Sorted Lists (LeetCode 21) is a sorted-order version of the merge pattern used in step 3. These three problems together form the "linked list composition" family — problems that are solved by combining well-known primitives.

The deeper skill this problem teaches is decomposition: seeing a hard problem as a sequence of easier problems. That skill transfers to graph problems (BFS then union-find), tree problems (traversal then recursion), and dynamic programming (identify subproblems then memoize). LeetCode 143 is a clean example of structured thinking under pressure.