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.