# Find the frequencies of all duplicates elements in the array

Last Updated : 21 Mar, 2023

Given an array of integers with duplicate elements in it, the task is to find the duplicate elements in the array and their frequencies.

Examples:

Input: arr[] = {2, 3, 4, 5, 4, 6, 4, 7, 4, 5, 6, 6}
Output: Below is the frequency of repeated elements –
4 –> 4
5 –> 2
6 –> 3
Input: arr[] = {4, 4, 5, 5, 6}
Output: Below is the frequency of repeated elements –
4 –> 2
5 –> 2

Approach:

• Create a Hash Map to store the frequency of the elements.
• Elements whose frequency is greater than 1 are the repeated elements.

Below is the implementation of the above approach:

## CPP

 `// CPP Implementation to find the` `// repeating elements with there count` `#include` `using` `namespace` `std;`   `// Function to find the repeating` `// elements with there count` `map<``int``,``int``> findRepeating(``int` `arr[], ``int` `size){`   `    ``// Hash map to store the ` `    ``// frequency of elements` `    ``map<``int``,``int``> frequency;` `    `  `    ``// Loop to store the frequency of ` `    ``// elements of array` `    ``for` `(``int` `i = 0; i < size; i++)` `    ``frequency[arr[i]]++;` `    ``return` `frequency;` `}` `        `  `// Driver Code ` `int` `main(){` `    ``int` `arr[] = {4, 4, 5, 5, 6};` `    ``int` `arr_size = ``sizeof``(arr)/``sizeof``(arr[0]); ` `    ``map<``int``,``int``> frequency = findRepeating(arr, arr_size);` `    ``cout<<``"Below is the frequency of repeated elements -"``< 1)` `            ``cout< "``<

## Java

 `// Java Implementation to find the` `// repeating elements with there count` `import` `java.util.*;`   `class` `GFG` `{` `    `  `// Function to find the repeating` `// elements with there count` `static` `HashMap findRepeating(``int` `[]arr, ``int` `size){` `    `  `    ``// Hash map to store the ` `    ``// frequency of elements` `    ``HashMap frequency = ``new` `HashMap();` `    `  `    ``// Loop to store the frequency of ` `    ``// elements of array` `    ``for``(``int` `i = ``0``; i < size; i++) ` `    ``{` `        ``if``(frequency.containsKey(arr[i]))` `        ``{` `            ``frequency.put(arr[i], frequency.get(arr[i]) + ``1``);` `        ``}` `        ``else` `        ``{` `            ``frequency.put(arr[i], ``1``);` `        ``}` `    ``}` `    ``return` `frequency;` `} `   `// Driver Code ` `public` `static` `void` `main(String []args)` `{` `    ``int` `[]arr = {``4``, ``4``, ``5``, ``5``, ``6``};` `    ``int` `arr_size = arr.length; ` `    ``HashMap frequency = findRepeating(arr, arr_size);` `    ``System.out.println(``"Below is the frequency"` `    ``+``"of repeated elements -"``);` `    ``for` `(Map.Entry entry : frequency.entrySet())` `        ``if` `(entry.getValue() > ``1``)` `            ``System.out.println(entry.getKey()+ ``" --> "``+entry.getValue());` `}` `}`   `// This code is contributed by PrinciRaj1992`

## Python

 `# Python Implementation to find the` `# repeating elements with there count`   `# Function to find the repeating` `# elements with there count` `def` `findRepeating(arr, size):` `    `  `    ``# Hash map to store the ` `    ``# frequency of elements` `    ``frequency ``=` `{}` `    `  `    ``# Loop to store the frequency of ` `    ``# elements of array` `    ``for` `i ``in` `range` `(``0``, size):` `        ``frequency[arr[i]] ``=` `\` `        ``frequency.get(arr[i], ``0``) ``+` `1` `    ``return` `frequency` `    `  `# Driver Code ` `if` `__name__ ``=``=` `"__main__"``:` `    ``arr ``=` `[``4``, ``4``, ``5``, ``5``, ``6``]` `    ``arr_size ``=` `len``(arr) ` `    ``frequency ``=` `findRepeating(arr, arr_size)` `    ``print``("Below ``is` `the frequency\` `    ``of repeated elements ``-``")` `    ``for` `i ``in` `frequency:` `        ``if` `frequency[i] > ``1``:` `            ``print``(i, ``" --> "``, frequency[i])`

## C#

 `// C# Implementation to find the` `// repeating elements with there count` `using` `System;` `using` `System.Collections.Generic;`   `class` `GFG` `{` `    `  `// Function to find the repeating` `// elements with there count` `static` `Dictionary<``int``, ``int``> findRepeating(``int` `[]arr, ``int` `size){` `    `  `    ``// Hash map to store the ` `    ``// frequency of elements` `    ``Dictionary<``int``,``int``> frequency = ``new` `Dictionary<``int``,``int``>();` `    `  `    ``// Loop to store the frequency of ` `    ``// elements of array` `    ``for``(``int` `i = 0; i < size; i++) ` `    ``{` `        ``if``(frequency.ContainsKey(arr[i]))` `        ``{` `            ``frequency[arr[i]] = frequency[arr[i]] + 1;` `        ``}` `        ``else` `        ``{` `            ``frequency.Add(arr[i], 1);` `        ``}` `    ``}` `    ``return` `frequency;` `} `   `// Driver Code ` `public` `static` `void` `Main(String []args)` `{` `    ``int` `[]arr = {4, 4, 5, 5, 6};` `    ``int` `arr_size = arr.Length; ` `    ``Dictionary<``int``,``int``> frequency = findRepeating(arr, arr_size);` `    ``Console.WriteLine(``"Below is the frequency"` `                        ``+``"of repeated elements -"``);` `    ``foreach` `(KeyValuePair<``int``,``int``> entry ``in` `frequency)` `        ``if` `(entry.Value > 1)` `            ``Console.WriteLine(entry.Key+ ``" --> "``+entry.Value);` `}` `}`   `// This code is contributed by 29AjayKumar`

## Javascript

 ``

Output:

```Below is the frequency    of repeated elements -
4  -->  2
5  -->  2```

Time Complexity: O(n*log(n))
Auxiliary Space: O(n)

Efficient Approach( Space optimization): we can use binary search . For this , First sort the array and then find frequency of all array element with the use of binary search function ( Upper_bound ) . The frequency of array element will be ‘last_index-first_index+1’ . If the frequency is greater than one , then print it .

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the above approach`   `#include ` `using` `namespace` `std;`   `//Function to find frequency of elements in the array` `void` `findRepeating(``int` `arr[], ``int` `n)` `{   ` `    ``sort(arr,arr+n);``//sort array for binary search` `   `  `    ``for``(``int` `i = 0 ; i < n ;i++)` `    ``{ ` `      ``//index of first and last occ of arr[i]` `      ``int` `first_index = lower_bound(arr,arr+n,arr[i])- arr;` `      ``int` `last_index = upper_bound(arr,arr+n,arr[i])- arr-1;` `      ``i=last_index;` `      `  `      ``int` `fre = last_index-first_index+1;``//finding frequency` `      ``if``(fre >= 2)` `      ``{ ``//printing frequency if it is greater than 1` `        ``cout << arr[i] <<``" --> "``<

## C#

 `using` `System;`   `class` `MainClass {` `    ``// Function to find frequency of elements in the array` `    ``static` `void` `FindRepeating(``int``[] arr, ``int` `n)` `    ``{` `        ``// sort array for binary search` `        ``Array.Sort(arr);`   `        ``for` `(``int` `i = 0; i < n; i++) {` `            ``// index of first and last occ of arr[i]` `            ``int` `first_index = Array.IndexOf(arr, arr[i]);` `            ``int` `last_index = Array.LastIndexOf(arr, arr[i]);` `            ``i = last_index;`   `            ``// finding frequency` `            ``int` `fre = last_index - first_index + 1;` `            ``if` `(fre >= 2) {` `                ``// printing frequency if it is greater than` `                ``// 1` `                ``Console.WriteLine(arr[i] + ``" --> "` `+ fre);` `            ``}` `        ``}` `    ``}`   `    ``// Drive code` `    ``public` `static` `void` `Main(``string``[] args)` `    ``{` `        ``int``[] arr = { 2, 3, 4, 5, 4, 6, 4, 7, 4, 5, 6, 6 };` `        ``int` `n = arr.Length;`   `        ``// Function call` `        ``FindRepeating(arr, n);` `    ``}` `}`

## Java

 `import` `java.util.*;`   `class` `Main {` `    ``// Function to find frequency of elements in the array` `    ``public` `static` `void` `findRepeating(``int` `arr[], ``int` `n)` `    ``{` `        ``Arrays.sort(arr); ``// sort array for binary search`   `        ``int` `i = ``0``;` `        ``while` `(i < n) {` `            ``// index of first and last occ of arr[i]` `            ``int` `firstIndex = i;` `            ``while` `(i < n - ``1` `&& arr[i] == arr[i + ``1``]) {` `                ``i++;` `            ``}` `            ``int` `lastIndex = i;`   `            ``int` `frequency = lastIndex - firstIndex` `                            ``+ ``1``; ``// finding frequency` `            ``if` `(frequency >= ``2``) {` `                ``// printing frequency if it is greater than` `                ``// 1` `                ``System.out.println(arr[i] + ``" --> "` `                                   ``+ frequency);` `            ``}` `            ``i++;` `        ``}` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int` `arr[] = { ``2``, ``3``, ``4``, ``5``, ``4``, ``6``, ``4``, ``7``, ``4``, ``5``, ``6``, ``6` `};` `        ``int` `n = arr.length;`   `        ``// Function call` `        ``findRepeating(arr, n);` `    ``}` `}`

## Javascript

 `//Function to find frequency of elements in the array` `function` `findRepeating(arr, n) {   ` `    ``arr.sort(); ``// sort array for binary search`   `    ``for``(let i = 0 ; i < n ; i++) { ` `        ``// index of first and last occ of arr[i]` `        ``let first_index = arr.indexOf(arr[i]);` `        ``let last_index = arr.lastIndexOf(arr[i]);` `        ``i = last_index;` `        `  `        ``let fre = last_index - first_index + 1; ``// finding frequency` `        ``if``(fre >= 2) { ``// printing frequency if it is greater than 1` `            ``console.log(arr[i] + ``" --> "` `+ fre);` `        ``}` `    ``} ` `}`   `// Drive code` `let arr = [2, 3, 4, 5, 4, 6, 4, 7, 4, 5, 6, 6];` `let n = arr.length;`   `// Function call` `findRepeating(arr, n);`

## Python3

 `def` `find_repeating(arr, n):` `    ``arr.sort() ``# sort array for binary search`   `    ``i ``=` `0` `    ``while` `i < n:` `        ``# index of first and last occ of arr[i]` `        ``first_index ``=` `i` `        ``while` `i < n ``-` `1` `and` `arr[i] ``=``=` `arr[i ``+` `1``]:` `            ``i ``+``=` `1` `        ``last_index ``=` `i`   `        ``frequency ``=` `last_index ``-` `first_index ``+` `1` `# finding frequency` `        ``if` `frequency >``=` `2``:` `            ``# printing frequency if it is greater than 1` `            ``print``(``str``(arr[i]) ``+` `" --> "` `+` `str``(frequency))` `        ``i ``+``=` `1`   `# Driver code` `arr ``=` `[``2``, ``3``, ``4``, ``5``, ``4``, ``6``, ``4``, ``7``, ``4``, ``5``, ``6``, ``6``]` `n ``=` `len``(arr)`   `# Function call` `find_repeating(arr, n)`

Output

```4 --> 4
5 --> 2
6 --> 3```

Time Complexity: O(n*log2n) , Taking O(log2n) time for binary search function ( upper_bound) .
Auxiliary Space: O(1)

Previous
Next
Share your thoughts in the comments