Cumulative frequency of count of each element in an unsorted array

Given an unsorted array. The task is to calculate the cumulative frequency of each element of the array using count array.

Examples:

Input : arr[] = [1, 2, 2, 1, 3, 4]
Output :1->2
        2->4
        3->5
        4->6

Input : arr[] = [1, 1, 1, 2, 2, 2]
Output :1->3
        2->6

A simple solution is to use two nested loops, the outer loops picks an element from left to right that are not visited. The inner loop counts its occurrences and mark occurrences as visited. Time complexity of this solution is O(n*n) and auxiliary space required is O(n).



A better solution is to use sorting. We sort the array so that same elements come together. After sorting, we linearly traverse elements and count their frequencies.

An efficient solution is to use hashing. Insert the element and its frequency in a set of pairs. As the set stores unique values in a sorted order, it will store all the elements with their frequencies in a sorted order. Iterate in the set and print the frequencies by adding the previous ones at every step.

Below is the implementation of the above approach.

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// CPP program to count cumlative
// frequencies of elements in an unsorted array.
#include <bits/stdc++.h>
using namespace std;
  
void countFreq(int a[], int n)
{
    // Insert elements and their
    // frequencies in hash map.
    unordered_map<int, int> hm;
    for (int i = 0; i < n; i++)
        hm[a[i]]++;
  
    // Declare a set
    set<pair<int, int> > st;
  
    // insert the element and
    // and insert its frequency in a set
    for (auto x : hm) {
        st.insert({ x.first, x.second });
    }
  
    int cumul = 0;
  
    // iterate the set and print the
    // cumulative frequency
    for (auto x : st) {
        cumul += x.second;
        cout << x.first << " " << cumul << endl;
    }
}
  
// Driver Code
int main()
{
    int a[] = { 1, 3, 2, 4, 2, 1 };
    int n = sizeof(a) / sizeof(a[0]);
    countFreq(a, n);
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to count cumlative 
// frequencies of elements in an unsorted array. 
import java.util.*;
  
class GFG 
{
    static void countFreq(int[] a, int n) 
    {
  
        // Insert elements and their
        // frequencies in hash map.
        HashMap<Integer, 
                Integer> hm = new HashMap<>();
        for (int i = 0; i < n; i++)
            hm.put(a[i], hm.get(a[i]) == null
                     1 : hm.get(a[i]) + 1);
  
        // Declare a Map
        SortedMap<Integer, Integer> st = new TreeMap<>();
  
        // insert the element and
        // and insert its frequency in a set
        for (HashMap.Entry<Integer,
                           Integer> x : hm.entrySet()) 
        {
            st.put(x.getKey(), x.getValue());
        }
  
        int cumul = 0;
  
        // iterate the set and print the
        // cumulative frequency
        for (SortedMap.Entry<Integer, 
                             Integer> x : st.entrySet())
        {
            cumul += x.getValue();
            System.out.println(x.getKey() + " " + cumul);
        }
    }
  
    // Driver Code
    public static void main(String[] args) 
    {
        int[] a = { 1, 3, 2, 4, 2, 1 };
        int n = a.length;
        countFreq(a, n);
    }
}
  
// This code is contributed by
// sanjeev2552

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 program to count cumlative 
# frequencies of elements in an unsorted array. 
def countFreq(a, n): 
  
    # Insert elements and their 
    # frequencies in hash map. 
    hm = {} 
    for i in range(0, n): 
        hm[a[i]] = hm.get(a[i], 0) + 1
  
    # Declare a set 
    st = set() 
  
    # Insert the element and 
    # its frequency in a set 
    for x in hm: 
        st.add((x, hm[x])) 
  
    cumul = 0
  
    # Iterate the set and print 
    # the cumulative frequency 
    for x in sorted(st): 
        cumul += x[1
        print(x[0], cumul) 
  
# Driver Code 
if __name__ == "__main__":
  
    a = [1, 3, 2, 4, 2, 1
    n = len(a) 
    countFreq(a, n)
      
# This code is contributed by Rituraj Jain

chevron_right


Output:

1 2
2 4
3 5
4 6

Time complexity of the solution is O(n log n).

What if we need frequencies of elements according to the order of the first occurrence?
For example, an array [2, 4, 1, 2, 1, 3, 4], the frequency of 2 should be printed first, then of 4, then 1 and finally 3.
Approach: Hash the count of occurrences of an element. Traverse in the array and print the cumulative frequency. Once the element and its cumulative frequency has been printed, hash the occurrence of that element as 0 so that it not printed again if it appears in the latter half of array while traversal.

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// CPP program to print the cumulative frequency 
// according to the order given 
#include <bits/stdc++.h>
using namespace std;
  
// Function to print the cumulative frequency 
// according to the order given 
void countFreq(int a[], int n)
{
    // Insert elements and their 
    // frequencies in hash map.
    unordered_map<int, int> hm;
    for (int i=0; i<n; i++)
        hm[a[i]]++;
    int cumul = 0;
      
   // traverse in the array 
   for(int i=0;i<n;i++)
   {
       // add the frequencies 
       cumul += hm[a[i]]; 
         
       // if the element has not been 
       // visited previously 
       if(hm[a[i]])
       {
           cout << a[i] << "->" << cumul << endl;
       }
       // mark the hash 0 
       // as the element's cumulative frequency 
       // has been printed 
       hm[a[i]]=0;
   }
}
  
// Driver Code
int main()
{
    int a[] = {1, 3, 2, 4, 2, 1};
    int n = sizeof(a)/sizeof(a[0]);
    countFreq(a, n);
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to print the cumulative frequency 
// according to the order given 
class GFG
{
  
// Function to print the cumulative frequency 
// according to the order given 
static void countFreq(int a[], int n)
{
    // Insert elements and their 
    // frequencies in hash map.
    int hm[] = new int[n];
    for (int i = 0; i < n; i++)
        hm[a[i]]++;
    int cumul = 0;
      
// traverse in the array 
for(int i = 0; i < n; i++)
{
    // add the frequencies 
    cumul += hm[a[i]]; 
          
    // if the element has not been 
    // visited previously 
    if(hm[a[i]] != 0)
    {
        System.out.println(a[i] + "->" + cumul);
    }
    // mark the hash 0 
    // as the element's cumulative frequency 
    // has been printed 
    hm[a[i]] = 0;
}
}
  
// Driver Code
public static void main(String[] args) 
{
    int a[] = {1, 3, 2, 4, 2, 1};
    int n = a.length;
    countFreq(a, n);
}
  
// This code has been contributed by 29AjayKumar

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 program to print the cumulative 
# frequency according to the order given
  
# Function to print the cumulative frequency
# according to the order given
def countFreq(a, n):
  
    # Insert elements and their
    # frequencies in hash map.
    hm = dict()
    for i in range(n):
        hm[a[i]] = hm.get(a[i], 0) + 1
  
    cumul = 0
  
    # traverse in the array
    for i in range(n):
  
    # add the frequencies
        cumul += hm[a[i]]
  
    # if the element has not been
    # visited previously
        if(hm[a[i]] > 0):
            print(a[i], "->", cumul)
              
    # mark the hash 0
    # as the element's cumulative 
    # frequency has been printed
        hm[a[i]] = 0
  
# Driver Code
a = [1, 3, 2, 4, 2, 1]
n = len(a)
countFreq(a, n)
  
# This code is contributed by mohit kumar

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program to print the cumulative frequency 
// according to the order given 
using System;
  
class GFG 
  
// Function to print the cumulative frequency 
// according to the order given 
static void countFreq(int []a, int n) 
    // Insert elements and their 
    // frequencies in hash map. 
    int []hm = new int[n]; 
    for (int i = 0; i < n; i++) 
        hm[a[i]]++; 
    int cumul = 0; 
      
// traverse in the array 
for(int i = 0; i < n; i++) 
    // add the frequencies 
    cumul += hm[a[i]]; 
          
    // if the element has not been 
    // visited previously 
    if(hm[a[i]] != 0) 
    
        Console.WriteLine(a[i] + "->" + cumul); 
    
      
    // mark the hash 0 
    // as the element's cumulative frequency 
    // has been printed 
    hm[a[i]] = 0; 
  
// Driver Code 
public static void Main(String[] args) 
    int []a = {1, 3, 2, 4, 2, 1}; 
    int n = a.Length; 
    countFreq(a, n); 
  
/* This code contributed by PrinciRaj1992 */

chevron_right


Output:

1->2
3->3
2->5
4->6

This article is contributed by Himanshu Ranjan. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.



My Personal Notes arrow_drop_up



Article Tags :
Practice Tags :


3


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.