数组中不同元素之间的最大绝对差异

给定一个由N 个整数组成的数组arr[] ，任务是找到数组不同元素之间的最大绝对差。
例子：

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: 5 
Explanation: 
Distinct elements of given array are 2, 3, -2. 
Therefore, the maximum absolute difference between them is (3 – (-2)) = 5. 
 

幼稚做法：将幼稚的方法是在给定阵列中的不同元件存储在数组中的临时[]和打印最大的阵列温度[]的差和最小元件。

时间复杂度： O(N ² )
辅助空间： O(N)

高效的方法：可以使用哈希优化上述朴素的方法。以下是步骤：

1. 将数组arr[]的每个元素的频率存储在 HashMap 中。
2. 现在使用上面创建的 HashMap 找到频率为1的数组的最大值和最小值。
3. 打印上一步得到的最大值和最小值的差值。

下面是上述方法的实现：

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 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 map = new Dictionary();
 
    // 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 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

// Javascript program for the above approach
 
// Function to find the maximum
// absolute difference between
// distinct elements in arr[]
function MaxAbsDiff(arr, n)
{
     
    // Map to store each element
    // with their occurrence in array
    var map = new Map();
 
    // maxElement and minElement to
    // store maximum and minimum
    // distinct element in arr[]
    var maxElement = -1000000000;
    var minElement = 1000000000;
 
    // Traverse arr[] and update each
    // element frequency in Map
    for(var i = 0; i < n; i++)
    {
        if(map.has(arr[i]))
            map.set(arr[i], map.get(arr[i])+1)
        else
            map.set(arr[i], 1);
    }
 
    // Traverse Map and check if
    // value of any key appears 1
    // then update maxElement and
    // minElement by that key
    map.forEach((value, key) => {
     
        if (value == 1)
        {
            maxElement = Math.max(maxElement,
                             key);
            minElement = Math.min(minElement,
                             key);
        }
    });
 
    // Return absolute difference of
    // maxElement and minElement
    return Math.abs(maxElement - minElement);
}
 
// Driver Code
 
// Given array arr[]
var arr = [12, 10, 9, 45, 2,
              10, 10, 45, 10 ];
var n = arr.length;
// Function call
document.write( MaxAbsDiff(arr, n));
 
// This code is contributed by famously.

输出：

10

时间复杂度： O(N)
辅助空间： O(N)