Linked List Frequency

Linked List Frequency - Problem

Given the head of a linked list containing k distinct elements, return the head to a linked list of length k containing the frequency of each distinct element in the given linked list in any order.

The frequency of an element is the number of times it appears in the linked list.

Example: If the linked list is [1→2→1→3→2→2], the frequencies are: 1 appears 2 times, 2 appears 3 times, 3 appears 1 time. Return a linked list containing [2→3→1] (frequencies in any order).

Input & Output

Example 1 — Basic Case

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

› Output: [2,3,1]

💡 Note: Element 1 appears 2 times, element 2 appears 3 times, element 3 appears 1 time. Return frequencies in any order.

Example 2 — All Unique

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

› Output: [1,1,1]

💡 Note: Each element appears exactly once, so all frequencies are 1.

Example 3 — All Same

$ Input: head = [5,5,5,5]

› Output: [4]

💡 Note: Only one distinct element (5) appears 4 times, so return [4].

Constraints

1 ≤ length of linked list ≤ 10⁵
-10⁵ ≤ Node.val ≤ 10⁵
The linked list contains exactly k distinct elements

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8 f Facebook 6

Use a hash map to count element frequencies in a single pass through the linked list, then build a result linked list containing these frequency counts. The optimal approach has O(n) time and O(k) space complexity.

Common Approaches

✓ Optimized

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

Brute Force - Count Each Element Separately

⏱️ Time: O(n²) Space: O(k)

First collect all unique elements, then for each unique element traverse the entire linked list to count how many times it appears. Finally build result linked list with these counts.

Hash Map - Single Pass Frequency Count

⏱️ Time: O(n) Space: O(k)

Traverse the linked list once to count frequency of each element using a hash map. Then create a new linked list containing these frequency counts in any order.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

typedef struct {
    int n;
    bool* uploaded;
    int prefixLen;
} LUPrefix;

LUPrefix* createLUPrefix(int n) {
    LUPrefix* obj = (LUPrefix*)malloc(sizeof(LUPrefix));
    obj->n = n;
    obj->uploaded = (bool*)calloc(n + 1, sizeof(bool));
    obj->prefixLen = 0;
    return obj;
}

void upload(LUPrefix* obj, int video) {
    obj->uploaded[video] = true;
    // Extend prefix if possible
    while (obj->prefixLen + 1 <= obj->n && obj->uploaded[obj->prefixLen + 1]) {
        obj->prefixLen++;
    }
}

int longest(LUPrefix* obj) {
    return obj->prefixLen;
}

void freeLUPrefix(LUPrefix* obj) {
    free(obj->uploaded);
    free(obj);
}

int main() {
    char line[10000];
    if (fgets(line, sizeof(line), stdin)) {
        // Simple parsing for the operations
        char* results[1000];
        int resultCount = 0;
        
        LUPrefix* luprefix = NULL;
        
        // Parse basic operations from input
        char* ptr = line;
        while (*ptr) {
            if (strncmp(ptr, "LUPrefix", 8) == 0) {
                // Find the number after LUPrefix
                while (*ptr && (*ptr < '0' || *ptr > '9')) ptr++;
                int n = 0;
                while (*ptr >= '0' && *ptr <= '9') {
                    n = n * 10 + (*ptr - '0');
                    ptr++;
                }
                if (luprefix) freeLUPrefix(luprefix);
                luprefix = createLUPrefix(n);
                results[resultCount++] = "null";
            } else if (strncmp(ptr, "upload", 6) == 0) {
                // Find the number after upload
                while (*ptr && (*ptr < '0' || *ptr > '9')) ptr++;
                int video = 0;
                while (*ptr >= '0' && *ptr <= '9') {
                    video = video * 10 + (*ptr - '0');
                    ptr++;
                }
                upload(luprefix, video);
                results[resultCount++] = "null";
            } else if (strncmp(ptr, "longest", 7) == 0) {
                char* result = (char*)malloc(20);
                sprintf(result, "%d", longest(luprefix));
                results[resultCount++] = result;
                ptr += 7;
            } else {
                ptr++;
            }
        }
        
        // Print results
        printf("[");
        for (int i = 0; i < resultCount; i++) {
            if (i > 0) printf(",");
            printf("%s", results[i]);
        }
        printf("]\n");
        
        // Clean up
        if (luprefix) freeLUPrefix(luprefix);
        for (int i = 0; i < resultCount; i++) {
            if (strcmp(results[i], "null") != 0) {
                free(results[i]);
            }
        }
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

23.4K Views

Medium Frequency

~15 min Avg. Time

890 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