# Count minimum frequency elements in a linked list

• Difficulty Level : Hard
• Last Updated : 27 Oct, 2021

Given a linked list containing duplicate elements. The task is to find the count of all minimum occurring elements in the given linked list. That is the count of all such elements whose frequency is minimum in the matrix.
Examples

```Input : 1-> 2-> 2-> 3
Output : 2
Explanation:
1 and 3 are elements occurs only one time.
So, count is 2.

Input : 10-> 20-> 20-> 10-> 30
Output : 1```

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Approach:

• Traverse the linked list and use a hash table to store the frequency of elements of the linked list such that the key of map is the linked list element and value is its frequency in the linked list.
• Then traverse the hash table to find the minimum frequency.
• Finally, traverse the hash table to find the frequency of elements and check if it matches with the minimum frequency obtained in previous step, if yes, then add this frequency to count.

Below is the implementation of the above approach:

## C++

 `// C++ program to find count of minimum``// frequency elements in Linked list``#include ``using` `namespace` `std;` `/* Link list node */``struct` `Node {``    ``int` `key;``    ``struct` `Node* next;``};` `/* Given a reference (pointer to pointer) to the head``of a list and an int, push a new node on the front``of the list. */``void` `push(``struct` `Node** head_ref, ``int` `new_key)``{``    ``struct` `Node* new_node = ``new` `Node;``    ``new_node->key = new_key;``    ``new_node->next = (*head_ref);``    ``(*head_ref) = new_node;``}` `// Function to count minimum frequency elements``// in the linked list``int` `countMinimum(``struct` `Node* head)``{``    ``// Store frequencies of all nodes.``    ``unordered_map<``int``, ``int``> mp;``    ``struct` `Node* current = head;``    ``while` `(current != NULL) {``        ``int` `data = current->key;``        ``mp[data]++;``        ``current = current->next;``    ``}` `    ``// Find min frequency``    ``current = head;``    ``int` `min_frequency = INT_MAX, countMin = 0;``    ``for` `(``auto` `it = mp.begin(); it != mp.end(); it++) {``        ``if` `(it->second <= min_frequency) {``            ``min_frequency = it->second;``        ``}``    ``}` `    ``// Find count of min frequency elements``    ``for` `(``auto` `it = mp.begin(); it != mp.end(); it++) {``        ``if` `(it->second == min_frequency) {``            ``countMin += (it->second);``        ``}``    ``}` `    ``return` `countMin;``}` `/* Driver program to test count function*/``int` `main()``{``    ``/* Start with the empty list */``    ``struct` `Node* head = NULL;``    ``int` `x = 21;` `    ``/* Use push() to construct below list``    ``10->10->11->30->10 */``    ``push(&head, 10);``    ``push(&head, 30);``    ``push(&head, 11);``    ``push(&head, 10);``    ``push(&head, 10);` `    ``cout << countMinimum(head) << endl;``    ``return` `0;``}`

## Java

 `// Java program to find count of minimum``// frequency elements in Linked list``import` `java.util.*;` `class` `GFG``{` `/* Link list node */``static` `class` `Node {``    ``int` `key;``    ``Node next;``};` `/* Given a reference (pointer to pointer) to the head``of a list and an int, push a new node on the front``of the list. */``static` `Node push(Node head_ref, ``int` `new_key)``{``    ``Node new_node = ``new` `Node();``    ``new_node.key = new_key;``    ``new_node.next = (head_ref);``    ``(head_ref) = new_node;``    ``return` `head_ref;``}` `// Function to count minimum frequency elements``// in the linked list``static` `int` `countMinimum( Node head)``{``    ``// Store frequencies of all nodes.``    ``HashMap mp = ``new` `HashMap();``    ``Node current = head;``    ``while` `(current != ``null``)``    ``{``        ``int` `data = current.key;``        ``mp.put(data, (mp.get(data) == ``null` `? ``1``:mp.get(data) + ``1``));``        ``current = current.next;``    ``}` `    ``// Find min frequency``    ``current = head;``    ``int` `min_frequency = Integer.MAX_VALUE, countMin = ``0``;``    ``for` `(Map.Entry it :mp.entrySet())``    ``{``        ``if` `(it.getValue() <= min_frequency)``        ``{``            ``min_frequency = it.getValue();``        ``}``    ``}` `    ``// Find count of min frequency elements``    ``for` `(Map.Entry it :mp.entrySet())``    ``{``        ``if` `(it.getValue() == min_frequency)``        ``{``            ``countMin += (it.getValue());``        ``}``    ``}` `    ``return` `countMin;``}` `/* Driver code*/``public` `static` `void` `main(String args[])``{``    ``/* Start with the empty list */``    ``Node head = ``null``;``    ``int` `x = ``21``;` `    ``/* Use push() to construct below list``    ``10.10.11.30.10 */``    ``head = push(head, ``10``);``    ``head = push(head, ``30``);``    ``head = push(head, ``11``);``    ``head = push(head, ``10``);``    ``head = push(head, ``10``);` `    ``System.out.println( countMinimum(head) );``}``}` `// This code is contributed by andrew1234`

## Python3

 `# Python3 program to find count of minimum``# frequency elements in Linked list``import` `sys``import` `math` `# Link list node``class` `Node:``    ``def` `__init__(``self``,data):``        ``self``.data ``=` `data``        ``self``.``next` `=` `None` `# Given a reference (pointer to pointer) to the head``# of a list and an int, push a new node on the front``# of the list.``def` `push(head,data):``    ``if` `not` `head:``        ``return` `Node(data)``    ``temp ``=` `Node(data)``    ``temp.``next` `=` `head``    ``head ``=` `temp``    ``return` `head` `# Function to count minimum frequency elements``# in the linked list``def` `countMinimun(head):``    ` `    ``# Store frequencies of all nodes.``    ``freq ``=` `{}``    ``temp ``=` `head``    ``while``(temp):``        ``d ``=` `temp.data``        ``if` `d ``in` `freq:``            ``freq[d] ``=` `freq.get(d) ``+` `1``        ``else``:``            ``freq[d] ``=` `1``        ``temp ``=` `temp.``next``    ` `    ``# Find min frequency``    ``minimum_freq ``=` `sys.maxsize``    ``for` `i ``in` `freq:``        ``minimum_freq ``=` `min``(minimum_freq, freq.get(i))``    ` `    ``# Find count of min frequency elements``    ``countMin ``=` `0``    ``for` `i ``in` `freq:``        ``if` `freq.get(i) ``=``=` `minimum_freq:``            ``countMin ``+``=` `1``    ``return` `countMin` `# Driver program to test count function #``if` `__name__``=``=``'__main__'``:` `    ``# Start with the empty list``    ``head ``=` `None``    ` `    ``# Use push() to construct below list``    ``#10->10->11->30->10``    ``head ``=` `push(head,``10``)``    ``head ``=` `push(head,``30``)``    ``head ``=` `push(head,``11``)``    ``head ``=` `push(head,``10``)``    ``head ``=` `push(head,``10``)` `    ``print``(countMinimun(head))` `# This code is Contribute by Vikash Kumar 37`

## C#

 `// C# program to find count of minimum``// frequency elements in Linked list``using` `System;``using` `System.Collections.Generic;` `class` `GFG``{` `/* Link list node */``public` `class` `Node {``    ``public` `int` `key;``    ``public` `Node next;``};` `/* Given a reference (pointer to pointer) to the head``of a list and an int, push a new node on the front``of the list. */``static` `Node push(Node head_ref, ``int` `new_key)``{``    ``Node new_node = ``new` `Node();``    ``new_node.key = new_key;``    ``new_node.next = (head_ref);``    ``head_ref = new_node;``    ``return` `head_ref;``}` `// Function to count minimum frequency elements``// in the linked list``static` `int` `countMinimum( Node head)``{``    ``// Store frequencies of all nodes.``    ``IDictionary<``int``,``int``> mp = ``new` `Dictionary<``int``,``int``>();``    ` `    ``Node current = head;``    ``while` `(current != ``null``)``    ``{``        ``int` `data = current.key;``        ``int` `val = 0;``        ``mp[data] = (!mp.TryGetValue(data,``out` `val)  ? 1:mp[data]+ 1);``        ``current = current.next;``    ``}` `    ``// Find min frequency``    ``current = head;``    ``int` `min_frequency = ``int``.MaxValue, countMin = 0;``    ``foreach` `(KeyValuePair<``int``, ``int``> it ``in` `mp)``    ``{``        ``if` `(it.Value <= min_frequency)``        ``{``            ``min_frequency = it.Value;``        ``}``    ``}` `    ``// Find count of min frequency elements``    ``foreach` `(KeyValuePair<``int``, ``int``> it ``in` `mp)``    ``{``        ``if` `(it.Value == min_frequency)``        ``{``            ``countMin += (it.Value);``        ``}``    ``}` `    ``return` `countMin;``}` `/* Driver code*/``public` `static` `void` `Main()``{``    ``/* Start with the empty list */``    ``Node head = ``null``;``    ``int` `x = 21;` `    ``/* Use push() to construct below list``    ``10.10.11.30.10 */``    ``head = push(head, 10);``    ``head = push(head, 30);``    ``head = push(head, 11);``    ``head = push(head, 10);``    ``head = push(head, 10);` `    ``Console.WriteLine( countMinimum(head) );``}``}` `// This code is contributed by SoumikMondal`

## Javascript

 ``
Output:
`2`

Time Complexity : O(n)

My Personal Notes arrow_drop_up