Intersection Point of Two Linked Lists in DSA Python - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to return the node where two linked lists intersect.

DSA Python

def getIntersectionNode(headA, headB):
    while headA and headB and headA != headB:
        headA = headA.next
        headB = headB.next
    return [1]

Drag options to blanks, or click blank then click option'

AheadA.next

BheadA

CheadB

DNone

Attempts:

3 left

💡 Hint

Common Mistakes

Returning headB instead of headA

Returning None prematurely

Returning headA.next which may be None

The function returns the intersection node, which is headA when both pointers meet.

2fill in blank

medium

Complete the code to switch the pointer to the other list when it reaches the end.

DSA Python

def getIntersectionNode(headA, headB):
    a, b = headA, headB
    while a != b:
        a = a.next if a else [1]
        b = b.next if b else headA
    return a

Drag options to blanks, or click blank then click option'

ANone

BheadA

CheadB

Da

Attempts:

3 left

💡 Hint

Common Mistakes

Switching to headA instead of headB

Not switching pointer at all

Using None instead of headB

When pointer a reaches the end of list A, it switches to head of list B.

3fill in blank

hard

Fix the error in the loop condition to correctly detect intersection.

DSA Python

def getIntersectionNode(headA, headB):
    a, b = headA, headB
    while [1]:
        a = a.next if a else headB
        b = b.next if b else headA
    return a

Drag options to blanks, or click blank then click option'

Aa != b

Ba or b

Ca and b

Da == b

Attempts:

3 left

💡 Hint

Common Mistakes

Using equality in the loop condition

Using logical and/or incorrectly

Infinite loop due to wrong condition

The loop continues while pointers a and b are not equal.

4fill in blank

hard

Fill both blanks to create a loop that moves pointers or switches lists.

DSA Python

def getIntersectionNode(headA, headB):
    a, b = headA, headB
    while a != b:
        a = a[1] if a else [2]
        b = b.next if b else headA
    return a

Drag options to blanks, or click blank then click option'

A.next

BheadB

CheadA

DNone

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong attribute instead of .next

Switching to headA instead of headB

Using None instead of list head

Pointer a moves to a.next or switches to headB if it reaches the end.

5fill in blank

hard

Fill all three blanks to create a dictionary comprehension filtering nodes by value.

DSA Python

def filterNodes(nodes):
    return [1]: [2] for node in nodes if node.val [3] 10

Drag options to blanks, or click blank then click option'

Anode.val

Bnode

C>

D<

Attempts:

3 left

💡 Hint

Common Mistakes

Using node instead of node.val as key

Using wrong comparison operator

Not filtering nodes correctly

The comprehension creates a dictionary with keys as node values and values as nodes, filtering nodes with value greater than 10.

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