Counting frequencies of array elements
Last Updated :
26 Jul, 2025
Improve
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.
Table of Content
[Naive Approach] Brute Force - O(n2) 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.
#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 ;
}
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));
}
}
}
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]);
}
}
}
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]);
}
Output
5 1 10 2 20 2
[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.
#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;
}
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));
}
}
}
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]);
}
}
}
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]);
}
Output
5 1 10 2 20 2
Time Complexity: O(n × log2n) , where O(log2n) 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.
#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;
}
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));
}
}
}
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]);
}
}
}
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]);
}
Output
5 1 10 2 20 2
C++ Program to Count Frequency of Each Element in an Array
