Linked List Components - Practice Coding Problems

Linked List Components - Problem

Imagine you have a linked list like a chain of connected nodes, where each node contains a unique integer value. You're also given an array nums that contains some of these values (but not necessarily all of them).

Your task is to find how many connected components exist in the linked list for the values in nums. Two values form a connected component if they appear consecutively in the linked list and both values are present in the nums array.

Example: If your linked list is 0→1→2→3 and nums = [0, 1, 3], then:

Values 0 and 1 are consecutive and both in nums → 1 component
Value 3 is in nums but not connected to others → 1 component
Total: 2 components

Return the total number of connected components.

Input & Output

example_1.py — Basic Components

$ Input: head = [0,1,2,3], nums = [0,1,3]

› Output: 2

💡 Note: Values 0 and 1 form one connected component since they're consecutive in the linked list and both exist in nums. Value 3 forms another component by itself. Value 2 is ignored since it's not in nums.

example_2.py — Single Component

$ Input: head = [0,1,2,3,4], nums = [0,3,1,4]

› Output: 2

💡 Note: Values 0 and 1 are consecutive and both in nums (component 1). Values 3 and 4 are consecutive and both in nums (component 2). Value 2 breaks the sequence between them.

example_3.py — All Isolated

$ Input: head = [0,1,2,3], nums = [0,2]

› Output: 2

💡 Note: Values 0 and 2 are both in nums but not consecutive in the linked list (separated by value 1), so they form 2 separate components.

Constraints

The number of nodes in the linked list is in the range [1, 10⁴]
0 ≤ Node.val < 10⁴
All values in the linked list are unique
1 ≤ nums.length ≤ 10⁴
0 ≤ nums[i] < 10⁴
All values in nums are unique
nums is a subset of all values in the linked list

Visualization

Tap to expand

Understanding the Visualization

Build lookup table

Convert nums array to hash set for fast lookups

Traverse the chain

Walk through linked list checking each node

Count sequences

Increment counter when starting new component

Key Takeaway

🎯 Key Insight: Use a hash set for O(1) lookups and count components by tracking when we start new consecutive sequences from nums in the linked list traversal.

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

The optimal solution uses a hash set to convert the nums array for O(1) lookups, then traverses the linked list once to count connected components. Key insight: only increment the component counter when starting a new sequence of consecutive values that exist in nums.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Hash Set (Optimal)	O(n + m)	O(m)	Convert nums to hash set for O(1) lookups while traversing linked list
Brute Force (Linear Search)	O(n*m)	O(1)	For each node, check if it's in nums using linear search

One-Pass Hash Set (Optimal) — Algorithm Steps

Convert nums array to hash set for O(1) lookups
Traverse linked list once from head to tail
For each node, check if value exists in hash set
Increment component count when starting new consecutive sequence
Track whether currently in a component to avoid double-counting

Visualization

Tap to expand

Step-by-Step Walkthrough

Build hash set

Convert nums array to hash set

Single traversal

Walk through linked list once

O(1) lookups

Check membership in constant time

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

struct ListNode {
    int val;
    struct ListNode *next;
};

// Simple hash set implementation for this problem
bool contains(int* nums, int numsSize, int target) {
    for (int i = 0; i < numsSize; i++) {
        if (nums[i] == target) return true;
    }
    return false;
}

int numComponents(struct ListNode* head, int* nums, int numsSize) {
    int components = 0;
    struct ListNode* current = head;
    bool inComponent = false;
    
    while (current) {
        if (contains(nums, numsSize, current->val)) {
            // Start new component if not already in one
            if (!inComponent) {
                components++;
                inComponent = true;
            }
        } else {
            // End current component
            inComponent = false;
        }
        
        current = current->next;
    }
    
    return components;
}

int main() {
    printf("Solution implemented\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + m)

n nodes to traverse + m elements to build hash set, each lookup is O(1)

✓ Linear Growth

Space Complexity

O(m)

Hash set stores m elements from nums array

✓ Linear Space

28.4K Views

Medium Frequency

~15 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

One-Pass Hash Set (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler