在给定数组中找到频率最小的元素中的最大元素

给定一个由N个整数组成的数组arr[] ，任务是找到具有最小频率的最大元素。

例子：

Input: arr[] = {2, 2, 5, 50, 1}
Output: 50
Explanation:
The element with minimum frequency is {1, 5, 50}. The maximum element among these element is 50.

Input: arr[] = {3, 2, 5, 6, 1}
Output: 6

方法：给定问题可以通过将数组元素的频率存储在 HashMap 中，然后找到具有最小频率的最大值来解决。请按照以下步骤解决给定问题：

• 将每个元素的频率存储在 HashMap 中，例如M 。
• 初始化两个变量，比如maxValue为INT_MIN和minFreq为INT_MAX ，它们存储结果最大元素并存储所有频率中的最小频率。
• 遍历地图M并执行以下步骤：
  • 如果当前元素的频率小于minFreq ，则将minFreq的值更新为当前频率，并将maxValue的值更新为当前元素。
  • 如果当前元素的频率等于minFreq并且maxValue的值小于当前值，则将maxValue的值更新为当前元素。
• 完成上述步骤后，打印maxValue的值作为结果元素。

下面是上述方法的实现：

C++

// C++ program for the above approach
 
#include 
using namespace std;
 
// Function to find the maximum element
// with the minimum frequency
int maxElementWithMinFreq(int* arr, int N)
{
    // Stores the frequency of array
    // elements
    unordered_map mp;
 
    // Find the frequency and store
    // in the map
    for (int i = 0; i < N; i++) {
        mp[arr[i]]++;
    }
 
    // Initialize minFreq to the maximum
    // value and minValue to the minimum
    int minFreq = INT_MAX;
    int maxValue = INT_MIN;
 
    // Traverse the map mp
    for (auto x : mp) {
 
        int num = x.first;
        int freq = x.second;
 
        // If freq < minFreq, then update
        // minFreq to freq and maxValue
        // to the current element
        if (freq < minFreq) {
            minFreq = freq;
            maxValue = num;
        }
 
        // If freq is equal to the minFreq
        // and current element > maxValue
        // then update maxValue to the
        // current element
        else if (freq == minFreq
                 && maxValue < num) {
            maxValue = num;
        }
    }
 
    // Return the resultant maximum value
    return maxValue;
}
 
// Driver Code
int main()
{
    int arr[] = { 2, 2, 5, 50, 1 };
    int N = sizeof(arr) / sizeof(arr[0]);
    cout << maxElementWithMinFreq(arr, N);
 
    return 0;
}

Java

// Java program for the above approach
import java.util.*;
 
class GFG{
 
// Function to find the maximum element
// with the minimum frequency
static int maxElementWithMinFreq(int[] arr, int N)
{
   
    // Stores the frequency of array
    // elements
    HashMap mp = new HashMap();
 
    // Find the frequency and store
    // in the map
    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);
    }
    }
 
    // Initialize minFreq to the maximum
    // value and minValue to the minimum
    int minFreq = Integer.MAX_VALUE;
    int maxValue = Integer.MIN_VALUE;
 
    // Traverse the map mp
    for (Map.Entry x : mp.entrySet()){
 
        int num = x.getKey();
        int freq = x.getValue();
 
        // If freq < minFreq, then update
        // minFreq to freq and maxValue
        // to the current element
        if (freq < minFreq) {
            minFreq = freq;
            maxValue = num;
        }
 
        // If freq is equal to the minFreq
        // and current element > maxValue
        // then update maxValue to the
        // current element
        else if (freq == minFreq
                 && maxValue < num) {
            maxValue = num;
        }
    }
 
    // Return the resultant maximum value
    return maxValue;
}
 
// Driver Code
public static void main(String[] args)
{
    int arr[] = { 2, 2, 5, 50, 1 };
    int N = arr.length;
    System.out.print(maxElementWithMinFreq(arr, N));
 
}
}
 
// This code is contributed by shikhasingrajput

Python3

# Python 3 program for the above approach
import sys
from collections import defaultdict
 
# Function to find the maximum element
# with the minimum frequency
def maxElementWithMinFreq(arr, N):
 
    # Stores the frequency of array
    # elements
    mp = defaultdict(int)
 
    # Find the frequency and store
    # in the map
    for i in range(N):
        mp[arr[i]] += 1
 
    # Initialize minFreq to the maximum
    # value and minValue to the minimum
    minFreq = sys.maxsize
    maxValue = -sys.maxsize-1
 
    # Traverse the map mp
    for x in mp:
 
        num = x
        freq = mp[x]
 
        # If freq < minFreq, then update
        # minFreq to freq and maxValue
        # to the current element
        if (freq < minFreq):
            minFreq = freq
            maxValue = num
 
        # If freq is equal to the minFreq
        # and current element > maxValue
        # then update maxValue to the
        # current element
        elif (freq == minFreq
              and maxValue < num):
            maxValue = num
 
    # Return the resultant maximum value
    return maxValue
 
# Driver Code
if __name__ == "__main__":
 
    arr = [2, 2, 5, 50, 1]
    N = len(arr)
    print(maxElementWithMinFreq(arr, N))
 
    # This code is contributed by ukasp.

C#

// C# program for the above approach
using System;
using System.Collections.Generic;
 
class GFG{
 
// Function to find the maximum element
// with the minimum frequency
static int maxElementWithMinFreq(int []arr, int N)
{
   
    // Stores the frequency of array
    // elements
    Dictionary mp = new Dictionary();
 
    // Find the frequency and store
    // in the map
    for (int i = 0; i < N; i++) {
        if(mp.ContainsKey(arr[i]))
        mp[arr[i]]++;
        else
          mp.Add(arr[i],1);
    }
 
    // Initialize minFreq to the maximum
    // value and minValue to the minimum
    int minFreq = Int32.MaxValue;
    int maxValue = Int32.MinValue;
 
    // Traverse the map mp
    foreach(KeyValuePair x in mp) {
 
        int num = x.Key;
        int freq = x.Value;
 
        // If freq < minFreq, then update
        // minFreq to freq and maxValue
        // to the current element
        if (freq < minFreq) {
            minFreq = freq;
            maxValue = num;
        }
 
        // If freq is equal to the minFreq
        // and current element > maxValue
        // then update maxValue to the
        // current element
        else if (freq == minFreq
                 && maxValue < num) {
            maxValue = num;
        }
    }
 
    // Return the resultant maximum value
    return maxValue;
}
 
// Driver Code
public static void Main()
{
    int []arr = { 2, 2, 5, 50, 1 };
    int N = arr.Length;
    Console.Write(maxElementWithMinFreq(arr, N));
}
}
 
// This code is contributed by SURENDRA_GANGWAR.

Javascript

        // JavaScript Program to implement
        // the above approach
 
        // Function to find the maximum element
        // with the minimum frequency
        function maxElementWithMinFreq(arr, N) {
            // Stores the frequency of array
            // elements
            let mp = new Map();
 
            // Find the frequency and store
            // in the map
            for (let i = 0; i < N; i++) {
                if (mp.has(arr[i])) {
                    mp.set(arr[i], mp.get(arr[i]) + 1);
                }
                else {
                    mp.set(arr[i], 1);
                }
 
            }
 
            // Initialize minFreq to the maximum
            // value and minValue to the minimum
            let minFreq = Number.MAX_VALUE
            let maxValue = Number.MIN_VALUE;
 
            // Traverse the map mp
            for (let [key, value] of mp) {
 
                let num = key;
                let freq = value;
 
                // If freq < minFreq, then update
                // minFreq to freq and maxValue
                // to the current element
                if (freq < minFreq) {
                    minFreq = freq;
                    maxValue = num;
                }
 
                // If freq is equal to the minFreq
                // and current element > maxValue
                // then update maxValue to the
                // current element
                else if (freq == minFreq
                    && maxValue < num) {
                    maxValue = num;
                }
            }
 
            // Return the resultant maximum value
            return maxValue;
        }
 
        // Driver Code
 
        let arr = [2, 2, 5, 50, 1];
        let N = arr.length;
        document.write(maxElementWithMinFreq(arr, N));
 
// This code is contributed by Potta Lokesh
    

输出：

50

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