Linked List Components

Linked List Components - Problem

You are given the head of a linked list containing unique integer values and an integer array nums that is a subset of the linked list values.

Return the number of connected components in nums where two values are connected if they appear consecutively in the linked list.

A connected component is a maximal group of consecutive nodes whose values are all present in nums.

Input & Output

Example 1 — Basic Connected Components

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

› Output: 1

💡 Note: The linked list is 0→1→2→3. All values [0,1,2,3] are present in nums and appear consecutively in the linked list, forming one connected component.

Example 2 — Separate Components

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

› Output: 2

💡 Note: Linked list: 0→1→2→3→4. Node 0 is in nums (start component 1), node 1 is in nums (continue component 1), node 2 is not in nums (end component 1), node 3 is in nums (start component 2), node 4 is in nums (continue component 2). Result: 2 components.

Example 3 — Single Component

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

› Output: 1

💡 Note: Node 0 not in nums, nodes 1,2,3 are consecutive in nums forming one component, node 4 not in nums. Only one connected component.

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

Visualization

Tap to expand

Asked in

F Facebook 3 M Microsoft 2

The key insight is to use a hash set for O(1) value lookups and count component starts when transitioning from not-found to found. Best approach is hash set optimization with Time: O(n + m), Space: O(m).

Common Approaches

✓ Dp 1d

⏱️ Time: N/A Space: N/A

Brute Force - Array Search

⏱️ Time: O(n×m) Space: O(1)

Traverse the linked list and for each node, linearly search through the nums array to check if the current value exists. Count components by tracking when we enter and exit sequences of found values.

Hash Set Optimization

⏱️ Time: O(n + m) Space: O(m)

Convert the nums array to a hash set for constant time lookups. Then traverse the linked list once, checking if each node's value exists in the set. Count components by tracking when we transition from not-found to found.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define MAX_SIZE 1000

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

struct ListNode* buildLinkedList(int* vals, int size) {
    if (size == 0) return NULL;
    
    struct ListNode* head = malloc(sizeof(struct ListNode));
    head->val = vals[0];
    head->next = NULL;
    
    struct ListNode* current = head;
    for (int i = 1; i < size; i++) {
        current->next = malloc(sizeof(struct ListNode));
        current = current->next;
        current->val = vals[i];
        current->next = NULL;
    }
    
    return head;
}

int numComponents(struct ListNode* head, int* nums, int numsSize) {
    bool numSet[MAX_SIZE] = {false};
    
    // Mark all numbers in nums as present
    for (int i = 0; i < numsSize; i++) {
        if (nums[i] >= 0 && nums[i] < MAX_SIZE) {
            numSet[nums[i]] = true;
        }
    }
    
    int components = 0;
    bool inComponent = false;
    
    struct ListNode* current = head;
    while (current != NULL) {
        if (current->val >= 0 && current->val < MAX_SIZE && numSet[current->val]) {
            if (!inComponent) {
                components++;
                inComponent = true;
            }
        } else {
            inComponent = false;
        }
        current = current->next;
    }
    
    return components;
}

int parseArray(char* line, int* arr) {
    int count = 0;
    char* ptr = line;
    
    // Skip opening bracket
    while (*ptr && *ptr != '[') ptr++;
    if (*ptr == '[') ptr++;
    
    while (*ptr) {
        // Skip whitespace and commas
        while (*ptr && (*ptr == ' ' || *ptr == ',' || *ptr == '\n' || *ptr == '\r')) ptr++;
        
        if (*ptr == ']' || *ptr == '\0') break;
        
        // Parse number
        char* endptr;
        long val = strtol(ptr, &endptr, 10);
        if (endptr != ptr) {
            arr[count++] = (int)val;
            ptr = endptr;
        } else {
            ptr++;
        }
    }
    
    return count;
}

int main() {
    char line[2000];
    int headVals[MAX_SIZE];
    int nums[MAX_SIZE];
    
    // Read head array
    fgets(line, sizeof(line), stdin);
    int headSize = parseArray(line, headVals);
    
    // Read nums array
    fgets(line, sizeof(line), stdin);
    int numsSize = parseArray(line, nums);
    
    struct ListNode* head = buildLinkedList(headVals, headSize);
    int result = numComponents(head, nums, numsSize);
    
    printf("%d\n", result);
    
    // Free memory
    while (head) {
        struct ListNode* temp = head;
        head = head->next;
        free(temp);
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

23.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