RetroSearch Browse

Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://www.geeksforgeeks.org/dsa/counting-frequencies-of-array-elements/ below:

Counting frequencies of array elements

Last Updated : 26 Jul, 2025

Try it on GfG Practice

Given an array arr[] of non-negative integers which may contain duplicate elements. Return the frequency of each distinct element present in the array.

Examples:

Input: arr[] = [10, 20, 10, 5, 20]
Output: [[5, 1], [10, 2], [20, 2]]
Explanation: Here 5 occurs once, 10 occurs 2 times and 20 occurs 2 times.

Input: arr[] = [10, 20, 20]
Output: [[10, 1], [20, 2]]
Explanation: Here 10 occurs 1 time, 20 occurs 2 times.

[Naive Approach] Brute Force - O(n²) Time O(n) Space

A simple solution is to run two loops. For every item count number of times, it occurs. To avoid duplicate printing, keep track of processed items.

C++


 #include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

vector<vector<int>> countFreq(vector<int>& arr){
    int n = arr.size();
    
    // Mark all array elements as not visited
    vector<bool> visited(n , false);
    vector<vector<int>>ans;
    for (int i = 0; i < n; i++) {
        
        // Skip this element if already processed
        if (visited[i] == true)
            continue;

        // store the frequency
        int count = 1;
        for (int j = i + 1; j < n; j++) {
            if (arr[i] == arr[j]) {
                visited[j] = true;
                count++;
            }
            
        }
        ans.push_back({arr[i] , count});
    }
    return ans;
}

int main(){
    vector <int> arr = {10, 20, 10, 5, 20};
    vector<vector<int>>ans =  countFreq(arr);
    sort(ans.begin(), ans.end()) ;
    for (auto x : ans){
        cout << x[0] << ' '<< x[1] <<'\n';
    }
    return 0 ;
}

Java


 import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class GfG {
    public static ArrayList<ArrayList<Integer>> countFreq(int[] arr) {
        int n = arr.length;
        
        // Mark all array elements as not visited
        boolean[] visited = new boolean[n];
        ArrayList<ArrayList<Integer>> ans = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            
            // Skip this element if already processed
            if (visited[i])
                continue;
            int count = 1;
            
            // store the frequency
            for (int j = i + 1; j < n; j++) {
                if (arr[i] == arr[j]) {
                    visited[j] = true;
                    count++;
                }
            }
            ArrayList<Integer> temp = new ArrayList<>();
            temp.add(arr[i]);
            temp.add(count);
            ans.add(temp);
        }
        return ans;
    }

    public static void main(String[] args) {
        int[] arr = {10, 20, 10, 5, 20};
        ArrayList<ArrayList<Integer>> ans = countFreq(arr);
        Collections.sort(ans, new Comparator<ArrayList<Integer>>() {
            public int compare(ArrayList<Integer> a, ArrayList<Integer> b) {
                return Integer.compare(a.get(0), b.get(0));
            }
        });
        for (ArrayList<Integer> x : ans) {
            System.out.println(x.get(0) + " " + x.get(1));
        }
    }
}

Python


 def countFreq(arr):
    n = len(arr)
    
    # Mark all array elements as not visited
    visited = [False] * n
    ans = []
    for i in range(n):
        
        # Skip this element if already processed
        if visited[i]:
            continue
        
        # store the frequency
        count = 1
        for j in range(i + 1, n):
            if arr[i] == arr[j]:
                visited[j] = True
                count += 1
        ans.append([arr[i], count])
    return ans

if __name__ == '__main__':
    arr = [10, 20, 10, 5, 20]
    ans = countFreq(arr)
    ans.sort(key=lambda x: x[0])
    for x in ans:
        print(x[0], x[1])


 using System;
using System.Collections.Generic;

class GfG {
    public static List<List<int>> countFreq(int[] arr) {
        int n = arr.Length;
        
        // Mark all array elements as not visited
        bool[] visited = new bool[n];
        List<List<int>> ans = new List<List<int>>();
        
        for (int i = 0; i < n; i++) {
            // Skip this element if already processed
            if (visited[i])
                continue;
            
            // store the frequency
            int count = 1;
            for (int j = i + 1; j < n; j++) {
                if (arr[i] == arr[j]) {
                    visited[j] = true;
                    count++;
                }
            }
            List<int> temp = new List<int>();
            temp.Add(arr[i]);
            temp.Add(count);
            ans.Add(temp);
        }
        return ans;
    }

    static void Main() {
        int[] arr = {10, 20, 10, 5, 20};
        List<List<int>> ans = countFreq(arr);
        ans.Sort((a, b) => a[0].CompareTo(b[0]));
        foreach (var x in ans) {
            Console.WriteLine(x[0] + " " + x[1]);
        }
    }
}

JavaScript


 function countFreq(arr) {
    let n = arr.length;
    
    // Mark all array elements as not visited
    let visited = Array(n).fill(false);
    let ans = [];
    
    for (let i = 0; i < n; i++) {
        // Skip this element if already processed
        if (visited[i]) continue;
        
        // store the frequency
        let count = 1;
        for (let j = i + 1; j < n; j++) {
            if (arr[i] === arr[j]) {
                visited[j] = true;
                count++;
            }
        }
        ans.push([arr[i], count]);
    }
    return ans;
}

// Driver Code 
let arr = [10, 20, 10, 5, 20];
let ans = countFreq(arr);
ans.sort((a, b) => a[0] - b[0]);
for (let x of ans) {
    console.log(x[0], x[1]);
}

[Better Approach] Using binary search

We can find frequency of array elements using Binary search function . First we will sort the array for binary search . Our frequency of element will be '(last occ - first occ) + 1' of a element in a array.

C++


 #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;

vector<vector<int>> countFreq(vector<int> &arr){
    int n = arr.size();
    
    // Sort array for binary search
    sort(arr.begin(), arr.end()); 
    vector<vector<int>> ans;
    for (int i = 0; i < n; i++) {
        
        // Find first and last occurrence of arr[i]
        // using lower and upper bound 
        auto firstIter = lower_bound(arr.begin(), arr.end(), arr[i]);
        auto lastIter = upper_bound(arr.begin(), arr.end(), arr[i]);
        int firstIndex = firstIter - arr.begin();
        int lastIndex = lastIter - arr.begin() - 1;
        
        // Calculate frequency
        int fre = lastIndex - firstIndex + 1; 
        ans.push_back({arr[i], fre}); 
        
        // Skip counted elements
        i = lastIndex; 
    }
    return ans;
}

int main(){
    vector<int> arr = {10 ,20 ,10 ,5 , 20};
    vector<vector<int>> ans = countFreq(arr);
    for (auto x : ans){
        cout << x[0] << " " << x[1] << endl;
    }
    return 0;
}

Java


 import java.util.ArrayList;
import java.util.Arrays;

public class GFG {
    public static ArrayList<ArrayList<Integer>> countFreq(int[] arr) {
        Arrays.sort(arr);
        ArrayList<ArrayList<Integer>> ans = new ArrayList<>();
        int n = arr.length;
        int i = 0;
        while (i < n) {
            int current = arr[i];
            int firstIndex = i;
            int lastIndex = i;

            // Find lastIndex by moving forward
            while (lastIndex + 1 < n && 
            arr[lastIndex + 1] == current)
                lastIndex++;
                
            // Calculate frequency
            int fre = lastIndex - firstIndex + 1; 
            
            // Store in ans as ArrayList
            ArrayList<Integer> temp = new ArrayList<>();
            temp.add(current);
            temp.add(fre);
            ans.add(temp);
            
             // Skip counted elements
            i = lastIndex + 1;
        }
        return ans;
    }

    public static void main(String[] args) {
        int[] arr = {10, 20, 5, 10, 20};
        ArrayList<ArrayList<Integer>> ans = countFreq(arr);
        for (ArrayList<Integer> x : ans) {
            System.out.println(x.get(0) + " " + x.get(1));
        }
    }
}

Python


 from bisect import bisect_left, bisect_right

def countFreq(arr):
    n = len(arr)
    
    # Sort array for binary search
    arr.sort()
    ans = []
    i = 0
    while i < n:
        
        # Find first and last occurrence of arr[i] 
        # using bisect_left and bisect_right
        firstIndex = bisect_left(arr, arr[i])
        lastIndex = bisect_right(arr, arr[i]) - 1

        # Calculate frequency
        fre = lastIndex - firstIndex + 1
        ans.append([arr[i], fre])

        # Skip counted elements
        i = lastIndex + 1

    return ans

if __name__ == "__main__":
    arr = [10, 20, 10, 5, 20]
    ans = countFreq(arr)
    for x in ans:
        print(x[0], x[1])


 using System;
using System.Collections.Generic;

class GFG{
    public static List<List<int>> countFreq(int[] arr){
        Array.Sort(arr); 
        int n = arr.Length;
        List<List<int>> ans = new List<List<int>>();
        int i = 0;
        while (i < n){
            int current = arr[i];
            int firstIndex = i;
            int lastIndex = i;
            
            // Find lastIndex by moving forward        
           while (lastIndex + 1 < n && 
            arr[lastIndex + 1] == current)
                lastIndex++;
                
            // Calculate frequency
            int fre = lastIndex - firstIndex + 1; 
            
            // store in arrayList
            List<int> temp = new List<int> { current, fre };
            ans.Add(temp);
            
            // Skip counted elements
            i = lastIndex + 1; 
        }
        return ans;
    }
    
    static void Main(){
        int[] arr = {10, 20, 10, 5, 20};
        List<List<int>> ans = countFreq(arr);
        foreach (var x in ans){
            Console.WriteLine(x[0] + " " + x[1]);
        }
    }
}

JavaScript


 function countFreq(arr) {
    arr.sort((a, b) => a - b); 
    const n = arr.length;
    const ans = [];
    let i = 0;
    while (i < n) {
        let current = arr[i];
        let firstIndex = i;
        let lastIndex = i;

        // Find lastIndex by moving forward
        while (lastIndex + 1 < n &&
        arr[lastIndex + 1] === current)
            lastIndex++;
            
         // Calculate frequency
        const fre = lastIndex - firstIndex + 1;
        
        //store in array list
        ans.push([current, fre]); 
        
        // Skip counted elements
        i = lastIndex + 1; 
    }
    return ans;
}

// Driver Code 
const arr = [10, 20, 10, 5, 20];
const ans = countFreq(arr);
for (let x of ans) {
    console.log(x[0], x[1]);
}

Time Complexity: O(n × log₂n) , where O(log₂n) time for binary search function.
Auxiliary Space: O(1), as using constant extra space

[Expected Solution] Using hashing - O(n) Time and O(n) Space

An efficient solution is using a hash map (e.g. unordered_map in C++, HashMap in Java, dict in Python, or Dictionary in C#), we can store elements as keys and their frequencies as values.

C++


 #include <iostream>
#include <unordered_map>
#include <vector>
#include <algorithm>
using namespace std;

vector<vector<int>> countFreq(vector<int>& arr) {
    
    // stores frequency of each number
    unordered_map<int, int> mp;      
    // stores {number, frequency}
    vector<vector<int>> ans;         

    // count frequency using unordered_map
    for (int num : arr) {
        mp[num]++;
    }

    // build the answer vector from the frequency map
    for (auto &it : mp) {
        ans.push_back({it.first, it.second});
    }

    return ans ;
}

int main() {
    vector<int> arr = {10, 20, 10, 5, 20};

    vector<vector<int>> ans = countFreq(arr);

    // sort the result in ascending order of the number
    sort(ans.begin(), ans.end(), [](vector<int>& a, 
                        vector<int>& b) {
        return a[0] < b[0];  
    });

    for (auto &x : ans) {
        cout << x[0] << " " << x[1] << endl;
    }

    return 0;
}

Java


 import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;

public class GfG {

    public static ArrayList<ArrayList<Integer>> countFreq(int[] arr) {
        
        // stores frequency of each number
        HashMap<Integer, Integer> mp = new HashMap<>();
        // stores {number, frequency}
        ArrayList<ArrayList<Integer>> ans = new ArrayList<>();

        // count frequency using HashMap
        for (int num : arr) {
            mp.put(num, mp.getOrDefault(num, 0) + 1);
        }

        // build the answer list from the frequency map
        for (Map.Entry<Integer, Integer> entry : mp.entrySet()) {
            ArrayList<Integer> temp = new ArrayList<>();
            temp.add(entry.getKey());
            temp.add(entry.getValue());
            ans.add(temp);
        }

        return ans;
    }

    public static void main(String[] args) {
        int[] arr = {10, 20, 10, 5, 20};

        ArrayList<ArrayList<Integer>> ans = countFreq(arr);

        // sort the result in ascending order of the number
        ans.sort((a, b) -> Integer.compare(a.get(0), b.get(0)));

        for (ArrayList<Integer> x : ans) {
            System.out.println(x.get(0) + " " + x.get(1));
        }
    }
}

Python


 def countFreq(arr):
    # stores frequency of each number
    mp = {}
    # stores [number, frequency]
    ans = []

    # count frequency using dictionary
    for num in arr:
        mp[num] = mp.get(num, 0) + 1

    # Build the answer list from the frequency map
    for num, freq in mp.items():
        ans.append([num, freq])

    return ans


if __name__ == "__main__":
    arr = [10, 20, 10, 5, 20]

    ans = countFreq(arr)

    # sort the result in ascending order of the number
    ans.sort(key=lambda x: x[0])

    for x in ans:
        print(x[0], x[1])


 using System;
using System.Collections.Generic;

class GfG {
    public static List<List<int>> countFreq(int[] arr) {
        
        // stores frequency of each number
        Dictionary<int, int> mp = new Dictionary<int, int>();
        
        // stores {number, frequency}
        List<List<int>> ans = new List<List<int>>();

        // count frequency using Dictionary
        foreach (int num in arr) {
            if (!mp.ContainsKey(num)) {
                mp[num] = 1;
            } else {
                mp[num]++;
            }
        }

        // Build the answer list from the frequency map
        foreach (var entry in mp) {
            ans.Add(new List<int> { entry.Key, entry.Value });
        }

        return ans;
    }

    static void Main() {
        int[] arr = {10, 20, 10, 5, 20};

        List<List<int>> ans = countFreq(arr);

        // sort the result in ascending order of the number
        ans.Sort((a, b) => a[0].CompareTo(b[0]));

        foreach (var x in ans) {
            Console.WriteLine(x[0] + " " + x[1]);
        }
    }
}

JavaScript


 function countFreq(arr) {
    // stores frequency of each number
    const mp = {};
    // stores [number, frequency]
    const ans = [];

    // count frequency using object
    for (let num of arr) {
        mp[num] = (mp[num] || 0) + 1;
    }

    // Build the answer array from the frequency map
    for (let num in mp) {
        ans.push([parseInt(num), mp[num]]);
    }

    return ans;
}

// Driver Code
const arr = [10, 20, 10, 5, 20];
let ans = countFreq(arr);
// sort the result in ascending order of the number
ans.sort((a, b) => a[0] - b[0]);
for (let x of ans) {
    console.log(x[0], x[1]);
}

C++ Program to Count Frequency of Each Element in an Array

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4