Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

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 <bits/stdc++.h>
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<Integer,Integer> mp = new HashMap<Integer,Integer>();
    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<Integer,Integer> it :mp.entrySet())
    {
        if (it.getValue() <= min_frequency)
        {
            min_frequency = it.getValue();
        }
    }
 
    // Find count of min frequency elements
    for (Map.Entry<Integer,Integer> 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




<script>
      // JavaScript program to find count of minimum
      // frequency elements in Linked list
      /* Link list node */
      class Node {
        constructor() {
          this.key = 0;
          this.next = null;
        }
      }
 
      /* 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. */
      function push(head_ref, new_key) {
        var 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
      function countMinimum(head) {
        // Store frequencies of all nodes.
        var mp = {};
 
        var current = head;
        while (current != null) {
          var data = current.key;
          var val = 0;
          mp[data] = !mp.hasOwnProperty(data) ? 1 : mp[data] + 1;
          current = current.next;
        }
 
        // Find min frequency
        current = head;
        var min_frequency = 2147483647,
          countMin = 0;
        for (const [key, value] of Object.entries(mp)) {
          if (value <= min_frequency) {
            min_frequency = value;
          }
        }
 
        // Find count of min frequency elements
        for (const [key, value] of Object.entries(mp)) {
          if (value == min_frequency) {
            countMin += value;
          }
        }
 
        return countMin;
      }
 
      /* Driver code*/
      /* Start with the empty list */
      var head = null;
      var 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);
 
      document.write(countMinimum(head) + "<br>");
       
      // This code is contributed by rdtank.
    </script>
Output: 
2

 

Time Complexity : O(n)
 




My Personal Notes arrow_drop_up
Recommended Articles
Page :