Intersection Point of Two Linked Lists in DSA C++ - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a pointer to traverse the first linked list.

DSA C++

ListNode* current = [1];

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

Anullptr

BheadA

CheadB

DtailA

Attempts:

3 left

💡 Hint

Common Mistakes

Using the head of the second list instead of the first.

Initializing the pointer to nullptr which means no node.

We start traversing the first linked list from its head, which is headA.

2fill in blank

medium

Complete the code to move the pointer to the next node in the linked list.

DSA C++

current = current[1];

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

A->next

B.prev

C.next

D->prev

Attempts:

3 left

💡 Hint

Common Mistakes

Using prev which is for doubly linked lists.

Using dot operator instead of arrow operator for pointers.

To move forward in a singly linked list, we use the ->next pointer.

3fill in blank

hard

Fix the error in the condition to check if two pointers point to the same node.

DSA C++

if (ptrA [1] ptrB) {

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

A=>

B!=

C=

D==

Attempts:

3 left

💡 Hint

Common Mistakes

Using assignment operator instead of comparison.

Using incorrect comparison operators like =>.

To check if two pointers point to the same node, use the equality operator ==.

4fill in blank

hard

Fill both blanks to correctly advance pointers or reset them to the other list's head.

DSA C++

ptrA = ptrA ? ptrA[1] : [2];

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

A->next

BheadB

CheadA

D->prev

Attempts:

3 left

💡 Hint

Common Mistakes

Resetting to the same list's head instead of the other list.

Using incorrect pointer access like ->prev.

If ptrA is not null, move to the next node; otherwise, reset to the head of the other list headB.

5fill in blank

hard

Fill all three blanks to complete the function that finds the intersection node.

DSA C++

ListNode* getIntersectionNode(ListNode* headA, ListNode* headB) {
    ListNode* ptrA = headA;
    ListNode* ptrB = headB;
    while (ptrA != ptrB) {
        ptrA = ptrA ? ptrA[1] : [2];
        ptrB = ptrB ? ptrB[3] : headA;
    }
    return ptrA;
}

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

A->next

BheadB

DheadA

Attempts:

3 left

💡 Hint

Common Mistakes

Resetting pointers to the wrong heads.

Using incorrect pointer access operators.

This code moves each pointer forward if possible; otherwise, it resets to the head of the other list. This way, both pointers traverse equal lengths and meet at the intersection or null.

Practice

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

easy

A. The last node of each linked list.

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

C. The first node of the longer linked list.

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

Solution

1. Step 1: Understand linked list nodes

   Each node in a linked list has a value and a reference (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 D

4. Quick Check:

   Intersection means shared node reference = A [OK]

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

Common Mistakes:

• Confusing same value with same node reference
• Thinking intersection is the last node always
• Assuming intersection means equal length lists

2. Which of the following C++ code snippets correctly declares a singly linked list node structure for intersection detection?

easy

A. struct Node { int data; Node* next; };

B. struct Node { int data; Node next; };

C. struct Node { int data; Node* next(){}; };

D. struct Node { int data; Node next(); };

Solution

1. Step 1: Understand pointer usage in C++ structs

   A linked list node must have a pointer to the next node, so Node* next; is correct.

2. Step 2: Analyze options

   struct Node { int data; Node* next; }; uses Node* next; which is correct. Options A, B, and D misuse pointer or function syntax.

3. Final Answer:

   struct Node { int data; Node* next; }; -> Option A

4. Quick Check:

   Pointer to next node = C [OK]

Hint: Use pointer (*) for next node in struct [OK]

Common Mistakes:

• Forgetting the * pointer for next node
• Using function syntax instead of pointer
• Declaring next as object instead of pointer

3. Given two linked lists intersecting at node with value 7, what will the following code print?

Node* getIntersectionNode(Node* headA, Node* headB) {
    Node* a = headA;
    Node* b = headB;
    while (a != b) {
        a = a ? a->next : headB;
        b = b ? b->next : headA;
    }
    return a;
}

// Lists:
// A: 3 -> 6 -> 9 -> 7 -> 10
// B: 1 -> 7 -> 10

Node* intersection = getIntersectionNode(headA, headB);
if (intersection) std::cout << intersection->data << std::endl;
else std::cout << -1 << std::endl;

medium

A. -1

B. 10

C. 7

D. 3

Solution

1. Step 1: Understand the algorithm

   This code uses two pointers traversing both lists; when one reaches end, it switches to the other list's head. They meet at intersection.

2. Step 2: Trace the pointers

   Both pointers meet at node with value 7, which is the intersection point.

3. Final Answer:

   7 -> Option C

4. Quick Check:

   Intersection node data = 7 [OK]

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

Common Mistakes:

• Assuming intersection is node with value 10
• Printing -1 when intersection exists
• Confusing node value with node reference

4. Identify the bug in this code snippet that tries to find the intersection point of two linked lists:

Node* getIntersection(Node* headA, Node* headB) {
    while (headA != headB) {
        headA = headA->next;
        headB = headB->next;
    }
    return headA;
}

medium

A. It does not handle different list lengths, causing null pointer errors.

B. It uses incorrect comparison operator for nodes.

C. It returns the wrong node after loop ends.

D. It should use recursion instead of iteration.

Solution

1. Step 1: Analyze pointer movement

   The code moves both pointers forward simultaneously without adjusting for different list lengths.

2. Step 2: Identify consequence

   If lists differ in length, one pointer may reach null before the other, causing a null pointer dereference or infinite loop.

3. Final Answer:

   It does not handle different list lengths, causing null pointer errors. -> Option A

4. Quick Check:

   Unequal lengths cause errors = D [OK]

Hint: Adjust pointers for length difference before comparing [OK]

Common Mistakes:

• Ignoring list length difference
• Dereferencing null pointers
• Assuming simultaneous traversal always works

5. You have two singly linked lists that intersect. List A has length 8, List B has length 5. Which approach correctly finds the intersection point efficiently?

hard

A. Traverse both lists fully and store nodes in hash sets, then find first common node.

B. Calculate length difference, advance longer list by difference, then move both pointers together.

C. Reverse both lists and compare nodes from start until they differ.

D. Compare node values one by one from heads until a matching value is found.

Solution

1. Step 1: Understand length difference method

   Calculate difference (8 - 5 = 3), advance longer list by 3 nodes to align both lists.

2. Step 2: Traverse both lists together

   Move both pointers one step at a time; the first node where they match is the intersection.

3. Final Answer:

   Calculate length difference, advance longer list by difference, then move both pointers together. -> Option B

4. Quick Check:

   Align by length difference then traverse = B [OK]

Hint: Advance longer list by length difference before simultaneous traversal [OK]

Common Mistakes:

• Comparing node values instead of references
• Reversing lists unnecessarily
• Using extra space when not needed