Linked List Intersection Finder - Problem

Given two singly linked lists that may merge at some point, find the intersection node where they first converge.

If the two linked lists have no intersection at all, return null.

The linked lists must retain their original structure after the function returns.

You may assume there are no cycles anywhere in the entire linked structure.

Each value on each node is in the range [1, 10⁹].

Input & Output

Example 1 — Lists Intersect at Node 4

$ Input: listA = [1,8,4], listB = [5,4], intersectVal = 4

› Output: 4

💡 Note: List A: 1→8→4, List B: 5→4. They intersect at the node with value 4. The intersection node is where the linked lists merge, not just matching values.

Example 2 — No Intersection

$ Input: listA = [2,6,4], listB = [1,5], intersectVal = null

› Output: null

💡 Note: The two linked lists do not intersect at all, so return null. Even if they had the same values, they would need to share actual node references.

Example 3 — Intersection at Head

$ Input: listA = [3], listB = [3], intersectVal = 3

› Output: 3

💡 Note: Both lists consist of the same single node, so they intersect at the head node with value 3.

Constraints

The number of nodes of listA is in the range [0, 3 × 10⁴]
The number of nodes of listB is in the range [0, 3 × 10⁴]
1 ≤ Node.val ≤ 10⁵
0 ≤ skipA ≤ m
0 ≤ skipB ≤ n

Visualization

Tap to expand

Asked in

a Amazon 45 M Microsoft 38 f Facebook 32 🍎 Apple 28

The key insight is using two pointers that switch paths when reaching the end - this ensures both pointers travel the same total distance and meet at the intersection point. Best approach uses the two-pointer technique with path switching. Time: O(m+n), Space: O(1).

Common Approaches

✓ Brute Force - Check Every Node

⏱️ Time: O(m×n) Space: O(1)

Visit each node in the first linked list, and for each node, traverse the entire second linked list to check if any node matches. This requires nested loops and becomes very slow for large lists.

Two Pointers - Equal Distance Trick

⏱️ Time: O(m+n) Space: O(1)

Start two pointers at the heads of both lists. When a pointer reaches the end, redirect it to the other list's head. Both pointers will travel the same total distance and meet at the intersection point.

Brute Force - Check Every Node — Algorithm Steps

Traverse each node in list A
For each node in A, traverse entire list B
Check if current node in A matches any node in B
Return first match found, or null if no intersection

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with first node in A

Begin traversing list A from head

Check against all nodes in B

For current node in A, traverse entire list B

Move to next node in A

Repeat until intersection found or lists exhausted

Code -

solution.c — C

struct ListNode {
    int val;
    struct ListNode* next;
};

struct ListNode* solution(struct ListNode* headA, struct ListNode* headB) {
    if (!headA || !headB) return NULL;
    
    struct ListNode* currentA = headA;
    while (currentA) {
        struct ListNode* currentB = headB;
        while (currentB) {
            if (currentA == currentB) {
                return currentA;
            }
            currentB = currentB->next;
        }
        currentA = currentA->next;
    }
    
    return NULL;
}

#include <stdio.h>
#include <stdlib.h>

int main() {
    // Input parsing simplified for demonstration
    struct ListNode* result = solution(NULL, NULL);
    if (result) {
        printf("%d\n", result->val);
    } else {
        printf("null\n");
    }
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m×n)

For each of m nodes in list A, we traverse all n nodes in list B

✓ Linear Growth

Space Complexity

O(1)

Only using a few pointer variables, no extra data structures

✓ Linear Space

78.4K Views

High Frequency

~25 min Avg. Time

2.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Linked List Intersection Finder - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Check Every Node — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler