Intersection of Two Linked Lists Explained: Intersect at 8 Walkthrough

Imagine you are managing two separate text histories in memory where both timelines eventually merge into the exact same sequence of edits. In data structures, this is represented by two singly linked lists that share a common tail, such as our locked working example: list $A=4\to 1\to 8\to 4\to 5$ and list $B=5\to 6\to 1\to 8\to 4\to 5$. They start with different prefix nodes ($4\to 1$ versus $5\to 6\to 1$), but once they hit node 8, they point to the exact same memory objects all the way to the end.

Without a clever pointer strategy, finding where these two lists merge requires checking every node in list $A$ against every node in list $B$ using a nested loop, or storing references in a hash set with $O(N)$ extra space. That brute-force approach ignores the structural gift of the merged tail: once two nodes point to the same next object, they can never split back apart. We need an approach that effortlessly bridges the gap between different prefix lengths without allocating extra memory.

// Given list A: 4 -> 1 -> 8 -> 4 -> 5
// Given list B: 5 -> 6 -> 1 -> 8 -> 4 -> 5
// Expected Intersection: Node with value 8 (shared object)

function getIntersectionNode(headA, headB) {
  // TODO: Why do standard pointer traversals miss each other here?
}

When looking at our working example where list $A$ ($4\to 1\to 8\to 4\to 5$) and list $B$ ($5\to 6\to 1\to 8\to 4\to 5$) merge at node 8, the core hurdle is mismatched head lengths. List $A$ has a unique prefix of length 2, while list $B$ has a unique prefix of length 3 before hitting the shared node 8.

Instead of measuring lengths or using nested loops, we deploy a path-redirection model. We imagine two runners, pointer $p$ starting at the head of list $A$ and pointer $q$ starting at the head of list $B$. When a pointer reaches the end of its list (hits null), it instantly teleports to the head of the opposite list and continues walking.

Let us visualize what happens to their total travel distance. Pointer $p$ travels list $A$ followed by list $B$. Pointer $q$ travels list $B$ followed by list $A$. Because addition is commutative ($\text{length}(A)+\text{length}(B)=\text{length}(B)+\text{length}(A)$), both pointers travel the exact same total number of steps before they align at the intersection node 8.

Once both pointers cross into the shared tail starting at node 8, they are locked in sync. Every subsequent step they take together is identical: $8\to 4\to 5\to \text{null}$. The elegance of this model is that the distance mismatch is completely dissolved during the first pass of cross-traversal.

Now let's trace our locked example from start to finish. We have list A starting at head 4 with length 5 ($4\to 1\to 8\to 4\to 5$), and list B starting at head 5 with length 6 ($5\to 6\to 1\to 8\to 4\to 5$). Both lists merge at node 8, sharing the exact same remaining tail nodes $8\to 4\to 5$.

Given:
- Pointer p starts at A.head (node 4).
- Pointer q starts at B.head (node 5).

Steps:
1. First Pass (Individual Lists): p travels through $4\to 1\to 8\to 4\to 5$ and then jumps to B.head. Meanwhile, q travels through $5\to 6\to 1\to 8\to 4\to 5$ and then jumps to A.head.
2. Absorbing the Offset: Because list B has one extra node at the front, pointer p hits null earlier and switches to B.head while q is still finishing list B. When q hits null, it switches to A.head. At this exact moment, p has traveled the length of A plus the prefix of B, and q has traveled the length of B plus the prefix of A.
3. Second Pass (The Convergence): Both pointers are now equidistant from the intersection node. Stepping forward in lockstep, p and q march simultaneously through the shared tail until they land on node 8.

Result:
The pointers collide at node 8 on the second pass, returning the correct shared intersection object.

Try this: Given list A = [4, 1, 8, 4, 5] and list B = [5, 6, 1, 8, 4, 5] intersecting at node 8:

Now that you have seen how the dual-pointer traversal equalizes the length difference in our working example ($A=4\to 1\to 8\to 4\to 5$ and $B=5\to 6\to 1\to 8\to 4\to 5$), it is time to test your mental model on a structural variation. Consider what happens when one list is completely disjoint from the other, or when they intersect at their very first nodes.

Imagine you are running the exact same pointer-switching logic on two lists that never intersect: list $A$ has length 3 and list $B$ has length 4, and neither shares any memory nodes. Before writing any code, trace mentally: what will the pointers $p$ and $q$ point to after both lists have been fully traversed twice, and what should your loop condition return?

Keep the core invariant in mind: pointer $p$ traverses $A$ then $B$, while pointer $q$ traverses $B$ then $A$. If they never share a tail node, they must finish their second traversal at the exact same moment. Think about how their final step resolves to null and why that prevents an infinite loop.

Try this: Consider two non-intersecting lists where List A has 3 nodes and List B has 4 nodes. Trace pointers p (starting at

B) through their full double-traversal cycle. What are the exact values of p and q at the end of iteration step 7 ($3+4$), and what value does the algorithm return?

You have mastered how two runners traversing combined paths $A+B$ and $B+A$ will naturally synchronize at node 8 by absorbing length differences. This same structural trick—routing pointers through each other's full domain to eliminate length offsets—extends far beyond simple singly linked list intersections. Whenever two dependent sequences or streams must be aligned without using extra memory for hash sets, treating the traversal lengths as an additive identity ($A+B=B+A$) is your primary tool. Consider how this logic generalizes when pointers move through cyclic graphs or when memory constraints strictly forbid modifying the original node structures.

def find_intersection_or_variant(headA, headB):
    # Apply the two-pointer bridge pattern learned from the Intersect at 8 example
    pass