Given an array of **n** positive integers with many repeating elements. The task is to find maximum difference between the frequency of any two different elements, such that the element with greater frequency is also greater in value than the second integer.

**Examples:**

Input :arr[] = { 3, 1, 3, 2, 3, 2 }.Output :2 Frequency of 3 = 3. Frequency of 2 = 2. Frequency of 1 = 1. Here difference of frequency of element 3 and 1 is = 3 - 1 = 2. Also 3 > 1.

**Method 1 (Use Hashing):**

The naive approach can be, find the frequency of each element and for each element find the element having lesser value and lesser frequency than the current element.

Below is the implementation of this approach:

## C++

`// C++ program to find maximum difference` `// between frequency of any two element` `// such that element with greater frequency` `// is also greater in value.` `#include<bits/stdc++.h>` `using` `namespace` `std;` `// Return the maximum difference between` `// frequencies of any two elements such that` `// element with greater frequency is also` `// greater in value.` `int` `maxdiff(` `int` `arr[], ` `int` `n)` `{` ` ` `unordered_map<` `int` `, ` `int` `> freq;` ` ` `// Finding the frequency of each element.` ` ` `for` `(` `int` `i = 0; i < n; i++)` ` ` `freq[arr[i]]++;` ` ` `int` `ans = 0;` ` ` `for` `(` `int` `i=0; i<n; i++)` ` ` `{` ` ` `for` `(` `int` `j=0; j<n; j++)` ` ` `{` ` ` `// finding difference such that element` ` ` `// having greater frequency is also` ` ` `// greater in value.` ` ` `if` `(freq[arr[i]] > freq[arr[j]] &&` ` ` `arr[i] > arr[j] )` ` ` `ans = max(ans, freq[arr[i]]-freq[arr[j]]);` ` ` `else` `if` `(freq[arr[i]] < freq[arr[j]] &&` ` ` `arr[i] < arr[j] )` ` ` `ans = max(ans, freq[arr[j]]-freq[arr[i]]);` ` ` `}` ` ` `}` ` ` `return` `ans;` `}` `// Driven Program` `int` `main()` `{` ` ` `int` `arr[] = { 3, 1, 3, 2, 3, 2 };` ` ` `int` `n = ` `sizeof` `(arr)/` `sizeof` `(arr[0]);` ` ` `cout << maxdiff(arr, n) << endl;` ` ` `return` `0;` `}` |

*chevron_right*

*filter_none*

## Java

`// Java program to find maximum difference` `// between frequency of any two element` `// such that element with greater frequency` `// is also greater in value.` `import` `java.util.*;` `class` `GFG ` `{` `// Return the maximum difference between` `// frequencies of any two elements such that` `// element with greater frequency is also` `// greater in value.` `static` `int` `maxdiff(` `int` `arr[], ` `int` `n)` `{` ` ` `Map<Integer, Integer> freq = ` `new` `HashMap<>();` ` ` `// Finding the frequency of each element.` ` ` `for` `(` `int` `i = ` `0` `; i < n; i++)` ` ` `freq.put(arr[i], ` ` ` `freq.get(arr[i]) == ` `null` `? ` `1` `: ` ` ` `freq.get(arr[i]) + ` `1` `);` ` ` `int` `ans = ` `0` `;` ` ` `for` `(` `int` `i = ` `0` `; i < n; i++)` ` ` `{` ` ` `for` `(` `int` `j = ` `0` `; j < n; j++)` ` ` `{` ` ` `// finding difference such that element` ` ` `// having greater frequency is also` ` ` `// greater in value.` ` ` `if` `(freq.get(arr[i]) > freq.get(arr[j]) &&` ` ` `arr[i] > arr[j])` ` ` `ans = Math.max(ans, freq.get(arr[i]) - ` ` ` `freq.get(arr[j]));` ` ` `else` `if` `(freq.get(arr[i]) < freq.get(arr[j]) &&` ` ` `arr[i] < arr[j] )` ` ` `ans = Math.max(ans, freq.get(arr[j]) - ` ` ` `freq.get(arr[i]));` ` ` `}` ` ` `}` ` ` `return` `ans;` `}` `// Driver Code` `public` `static` `void` `main(String[] args)` `{` ` ` `int` `arr[] = { ` `3` `, ` `1` `, ` `3` `, ` `2` `, ` `3` `, ` `2` `};` ` ` `int` `n = arr.length;` ` ` `System.out.println(maxdiff(arr, n));` `}` `}` `// This code is contributed by 29AjayKumar` |

*chevron_right*

*filter_none*

## Python3

`# Python program to find maximum difference ` `# between frequency of any two element ` `# such that element with greater frequency ` `# is also greater in value. ` `from` `collections ` `import` `defaultdict` `# Return the maximum difference between ` `# frequencies of any two elements such that ` `# element with greater frequency is also ` `# greater in value. ` `def` `maxdiff(arr, n):` ` ` `freq ` `=` `defaultdict(` `lambda` `: ` `0` `)` ` ` `# Finding the frequency of each element.` ` ` `for` `i ` `in` `range` `(n):` ` ` `freq[arr[i]] ` `+` `=` `1` ` ` `ans ` `=` `0` ` ` `for` `i ` `in` `range` `(n):` ` ` `for` `j ` `in` `range` `(n):` ` ` `# finding difference such that element ` ` ` `# having greater frequency is also ` ` ` `# greater in value. ` ` ` `if` `freq[arr[i]] > freq[arr[j]] ` `and` `arr[i] > arr[j]:` ` ` `ans ` `=` `max` `(ans, freq[arr[i]] ` `-` `freq[arr[j]])` ` ` `elif` `freq[arr[i]] < freq[arr[j]] ` `and` `arr[i] < arr[j]:` ` ` `ans ` `=` `max` `(ans, freq[arr[j]] ` `-` `freq[arr[i]])` ` ` `return` `ans` `arr ` `=` `[` `3` `,` `1` `,` `3` `,` `2` `,` `3` `,` `2` `]` `n ` `=` `len` `(arr)` `print` `(maxdiff(arr,n))` `# This code is contributed by Shrikant13` |

*chevron_right*

*filter_none*

## C#

`// C# program to find maximum difference ` `// between frequency of any two element ` `// such that element with greater frequency ` `// is also greater in value. ` `using` `System;` `using` `System.Collections.Generic;` `class` `GFG` `{` ` ` `// Return the maximum difference between ` ` ` `// frequencies of any two elements such that ` ` ` `// element with greater frequency is also ` ` ` `// greater in value.` ` ` `static` `int` `maxdiff(` `int` `[] arr, ` `int` `n)` ` ` `{` ` ` `Dictionary<` `int` `, ` ` ` `int` `> freq = ` `new` `Dictionary<` `int` `,` ` ` `int` `>();` ` ` `// Finding the frequency of each element.` ` ` `for` `(` `int` `i = 0; i < n; i++)` ` ` `{` ` ` `if` `(freq.ContainsKey(arr[i]))` ` ` `freq[arr[i]]++;` ` ` `else` ` ` `freq.Add(arr[i], 1);` ` ` `}` ` ` `int` `ans = 0;` ` ` `for` `(` `int` `i = 0; i < n; i++)` ` ` `{` ` ` `for` `(` `int` `j = 0; j < n; j++)` ` ` `{` ` ` `// finding difference such that element ` ` ` `// having greater frequency is also ` ` ` `// greater in value.` ` ` `if` `(freq[arr[i]] > freq[arr[j]] && arr[i] > arr[j])` ` ` `ans = Math.Max(ans, freq[arr[i]] - freq[arr[i]]);` ` ` `else` `if` `(freq[arr[i]] < freq[arr[j]] && arr[i] < arr[j])` ` ` `ans = Math.Max(ans, freq[arr[j]] - freq[arr[i]]);` ` ` `}` ` ` `}` ` ` `return` `ans;` ` ` `}` ` ` `// Driver Code ` ` ` `public` `static` `void` `Main(String[] args)` ` ` `{` ` ` `int` `[] arr = { 3, 1, 3, 2, 3, 2 };` ` ` `int` `n = arr.Length;` ` ` `Console.WriteLine(maxdiff(arr, n));` ` ` `}` `}` `// This code is contributed by` `// sanjeev2552` |

*chevron_right*

*filter_none*

**Output:**

2

**Time Complexity:** O(n^{2}).

**Method 2 (Use Hashing and Sorting):**

The idea is to find all the distinct elements and store in an array, say dist[ ]. Sort the distinct element array dist[] in increasing order. Now for any distinct element at index i, for all index j such that i > j > 0, find the element between index 0 to i-1 having minimum frequency. We can find frequency of an element in same way as method 1, i.e., storing frequencies in a hash table.

So do this for all i and find the maximum difference. To find the minimum frequency for all i maintain a prefix minimum.

Below is representation of this approach:

## C++

`// Efficient C++ program to find maximum ` `// difference between frequency of any two ` `// elements such that element with greater ` `// frequency is also greater in value. ` `#include<bits/stdc++.h> ` `using` `namespace` `std; ` `// Return the maximum difference between ` `// frequencies of any two elements such that ` `// element with greater frequency is also ` `// greater in value. ` `int` `maxdiff(` `int` `arr[], ` `int` `n) ` `{ ` ` ` `unordered_map<` `int` `, ` `int` `> freq; ` ` ` `int` `dist[n]; ` ` ` `// Finding the frequency of each element. ` ` ` `int` `j = 0; ` ` ` `for` `(` `int` `i = 0; i < n; i++) ` ` ` `{ ` ` ` `if` `(freq.find(arr[i]) == freq.end()) ` ` ` `dist[j++] = arr[i]; ` ` ` `freq[arr[i]]++; ` ` ` `} ` ` ` `// Sorting the distinct element ` ` ` `sort(dist, dist + j); ` ` ` `int` `min_freq = n+1; ` ` ` `// Iterate through all sorted distinct elements. ` ` ` `// For each distinct element, maintaining the ` ` ` `// element with minimum frequency than that ` ` ` `// element and also finding the maximum ` ` ` `// frequency difference ` ` ` `int` `ans = 0; ` ` ` `for` `(` `int` `i=0; i<j; i++) ` ` ` `{ ` ` ` `int` `cur_freq = freq[dist[i]]; ` ` ` `ans = max(ans, cur_freq - min_freq); ` ` ` `min_freq = min(min_freq, cur_freq); ` ` ` `} ` ` ` `return` `ans; ` `} ` `// Driven Program ` `int` `main() ` `{ ` ` ` `int` `arr[] = { 3, 1, 3, 2, 3, 2 }; ` ` ` `int` `n = ` `sizeof` `(arr)/` `sizeof` `(arr[0]); ` ` ` `cout << maxdiff(arr, n) << endl; ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

## Python3

`# Efficient Python3 program to find maximum ` `# difference between frequency of any two ` `# elements such that element with greater ` `# frequency is also greater in value. ` `# Return the maximum difference between ` `# frequencies of any two elements such that ` `# element with greater frequency is also ` `# greater in value. ` `def` `maxdiff(arr, n):` ` ` `freq ` `=` `{}` ` ` `dist ` `=` `[` `0` `] ` `*` `n` ` ` ` ` `# Finding the frequency of each element. ` ` ` `j ` `=` `0` ` ` `for` `i ` `in` `range` `(n):` ` ` `if` `(arr[i] ` `not` `in` `freq):` ` ` `dist[j] ` `=` `arr[i]` ` ` `j ` `+` `=` `1` ` ` `freq[arr[i]] ` `=` `0` ` ` `if` `(arr[i] ` `in` `freq):` ` ` `freq[arr[i]] ` `+` `=` `1` ` ` `dist ` `=` `dist[:j]` ` ` ` ` `# Sorting the distinct element ` ` ` `dist.sort()` ` ` `min_freq ` `=` `n ` `+` `1` ` ` ` ` `# Iterate through all sorted distinct elements. ` ` ` `# For each distinct element, maintaining the ` ` ` `# element with minimum frequency than that ` ` ` `# element and also finding the maximum ` ` ` `# frequency difference ` ` ` `ans ` `=` `0` ` ` `for` `i ` `in` `range` `(j):` ` ` `cur_freq ` `=` `freq[dist[i]] ` ` ` `ans ` `=` `max` `(ans, cur_freq ` `-` `min_freq) ` ` ` `min_freq ` `=` `min` `(min_freq, cur_freq) ` ` ` ` ` `return` `ans ` `# Driven Program ` `arr ` `=` `[` `3` `, ` `1` `, ` `3` `, ` `2` `, ` `3` `, ` `2` `]` `n ` `=` `len` `(arr)` `print` `(maxdiff(arr, n))` `# This code is contributed by SHUBHAMSINGH10` |

*chevron_right*

*filter_none*

## C#

`// Efficient C# program to find maximum` `// difference between frequency of any two` `// elements such that element with greater` `// frequency is also greater in value.` `using` `System.Collections.Generic; ` `using` `System; ` `class` `GFG{` ` ` `// Return the maximum difference between` `// frequencies of any two elements such` `// that element with greater frequency ` `// is also greater in value.` `static` `int` `maxdiff(` `int` `[]arr, ` `int` `n)` `{` ` ` `Dictionary<` `int` `,` ` ` `int` `> freq = ` `new` `Dictionary<` `int` `, ` ` ` `int` `>();` ` ` `List<` `int` `> dist = ` `new` `List<` `int` `>();` ` ` ` ` `// Finding the frequency of each element.` ` ` `int` `j = 0;` ` ` `for` `(` `int` `i = 0; i < n; i++)` ` ` `{` ` ` `if` `(freq.ContainsKey(arr[i]) == ` `false` `)` ` ` `{` ` ` `dist.Add(arr[i]);` ` ` `j++;` ` ` `}` ` ` ` ` `if` `(freq.ContainsKey(arr[i]))` ` ` `freq[arr[i]]++;` ` ` `else` ` ` `freq[arr[i]]=1;` ` ` `}` ` ` `// Sorting the distinct element` ` ` `dist.Sort();` ` ` `int` `min_freq = n + 1;` ` ` `// Iterate through all sorted distinct elements.` ` ` `// For each distinct element, maintaining the` ` ` `// element with minimum frequency than that` ` ` `// element and also finding the maximum` ` ` `// frequency difference` ` ` `int` `ans = 0;` ` ` `for` `(` `int` `i = 0; i < j; i++)` ` ` `{` ` ` `int` `cur_freq = freq[dist[i]];` ` ` `ans = Math.Max(ans, cur_freq - min_freq);` ` ` `min_freq = Math.Min(min_freq, cur_freq);` ` ` `}` ` ` `return` `ans;` `}` `// Driver code` `public` `static` `void` `Main(String[] args) ` `{` ` ` `int` `[]arr = { 3, 1, 3, 2, 3, 2 };` ` ` `int` `n = arr.Length;` ` ` `Console.WriteLine(maxdiff(arr, n));` `}` `}` `// This code is contributed by Stream_Cipher` |

*chevron_right*

*filter_none*

**Output:**

2

**Time Complexity : **O(n log n).

This article is contributed by **Anuj Chauhan(anuj0503)**. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@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.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready.

## Recommended Posts:

- Count of elements such that its sum/difference with X also exists in the Array
- Find the number of elements X such that X + K also exists in the array
- Maximum length prefix such that frequency of each character is atmost number of characters with minimum frequency
- Find the element having different frequency than other array elements
- Maximum product from array such that frequency sum of all repeating elements in product is less than or equal to 2 * k
- Count of distinct possible pairs such that the element from A is greater than the element from B
- Replace each element by the difference of the total size of the array and frequency of that element
- Length of longest subarray having frequency of every element equal to K
- Substring of length K having maximum frequency in the given string
- Next Greater Frequency Element
- Sum of elements in an array having prime frequency
- Product of elements in an array having prime frequency
- XOR of elements in an array having prime frequency
- Sum of elements in an array having composite frequency
- Count the elements having frequency equals to its value
- Count the elements having frequency equals to its value | Set 2
- Count elements such that there are exactly X elements with values greater than or equal to X
- Count number of subsets whose median is also present in the same subset
- Maximum distance between two elements whose absolute difference is K
- Find all elements in array which have at-least two greater elements