Intersection Point of Two Linked Lists in DSA Python - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Find the intersection node value

Given two linked lists that intersect, what is the value of the intersection node printed by the code?

DSA Python

class Node:
    def __init__(self, val):
        self.val = val
        self.next = None

def get_intersection_node(headA, headB):
    ptrA, ptrB = headA, headB
    while ptrA != ptrB:
        ptrA = ptrA.next if ptrA else headB
        ptrB = ptrB.next if ptrB else headA
    return ptrA

# Create nodes
common = Node(8)
common.next = Node(10)

headA = Node(3)
headA.next = Node(7)
headA.next.next = common

headB = Node(99)
headB.next = Node(1)
headB.next.next = common

intersection = get_intersection_node(headA, headB)
print(intersection.val if intersection else None)

A 7

B 10

C None

D 8

💡 Hint

Trace the pointers moving through each list and switching heads when reaching the end.

The intersection node is the first common node in both lists, which has value 8. The algorithm moves pointers through both lists and aligns them to find this node.

❓ Predict Output

intermediate

Output when no intersection exists

What is the output of the code when two linked lists do not intersect?

DSA Python

class Node:
    def __init__(self, val):
        self.val = val
        self.next = None

def get_intersection_node(headA, headB):
    ptrA, ptrB = headA, headB
    while ptrA != ptrB:
        ptrA = ptrA.next if ptrA else headB
        ptrB = ptrB.next if ptrB else headA
    return ptrA

headA = Node(1)
headA.next = Node(2)
headA.next.next = Node(3)

headB = Node(4)
headB.next = Node(5)
headB.next.next = Node(6)

intersection = get_intersection_node(headA, headB)
print(intersection.val if intersection else None)

A None

B 1

C 6

D 0

💡 Hint

If no intersection exists, the pointers will both become None at the same time.

When lists do not intersect, the pointers eventually become None simultaneously, so the function returns None.

🔧 Debug

advanced

Identify the error in intersection detection code

What error does the following code produce when trying to find the intersection point of two linked lists?

DSA Python

def get_intersection_node(headA, headB):
    ptrA, ptrB = headA, headB
    while ptrA != ptrB:
        ptrA = ptrA.next
        ptrB = ptrB.next
        if ptrA is None and ptrB is None:
            return None
    return ptrA

A SyntaxError due to missing colon

B Returns None correctly when no intersection

C AttributeError when ptrA or ptrB is None

D Infinite loop when lists intersect

💡 Hint

Check what happens when ptrA or ptrB reaches the end of the list.

The code tries to access .next on None without checking, causing AttributeError.

🧠 Conceptual

advanced

Why does switching heads help find intersection?

Why does switching the pointers to the other list's head after reaching the end help find the intersection point?

A It skips nodes to speed up search

B It equalizes the path lengths so pointers meet at intersection

C It prevents infinite loops by breaking early

D It resets pointers to start over from beginning

💡 Hint

Think about how different list lengths affect pointer alignment.

Switching heads makes both pointers traverse equal total lengths, so they meet at the intersection node.

❓ Predict Output

expert

Output of intersection detection with cycle in one list

What is the output of the code when one linked list has a cycle and the other intersects it at a node inside the cycle?

DSA Python

class Node:
    def __init__(self, val):
        self.val = val
        self.next = None

def get_intersection_node(headA, headB):
    ptrA, ptrB = headA, headB
    visited = set()
    while ptrA and ptrB:
        if ptrA == ptrB:
            return ptrA
        if ptrA in visited or ptrB in visited:
            return None
        visited.add(ptrA)
        visited.add(ptrB)
        ptrA = ptrA.next if ptrA else None
        ptrB = ptrB.next if ptrB else None
    return None

# Create cycle list
headA = Node(1)
node2 = Node(2)
node3 = Node(3)
node4 = Node(4)
headA.next = node2
node2.next = node3
node3.next = node4
node4.next = node2  # cycle here

# Create second list intersecting inside cycle
headB = Node(9)
headB.next = node3

intersection = get_intersection_node(headA, headB)
print(intersection.val if intersection else None)

A 3

B 2

C None

D 4

💡 Hint

The intersection is at node with value 3 inside the cycle.

The code detects intersection at node 3 before revisiting nodes in the cycle.

Practice

1. What does the term intersection point of two linked lists mean?

easy

A. The first node of the longer linked list.

B. The node where both linked lists share the same reference (memory address).

C. The node where the values of both linked lists are equal.

D. The last node of the shorter linked list.

Solution

1. Step 1: Understand linked list nodes

   Each node in a linked list has a value and a reference (memory address) to the next node.

2. Step 2: Define intersection point

   The intersection point is where two linked lists share the exact same node reference, not just the same value.

3. Final Answer:

   The node where both linked lists share the same reference (memory address). -> Option B

4. Quick Check:

   Intersection means shared node reference [OK]

Hint: Intersection means same node object, not just same value [OK]

Common Mistakes:

• Confusing same value with same node reference
• Thinking intersection is based on node values
• Assuming intersection is always at the start

2. Which of the following Python code snippets correctly initializes two linked lists headA and headB that intersect at node with value 8?

easy

A. headA = Node(3)
headB = Node(99)
headA.next = Node(8)
headB.next = Node(8)

B. node = Node(8)
headA = Node(3, node)
headB = Node(99, node)

C. headA = Node(3)
headB = Node(99)
node = Node(8)
headA.next = node
headB.next = node

D. nodeA = Node(3)
nodeB = Node(99)
nodeC = Node(8)
headA = nodeA
headB = nodeB

Solution

1. Step 1: Understand intersection setup

   To create intersection, both lists must share the same node object for the intersecting node.

2. Step 2: Check code correctness

   headA = Node(3) headB = Node(99) node = Node(8) headA.next = node headB.next = node creates node with value 8 once and assigns it as next for both lists, ensuring intersection.

3. Final Answer:

   headA and headB share the same node object for value 8. -> Option C

4. Quick Check:

   Shared node object creates intersection [OK]

Hint: Intersection needs shared node object, not just same value nodes [OK]

Common Mistakes:

• Creating separate nodes with same value instead of shared node
• Assigning next pointers incorrectly
• Not linking nodes properly

3. What will be the output of the following Python code that finds the intersection point of two linked lists?

class Node:
    def __init__(self, val):
        self.val = val
        self.next = None

def get_intersection(headA, headB):
    a, b = headA, headB
    while a != b:
        a = a.next if a else headB
        b = b.next if b else headA
    return a.val if a else None

# Setup
common = Node(7)
common.next = Node(10)
headA = Node(3)
headA.next = Node(6)
headA.next.next = common
headB = Node(99)
headB.next = common

print(get_intersection(headA, headB))

medium

A. 7

B. 10

C. None

D. 3

Solution

1. Step 1: Understand the intersection nodes

   Both lists share node with value 7 and then 10. Intersection is at node with value 7.

2. Step 2: Trace the get_intersection function

   Pointers a and b traverse lists; when they meet at node 7, function returns 7.

3. Final Answer:

   7 -> Option A

4. Quick Check:

   First shared node value is 7 [OK]

Hint: Two-pointer method returns first shared node value [OK]

Common Mistakes:

• Returning value of second shared node
• Returning None if not careful with pointer resets
• Confusing node values with references

4. The following code attempts to find the intersection point of two linked lists but does not work correctly. What is the main error?

def get_intersection(headA, headB):
    a, b = headA, headB
    while a != b:
        a = a.next
        b = b.next
    return a.val if a else None

medium

A. It returns the value of the last node instead of the intersection.

B. It compares node values instead of node references.

C. It uses incorrect variable names for nodes.

D. It does not reset pointers to the other list when reaching the end.

Solution

1. Step 1: Analyze pointer movement

   The code moves pointers a and b forward but never resets them to the other list's head.

2. Step 2: Understand consequence

   Without resetting, pointers may reach None at different times and never meet, missing intersection.

3. Final Answer:

   It does not reset pointers to the other list when reaching the end. -> Option D

4. Quick Check:

   Resetting pointers is key for intersection detection [OK]

Hint: Reset pointers to other list head when reaching end [OK]

Common Mistakes:

• Not resetting pointers causes infinite loop or no detection
• Comparing values instead of references
• Returning wrong node value

5. Given two singly linked lists that may or may not intersect, which approach correctly finds the intersection point in O(m+n) time and O(1) space?

Options:
A) Use two pointers starting at heads; move each pointer to the other list's head when reaching end until they meet.
B) Use a hash set to store nodes of first list, then check nodes of second list for membership.
C) Compare every node of first list with every node of second list.
D) Reverse both lists and compare nodes from the start until mismatch.

hard

A. Two-pointer switching heads method until pointers meet.

B. Hash set membership check for intersection.

C. Nested loops comparing all nodes pairwise.

D. Reverse lists and compare nodes from start.

Solution

1. Step 1: Analyze time and space complexity

   Two-pointer switching heads method until pointers meet. uses two pointers and no extra space, running in O(m+n) time and O(1) space.

2. Step 2: Compare other options

   Hash set membership check for intersection. uses extra space (hash set), Nested loops comparing all nodes pairwise. is O(m*n), Reverse lists and compare nodes from start. modifies lists and is inefficient.

3. Final Answer:

   Two-pointer switching heads method until pointers meet. -> Option A

4. Quick Check:

   Two-pointer method is optimal for intersection [OK]

Hint: Two-pointer switch method finds intersection efficiently [OK]

Common Mistakes:

• Using extra space unnecessarily
• Using nested loops causing slow performance
• Modifying lists destructively