Why Intersection Point of Two Linked Lists in DSA Python?

The Big Idea

Discover the clever trick that finds where two linked lists meet without checking every node!

The Scenario

Imagine you have two separate train tracks that suddenly merge into one track at some point. You want to find exactly where these two tracks join. Doing this by walking along each track and comparing every point manually would take a lot of time and effort.

The Problem

Manually checking each node of two linked lists to find where they intersect means comparing every node from the first list with every node from the second list. This is slow and tiring, especially if the lists are long. It's easy to make mistakes and miss the intersection point.

The Solution

Using the concept of the intersection point of two linked lists, we can cleverly find the exact node where the two lists merge without checking every pair. This method uses pointers that move through the lists and meet at the intersection, making the search fast and simple.

Before vs After

✗ Before

for node1 in list1:
    for node2 in list2:
        if node1 == node2:
            return node1
return None

✓ After

pointer1 = head1
pointer2 = head2
while pointer1 != pointer2:
    pointer1 = pointer1.next if pointer1 else head2
    pointer2 = pointer2.next if pointer2 else head1
return pointer1

What It Enables

This concept enables quick and efficient detection of where two linked lists merge, saving time and reducing errors.

Real Life Example

In social networks, two people's friend lists might overlap at some point. Finding the intersection helps identify common friends or shared connections quickly.

Key Takeaways

Manual comparison is slow and error-prone.

Using two pointers that switch lists finds the intersection efficiently.

This method works even if lists have different lengths.

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