Intersection of Two Linked Lists - Practice Coding Problems

Intersection of Two Linked Lists - Problem

You're given the heads of two singly linked lists, headA and headB. Your task is to find the node where these two lists intersect and return that node. If the lists don't intersect at all, return null.

Key Point: The intersection is based on reference equality, not value equality. Two nodes are considered the same if they are the exact same node object in memory.

For example, consider these two linked lists:

List A: 4 → 1 → 8 → 4 → 5
List B:      6 → 1 → 8 → 4 → 5
                  ↑
             intersection point

The lists intersect at the node with value 8, and from that point onward, they share the same nodes.

Important constraints:

There are no cycles in the linked structure
The linked lists must retain their original structure after the function returns
You cannot modify the values or structure of the nodes

Input & Output

example_1.py — Basic Intersection

$ Input: listA = [4,1,8,4,5], listB = [5,6,1,8,4,5], skipA = 2, skipB = 3

› Output: Intersection at node with value 8

💡 Note: The lists intersect at the node with value 8. List A has 2 nodes before intersection, List B has 3 nodes before intersection. From the intersection point onward, both lists share the same nodes.

example_2.py — No Intersection

$ Input: listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2

› Output: null

💡 Note: The two lists do not intersect at all. List A and List B are completely separate with no shared nodes, so we return null.

example_3.py — Single Node Intersection

$ Input: listA = [1,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1

› Output: Intersection at node with value 2

💡 Note: List A has 3 nodes before intersection [1,9,1], then intersects with List B at node 2. List B has 1 node [3] before the intersection point.

Constraints

The number of nodes of listA is in the range [1, 3 * 10⁴]
The number of nodes of listB is in the range [1, 3 * 10⁴]
1 <= Node.val <= 10⁵
0 <= skipA < listA.length
0 <= skipB < listB.length
intersectVal is 0 if listA and listB do not intersect
Follow up: Could you write a solution that runs in O(m + n) time and use only O(1) memory?

Asked in

The optimal solution uses the two pointers technique with O(m+n) time and O(1) space. Key insight: if two pointers traverse both lists (switching to the other list when reaching the end), they'll travel equal distances and meet exactly at the intersection point. This elegant approach requires no extra space and guarantees finding the intersection in a single traversal of the combined structure.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(m*n)	O(1)	For each node in list A, traverse entire list B to check for intersection
Two Pointers (Optimal)	O(m + n)	O(1)	Use two pointers that switch lists when reaching the end - they'll meet at intersection
Hash Set (Two Pass)	O(m + n)	O(m)	Store all nodes from list A in hash set, then check list B for matches

Brute Force (Nested Loops) — Algorithm Steps

Start with the head of list A
For each node in list A, traverse the entire list B
Compare each node in B with the current node from A using reference equality
If a match is found, return that node
If we finish traversing A without finding any matches, return null

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with first node of A

Begin traversal from head of list A

Check against all of B

For current A node, traverse entire list B looking for match

Move to next A node

If no match found, move to next node in A and repeat

Return intersection or null

Return first match found, or null if no intersection exists

Code -

solution.c — C

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

// Definition for singly-linked list.
struct ListNode {
    int val;
    struct ListNode *next;
};

struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {
    if (!headA || !headB) {
        return NULL;
    }
    
    // For each node in list A
    struct ListNode* currentA = headA;
    while (currentA) {
        // Traverse entire list B to find intersection
        struct ListNode* currentB = headB;
        while (currentB) {
            // Check if same node (reference equality)
            if (currentA == currentB) {
                return currentA;
            }
            currentB = currentB->next;
        }
        currentA = currentA->next;
    }
    
    return NULL;
}

struct ListNode* createNode(int val) {
    struct ListNode* node = (struct ListNode*)malloc(sizeof(struct ListNode));
    node->val = val;
    node->next = NULL;
    return node;
}

int main() {
    // Create test case
    struct ListNode* intersection = createNode(8);
    intersection->next = createNode(4);
    intersection->next->next = createNode(5);
    
    struct ListNode* headA = createNode(4);
    headA->next = createNode(1);
    headA->next->next = intersection;
    
    struct ListNode* headB = createNode(5);
    headB->next = createNode(6);
    headB->next->next = createNode(1);
    headB->next->next->next = intersection;
    
    struct ListNode* result = getIntersectionNode(headA, headB);
    printf("Intersection value: %d\n", result ? result->val : -1);
    
    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 additional data structures

✓ Linear Space

25.0K Views

Medium Frequency

~15 min Avg. Time

850 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