Linked List Frequency - Practice Coding Problems

Linked List Frequency - Problem

You're given the head of a linked list containing various elements. Your task is to count how many times each distinct element appears and return a new linked list containing these frequency counts.

For example, if your linked list contains [1, 2, 1, 3, 2, 1], you need to:

Count frequencies: 1 appears 3 times, 2 appears 2 times, 3 appears 1 time
Return a new linked list with values [3, 2, 1] (in any order)

The order of frequencies in the result doesn't matter - focus on getting the correct counts!

Input & Output

example_1.py — Basic Example

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

› Output: [3,2,1]

💡 Note: Element 1 appears 3 times, element 2 appears 2 times, element 3 appears 1 time. The result can be in any order.

example_2.py — All Unique Elements

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

› Output: [1,1,1]

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

example_3.py — Single Element

$ Input: head = [7]

› Output: [1]

💡 Note: Only one element with frequency 1.

Constraints

The number of nodes in the list is in the range [0, 10⁴]
-1000 ≤ Node.val ≤ 1000
The list contains k distinct elements where k ≥ 1
The result list should contain exactly k nodes

Visualization

Tap to expand

Understanding the Visualization

Initialize

Start with empty hash map and result list pointers

Process Elements

For each element: if new, create result node; if seen, update existing node

Maintain Mapping

Hash map tracks both frequency count and pointer to corresponding result node

Return Result

After single traversal, return head of frequency list

Key Takeaway

🎯 Key Insight: By storing both frequency counts AND pointers to result nodes in our hash map, we can update frequencies in real-time during a single traversal, achieving optimal O(n) time complexity.

Asked in

G Google 42 a Amazon 38 f Meta 29 ⊞ Microsoft 25

The optimal solution uses a one-pass hash table approach with O(n) time and O(k) space complexity. We maintain both a frequency counter and pointers to result nodes, allowing us to update frequencies in real-time as we traverse the original linked list. This eliminates the need for multiple passes while building the result efficiently.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Hash Table with List Building (Optimal)	O(n)	O(k)	Count frequencies and build result list simultaneously in one traversal
Brute Force (Nested Loops)	O(n²)	O(n)	For each node, traverse the entire list to count occurrences
Two-Pass Hash Table	O(n)	O(k)	First pass counts frequencies, second pass builds result linked list

One-Pass Hash Table with List Building (Optimal) — Algorithm Steps

Initialize empty hash map and result list pointers
Traverse original list once: for each element, update frequency in hash map
Maintain mapping from elements to their corresponding frequency nodes in result list
When frequency changes, update the corresponding node value in result list
Return head of result list after single traversal

Visualization

Tap to expand

Step-by-Step Walkthrough

Process 1

First occurrence of 1: create frequency=1 node, add to result

Process 2

First occurrence of 2: create frequency=1 node, append to result

Process 1 Again

Second occurrence of 1: update existing node value to 2

Complete

Continue updating frequencies in-place as we traverse

Code -

solution.c — C

// Definition for singly-linked list
struct ListNode {
    int val;
    struct ListNode *next;
};

// Hash table implementation
#define HASH_SIZE 1000

struct HashEntry {
    int key;
    int frequency;
    struct ListNode* resultNode;
    int used;
};

struct ListNode* frequencyOfElements(struct ListNode* head) {
    if (!head) return NULL;
    
    struct HashEntry hashTable[HASH_SIZE] = {0};
    struct ListNode* resultHead = NULL;
    struct ListNode* resultTail = NULL;
    
    struct ListNode* current = head;
    while (current) {
        int element = current->val;
        int hash = ((element % HASH_SIZE) + HASH_SIZE) % HASH_SIZE;
        
        // Linear probing
        while (hashTable[hash].used && hashTable[hash].key != element) {
            hash = (hash + 1) % HASH_SIZE;
        }
        
        if (hashTable[hash].used) {
            // Update existing frequency
            hashTable[hash].frequency++;
            hashTable[hash].resultNode->val = hashTable[hash].frequency;
        } else {
            // First occurrence - create new result node
            hashTable[hash].key = element;
            hashTable[hash].frequency = 1;
            hashTable[hash].used = 1;
            
            struct ListNode* newNode = malloc(sizeof(struct ListNode));
            newNode->val = 1;
            newNode->next = NULL;
            hashTable[hash].resultNode = newNode;
            
            // Add to result list
            if (!resultHead) {
                resultHead = newNode;
                resultTail = newNode;
            } else {
                resultTail->next = newNode;
                resultTail = newNode;
            }
        }
        
        current = current->next;
    }
    
    return resultHead;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single traversal of the linked list with O(1) hash operations

✓ Linear Growth

Space Complexity

O(k)

Hash map + result list store at most k distinct elements

✓ Linear Space

42.4K Views

Medium-High Frequency

~18 min Avg. Time

1.8K 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 Table with List Building (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler