Related Articles

# Maximum absolute difference between distinct elements in an Array

• Last Updated : 18 May, 2021

Given an array arr[] of N integers, the task is to find the maximum absolute difference between distinct elements of the array.
Examples:

Input: arr[] = {12, 10, 9, 45, 2, 10, 10, 45, 10}
Output: 10
Explanation:
Distinct elements of given array are 12, 9, 2.
Therefore, the maximum absolute difference between them is (12 – 2) = 10.

Input: arr[] = {2, -1, 10, 3, -2, -1, 10}
Output:
Explanation:
Distinct elements of given array are 2, 3, -2.
Therefore, the maximum absolute difference between them is (3 – (-2)) = 5.

Naive Approach: The naive approach is to store the distinct element in the given array in an array temp[] and print the difference of maximum and minimum element of the array temp[].

Time Complexity: O(N2
Auxiliary Space: O(N)

Efficient Approach: The above naive approach can be optimized using Hashing. Below are the steps:

1. Store the frequency of each element of the array arr[] in a HashMap.
2. Now find the maximum and minimum value of the array whose frequency is 1 using the above HashMap created.
3. Print the difference between the maximum and minimum value obtained in the above step.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to find the maximum``// absolute difference between``// distinct elements in arr[]``int` `MaxAbsDiff(``int` `arr[], ``int` `n)``{``    ` `    ``// Map to store each element``    ``// with their occurrence in array``    ``unordered_map<``int``, ``int``> map;` `    ``// maxElement and minElement to``    ``// store maximum and minimum``    ``// distinct element in arr[]``    ``int` `maxElement = INT_MIN;``    ``int` `minElement = INT_MAX;` `    ``// Traverse arr[] and update each``    ``// element frequency in Map``    ``for``(``int` `i = 0; i < n; i++)``    ``{``        ``map[arr[i]]++;``    ``}` `    ``// Traverse Map and check if``    ``// value of any key appears 1``    ``// then update maxElement and``    ``// minElement by that key``    ``for``(``auto` `itr = map.begin();``             ``itr != map.end(); itr++)``    ``{``        ``if` `(itr -> second == 1)``        ``{``            ``maxElement = max(maxElement,``                             ``itr -> first);``            ``minElement = min(minElement,``                             ``itr -> first);``        ``}``    ``}` `    ``// Return absolute difference of``    ``// maxElement and minElement``    ``return` `abs``(maxElement - minElement);``}` `// Driver Code``int` `main()``{``    ` `    ``// Given array arr[]``    ``int` `arr[] = { 12, 10, 9, 45, 2,``                  ``10, 10, 45, 10 };` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``// Function call``    ``cout << MaxAbsDiff(arr, n) << ``"\n"``;``    ` `    ``return` `0;``}` `// This code is contributed by akhilsaini`

## Java

 `// Java program for the above approach``import` `java.util.*;` `class` `GFG {` `    ``// Function to find the maximum``    ``// absolute difference between``    ``// distinct elements in arr[]``    ``static` `int` `MaxAbsDiff(``int``[] arr, ``int` `n)``    ``{``        ``// HashMap to store each element``        ``// with their occurrence in array``        ``Map map``            ``= ``new` `HashMap<>();` `        ``// maxElement and minElement to``        ``// store maximum and minimum``        ``// distinct element in arr[]``        ``int` `maxElement = Integer.MIN_VALUE;``        ``int` `minElement = Integer.MAX_VALUE;` `        ``// Traverse arr[] and update each``        ``// element frequency in HashMap``        ``for` `(``int` `i = ``0``; i < n; i++) {``            ``map.put(arr[i],``                    ``map.getOrDefault(arr[i], ``0``)``                        ``+ ``1``);``        ``}` `        ``// Traverse HashMap and check if``        ``// value of any key appears 1``        ``// then update maxElement and``        ``// minElement by that key``        ``for` `(Map.Entry k :``             ``map.entrySet()) {` `            ``if` `(k.getValue() == ``1``) {``                ``maxElement``                    ``= Math.max(maxElement,``                               ``k.getKey());``                ``minElement``                    ``= Math.min(minElement,``                               ``k.getKey());``            ``}``        ``}` `        ``// Return absolute difference of``        ``// maxElement and minElement``        ``return` `Math.abs(maxElement``                        ``- minElement);``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``// Given array arr[]``        ``int``[] arr = { ``12``, ``10``, ``9``, ``45``, ``2``,``                      ``10``, ``10``, ``45``, ``10` `};``        ``int` `n = arr.length;` `        ``// Function Call``        ``System.out.println(MaxAbsDiff(arr, n));``    ``}``}`

## Python3

 `# Python3 program for``# the above approach``import` `sys``from` `collections ``import` `defaultdict` `# Function to find the maximum``# absolute difference between``# distinct elements in arr[]``def` `MaxAbsDiff(arr, n):` `    ``# HashMap to store each element``    ``# with their occurrence in array``    ``map` `=` `defaultdict (``int``)` `    ``# maxElement and minElement to``    ``# store maximum and minimum``    ``# distinct element in arr[]``    ``maxElement ``=` `-``sys.maxsize ``-` `1``    ``minElement ``=` `sys.maxsize` `    ``# Traverse arr[] and update each``    ``# element frequency in HashMap``    ``for` `i ``in` `range` `(n):``        ``map``[arr[i]] ``+``=` `1` `    ``# Traverse HashMap and check if``    ``# value of any key appears 1``    ``# then update maxElement and``    ``# minElement by that key``    ``for` `k ``in` `map``:``        ``if` `(``map``[k] ``=``=` `1``):``            ``maxElement ``=` `max``(maxElement, k)``            ``minElement ``=` `min``(minElement, k)` `    ``# Return absolute difference of``    ``# maxElement and minElement``    ``return` `abs``(maxElement ``-` `minElement)` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:``  ` `    ``# Given array arr[]``    ``arr ``=` `[``12``, ``10``, ``9``, ``45``, ``2``,``           ``10``, ``10``, ``45``, ``10``]``    ``n ``=` `len``( arr)` `    ``# Function Call``    ``print``(MaxAbsDiff(arr, n))` `# This code is contributed by Chitranayal`

## C#

 `// C# program for the above approach``using` `System;``using` `System.Collections.Generic;` `class` `GFG{` `// Function to find the maximum``// absolute difference between``// distinct elements in []arr``static` `int` `MaxAbsDiff(``int``[] arr, ``int` `n)``{``    ` `    ``// Dictionary to store each element``    ``// with their occurrence in array``    ``Dictionary<``int``,``               ``int``> map = ``new` `Dictionary<``int``,``                                         ``int``>();` `    ``// maxElement and minElement to``    ``// store maximum and minimum``    ``// distinct element in []arr``    ``int` `maxElement = ``int``.MinValue;``    ``int` `minElement = ``int``.MaxValue;` `    ``// Traverse []arr and update each``    ``// element frequency in Dictionary``    ``for``(``int` `i = 0; i < n; i++)``    ``{``       ``if``(map.ContainsKey(arr[i]))``          ``map[arr[i]] = map[arr[i]] + 1;``       ``else``          ``map.Add(arr[i], 1);``    ``}` `    ``// Traverse Dictionary and check if``    ``// value of any key appears 1``    ``// then update maxElement and``    ``// minElement by that key``    ``foreach` `(KeyValuePair<``int``, ``int``> k ``in` `map)``    ``{``        ``if` `(k.Value == 1)``        ``{``            ``maxElement = Math.Max(maxElement,``                                  ``k.Key);``            ``minElement = Math.Min(minElement,``                                  ``k.Key);``        ``}``    ``}` `    ``// Return absolute difference of``    ``// maxElement and minElement``    ``return` `Math.Abs(maxElement - minElement);``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ` `    ``// Given array []arr``    ``int``[] arr = { 12, 10, 9, 45, 2,``                  ``10, 10, 45, 10 };``    ``int` `n = arr.Length;` `    ``// Function call``    ``Console.WriteLine(MaxAbsDiff(arr, n));``}``}` `// This code is contributed by Princi Singh`

## Javascript

 ``
Output:
`10`

Time Complexity: O(N)
Auxiliary Space: O(N)

Attention reader! Don’t stop learning now. Join the First-Step-to-DSA Course for Class 9 to 12 students , specifically designed to introduce data structures and algorithms to the class 9 to 12 students

My Personal Notes arrow_drop_up