# Difference between highest and least frequencies in an array

• Difficulty Level : Easy
• Last Updated : 07 Nov, 2022

Given an array, find the difference between highest occurrence and least occurrence of any number in an array

Examples:

```Input  : arr[] = [7, 8, 4, 5, 4, 1, 1, 7, 7, 2, 5]
Output : 2
Lowest occurring element (5) occurs once.
Highest occurring element (1 or 7) occurs 3 times

Input  : arr[] = [1, 1, 1, 3, 3, 3]
Output : 0```

A simple solution is to use two loops to count the frequency of every element and keep track of maximum and minimum frequencies.
A better solution is to sort the array in O(n log n) and check consecutive element’s occurrence and compare their count respectively.

Implementation:

## C++

 `// CPP code to find the difference between highest``// and least frequencies``#include ``using` `namespace` `std;` `int` `findDiff(``int` `arr[], ``int` `n)``{``    ``// sort the array``    ``sort(arr, arr + n);` `    ``int` `count = 0, max_count = 0, min_count = n;``    ``for` `(``int` `i = 0; i < (n - 1); i++) {` `        ``// checking consecutive elements``        ``if` `(arr[i] == arr[i + 1]) {``            ``count += 1;``            ``continue``;``        ``}``        ``else` `{``            ``max_count = max(max_count, count);``            ``min_count = min(min_count, count);``            ``count = 0;``        ``}``    ``}` `    ``return` `(max_count - min_count);``}` `// Driver code``int` `main()``{``    ``int` `arr[] = { 7, 8, 4, 5, 4, 1, 1, 7, 7, 2, 5 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``cout << findDiff(arr, n) << ``"\n"``;``    ``return` `0;``}`

## Java

 `// JAVA Code for Difference between``// highest and least frequencies``// in an array``import` `java.util.*;` `class` `GFG {` `    ``static` `int` `findDiff(``int` `arr[], ``int` `n)``    ``{``        ``// sort the array``        ``Arrays.sort(arr);` `        ``int` `count = ``0``, max_count = ``0``,``            ``min_count = n;` `        ``for` `(``int` `i = ``0``; i < (n - ``1``); i++) {` `            ``// checking consecutive elements``            ``if` `(arr[i] == arr[i + ``1``]) {``                ``count += ``1``;``                ``continue``;``            ``}``            ``else` `{``                ``max_count = Math.max(max_count,``                                     ``count);` `                ``min_count = Math.min(min_count,``                                     ``count);``                ``count = ``0``;``            ``}``        ``}` `        ``return` `(max_count - min_count);``    ``}` `    ``// Driver program to test above function``    ``public` `static` `void` `main(String[] args)``    ``{` `        ``int` `arr[] = { ``7``, ``8``, ``4``, ``5``, ``4``, ``1``,``                      ``1``, ``7``, ``7``, ``2``, ``5` `};``        ``int` `n = arr.length;` `        ``System.out.println(findDiff(arr, n));``    ``}``}` `// This code is contributed by Arnav Kr. Mandal.`

## Python3

 `# Python3 code to find the difference``# between highest nd least frequencies` `def` `findDiff(arr, n):``    ` `    ``# sort the array``    ``arr.sort()``    ` `    ``count ``=` `0``; max_count ``=` `0``; min_count ``=` `n``    ``for` `i ``in` `range``(``0``, (n``-``1``)):` `        ``# checking consecutive elements``        ``if` `arr[i] ``=``=` `arr[i ``+` `1``]:``            ``count ``+``=` `1``            ``continue``        ``else``:``            ``max_count ``=` `max``(max_count, count)``            ``min_count ``=` `min``(min_count, count)``            ``count ``=` `0``    ``return` `max_count ``-` `min_count` `# Driver Code``arr ``=` `[ ``7``, ``8``, ``4``, ``5``, ``4``, ``1``, ``1``, ``7``, ``7``, ``2``, ``5` `]``n ``=` `len``(arr)``print` `(findDiff(arr, n))` `# This code is contributed by Shreyanshi Arun.`

## C#

 `// C# Code for Difference between``// highest and least frequencies``// in an array``using` `System;` `class` `GFG {` `    ``static` `int` `findDiff(``int``[] arr, ``int` `n)``    ``{``        ` `        ``// sort the array``        ``Array.Sort(arr);` `        ``int` `count = 0, max_count = 0,``            ``min_count = n;` `        ``for` `(``int` `i = 0; i < (n - 1); i++) {` `            ``// checking consecutive elements``            ``if` `(arr[i] == arr[i + 1]) {``                ``count += 1;``                ``continue``;``            ``}``            ``else` `{``                ``max_count = Math.Max(max_count,``                                    ``count);` `                ``min_count = Math.Min(min_count,``                                    ``count);``                ``count = 0;``            ``}``        ``}` `        ``return` `(max_count - min_count);``    ``}` `    ``// Driver program to test above function``    ``public` `static` `void` `Main()``    ``{` `        ``int``[] arr = { 7, 8, 4, 5, 4, 1,``                       ``1, 7, 7, 2, 5 };``        ``int` `n = arr.Length;` `        ``Console.WriteLine(findDiff(arr, n));``    ``}``}` `// This code is contributed by vt_m.`

## PHP

 ``

## Javascript

 ``

Output

`2`

Time Complexity: O(nlogn) the inbuilt sort function takes N log N time to complete all operations, hence the overall time taken by the algorithm is N log N
Space Complexity: O(1) since no extra array is used so the space taken by the algorithm is constant

An efficient solution is to use hashing. We count frequencies of all elements and finally traverse the hash table to find maximum and minimum.

Below is the implementation.

## C++

 `// CPP code to find the difference between highest``// and least frequencies``#include ``using` `namespace` `std;` `int` `findDiff(``int` `arr[], ``int` `n)``{``    ``// Put all elements in a hash map``    ``unordered_map<``int``, ``int``> hm;``    ``for` `(``int` `i = 0; i < n; i++)``        ``hm[arr[i]]++;` `    ``// Find counts of maximum and minimum``    ``// frequent elements``    ``int` `max_count = 0, min_count = n;``    ``for` `(``auto` `x : hm) {``        ``max_count = max(max_count, x.second);``        ``min_count = min(min_count, x.second);``    ``}` `    ``return` `(max_count - min_count);``}` `// Driver``int` `main()``{``    ``int` `arr[] = { 7, 8, 4, 5, 4, 1, 1, 7, 7, 2, 5 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``cout << findDiff(arr, n) << ``"\n"``;``    ``return` `0;``}`

## Java

 `// Java code to find the difference between highest``// and least frequencies``import` `java.util.*;` `class` `GFG``{` `static` `int` `findDiff(``int` `arr[], ``int` `n)``{``    ``// Put all elements in a hash map``    ``Map mp = ``new` `HashMap<>();``    ``for` `(``int` `i = ``0` `; i < n; i++)``    ``{``        ``if``(mp.containsKey(arr[i]))``        ``{``            ``mp.put(arr[i], mp.get(arr[i])+``1``);``        ``}``        ``else``        ``{``            ``mp.put(arr[i], ``1``);``        ``}``    ``}` `    ``// Find counts of maximum and minimum``    ``// frequent elements``    ``int` `max_count = ``0``, min_count = n;``    ``for` `(Map.Entry x : mp.entrySet())``    ``{``        ``max_count = Math.max(max_count, x.getValue());``        ``min_count = Math.min(min_count, x.getValue());``    ``}` `    ``return` `(max_count - min_count);``}` `// Driver code``public` `static` `void` `main(String[] args)``{``    ``int` `arr[] = { ``7``, ``8``, ``4``, ``5``, ``4``, ``1``, ``1``, ``7``, ``7``, ``2``, ``5` `};``    ``int` `n = arr.length;``    ``System.out.println(findDiff(arr, n));``}``}` `/* This code is contributed by PrinciRaj1992 */`

## Python3

 `# Python code to find the difference between highest``# and least frequencies` `from` `collections ``import` `defaultdict``def` `findDiff(arr,n):` `    ``# Put all elements in a hash map``    ``mp ``=` `defaultdict(``lambda``:``0``)``    ``for` `i ``in` `range``(n):``        ``mp[arr[i]]``+``=``1` `    ``# Find counts of maximum and minimum``    ``# frequent elements``    ``max_count``=``0``;min_count``=``n``    ``for` `key,values ``in` `mp.items():``        ``max_count``=` `max``(max_count,values)``        ``min_count ``=` `min``(min_count,values)` `    ``return` `max_count``-``min_count`  `# Driver code``arr ``=` `[ ``7``, ``8``, ``4``, ``5``, ``4``, ``1``, ``1``, ``7``, ``7``, ``2``, ``5``]``n ``=` `len``(arr)``print``(findDiff(arr,n))` `# This code is contributed by Shrikant13`

## C#

 `// C# code to find the difference between highest``// and least frequencies``using` `System;``using` `System.Collections.Generic;` `class` `GFG``{` `static` `int` `findDiff(``int` `[]arr, ``int` `n)``{``    ``// Put all elements in a hash map``    ``Dictionary<``int``,``int``> mp = ``new` `Dictionary<``int``,``int``>();``    ``for` `(``int` `i = 0 ; i < n; i++)``    ``{``        ``if``(mp.ContainsKey(arr[i]))``        ``{``            ``var` `val = mp[arr[i]];``            ``mp.Remove(arr[i]);``            ``mp.Add(arr[i], val + 1);``        ``}``        ``else``        ``{``            ``mp.Add(arr[i], 1);``        ``}``    ``}` `    ``// Find counts of maximum and minimum``    ``// frequent elements``    ``int` `max_count = 0, min_count = n;``    ``foreach``(KeyValuePair<``int``, ``int``> entry ``in` `mp)``    ``{``        ``max_count = Math.Max(max_count, entry.Value);``        ``min_count = Math.Min(min_count, entry.Value);``    ``}` `    ``return` `(max_count - min_count);``}` `// Driver code``public` `static` `void` `Main(String[] args)``{``    ``int` `[]arr = { 7, 8, 4, 5, 4, 1, 1, 7, 7, 2, 5 };``    ``int` `n = arr.Length;``    ``Console.WriteLine(findDiff(arr, n));``}``}` `// This code is contributed by Princi Singh`

## Javascript

 ``

Output

`2`

Time Complexity: O(n) since one traversal of the array is required to complete all operations hence the overall time required by the algorithm is linear
Auxiliary Space: O(n) since an unordered map is used, in the worst case all elements will be stored inside the unordered map thus the space taken by the algorithm is linear

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.

My Personal Notes arrow_drop_up