Cumulative frequency of count of each element in an unsorted array - GeeksforGeeks

15 Dec, 2021
Given an unsorted array. The task is to calculate the cumulative frequency of each element of the array using a 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 loop picks an element from left to right that is not visited. The inner loop counts its occurrences and marks occurrences as visited. The time complexity of this solution is O(n*n) and the auxiliary space required is O(n).
A better solution is to use sorting. We sort the array so that the 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++
Java
Python3
C#
Javascript
#include <bits/stdc++.h>using namespace std; // Function to print the cumulative frequency according to// the order givenvoid countFreq(int a[], int n){       // Declaring a map so values get inserted in a sorted    // manner    map<int, int> m;       // Inserting values into the map    for (int i = 0; i < n; i++) {        m[a[i]]++;    }       // Variable to store the count of previous number    // cumulative frequency    int cumul = 0;    for (auto v : m) {        cout << v.first << " " << v.second + cumul             << endl;        cumul += v.second;    }} int main(){    int arr[] = { 1, 3, 2, 4, 2, 1 };    int n = sizeof(arr) / sizeof(arr[0]);    countFreq(arr, n);    return 0;} // This code is contributed by Vinayak Pareek (Kargil)
// Java program to count cumulative// 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
# Python3 program to count cumulative# 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 Codeif __name__ == "__main__":     a = [1, 3, 2, 4, 2, 1]    n = len(a)    countFreq(a, n)     # This code is contributed by Rituraj Jain
// C# program to count cumulative// frequencies of elements in an// unsorted array.using System;using System.Collections.Generic;using System.Linq; class GFG{     static void countFreq(int[] a, int n){         // Insert elements and their    // frequencies in hash map.    Dictionary<int,               int> hm = new Dictionary<int,                                        int>();    for(int i = 0; i < n; i++)    {        if (hm.ContainsKey(a[i]))        {            hm[a[i]]++;        }        else        {            hm[a[i]] = 1;        }    }     int cumul = 0;     // Iterate the set and print the    // cumulative frequency    foreach(KeyValuePair<int,                         int> x in hm.OrderBy(key => key.Key))    {        cumul += x.Value;        Console.Write(x.Key + " " + cumul + "\n");    }} // Driver Codepublic 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 rutvik_56
<script>// Javascript program to count cumulative// frequencies of elements in an unsorted array.         function countFreq(a,n)    {        // Insert elements and their        // frequencies in hash map.        let hm = new Map();        for (let i = 0; i < n; i++)            hm.set(a[i], hm.get(a[i]) == null ?                     1 : hm.get(a[i]) + 1);           // Declare a Map        let st = new Set();                   // insert the element and        // and insert its frequency in a set        for (let [key, value] of hm.entries())        {               st.add([key, value]);        }          st=[...st.entries()].sort()        let cumul = 0;           // iterate the set and print the        // cumulative frequency        for (let [key, value] of st.entries())        {            cumul += value[1][1];            document.write(value[1][0] + " " + cumul+"<br>");        }    }         // Driver Code    let a=[1, 3, 2, 4, 2, 1];    let n = a.length;    countFreq(a, n);      // This code is contributed by unknown2108</script>
1 2
2 4
3 5
4 6
 
The 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++
Java
Python3
C#
Javascript
// C++ 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 givenvoid 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 Codeint main(){    int a[] = {1, 3, 2, 4, 2, 1};    int n = sizeof(a)/sizeof(a[0]);    countFreq(a, n);    return 0;}
// Java program to print the cumulative frequency// according to the order givenclass GFG{ // Function to print the cumulative frequency// according to the order givenstatic 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 arrayfor(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 Codepublic 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
# Python3 program to print the cumulative# frequency according to the order given # Function to print the cumulative frequency# according to the order givendef 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 Codea = [1, 3, 2, 4, 2, 1]n = len(a)countFreq(a, n) # This code is contributed by mohit kumar
// C# program to print the cumulative frequency// according to the order givenusing System; class GFG{ // Function to print the cumulative frequency// according to the order givenstatic 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 arrayfor(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 Codepublic 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 */
<script>// Javascript program to print the cumulative frequency// according to the order given     // Function to print the cumulative frequency// according to the order givenfunction countFreq(a,n) {    // Insert elements and their    // frequencies in hash map.    let hm = new Array(n);    for(let i=0;i<hm.length;i++)    {        hm[i]=0;    }    for (let i = 0; i < n; i++)        hm[a[i]]++;    let cumul = 0;           // traverse in the array    for(let 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)        {            document.write(a[i] + "->" + cumul+"<br>");        }        // mark the hash 0        // as the element's cumulative frequency        // has been printed        hm[a[i]] = 0;    }  }  // Driver Codelet a=[1, 3, 2, 4, 2, 1];let n = a.length;countFreq(a, n);      // This code is contributed by patel2127</script>
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 write.geeksforgeeks.org or mail your article to review-team@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. 
mohit kumar 29
29AjayKumar
princiraj1992
rituraj_jain
sanjeev2552
nidhi_biet
rutvik_56
unknown2108
patel2127
kargiloutlook
surinderdawra388
Arrays
Hash
Arrays
Hash
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Comments
Old Comments
Next Greater Element
Window Sliding Technique
Count pairs with given sum
Program to find sum of elements in a given array
Reversal algorithm for array rotation
Internal Working of HashMap in Java
Hashing | Set 1 (Introduction)
Count pairs with given sum
Hashing | Set 3 (Open Addressing)
Hashing | Set 2 (Separate Chaining)