在给定的嵌套数组中查找频率最高的元素

给定一个由N 个整数组成的数组arr[] 。任务是创建给定数组arr[]的频率数组freq []并找到频率数组的最大元素。如果数组freq[]中的两个元素具有相同的频率，则返回具有较小值的元素。

例子：

Input: arr[] = {1, 1, 1, 2, 3, 2, 2, 3, 5, 5, 5, 5, 4, 4, 4, 4, 4}; 
Output: 3 
Explanation: 
frequency of elements is given by: 
val -> freq[] 
1 -> 3 
2 -> 3 
3 -> 2 
4 -> 5 
5 -> 4 
Element 3 has the maximum frequency in the frequency array.

Input: arr[] = { 3, 5, 15, 51, 15, 14, 14, 14, 14, 4}; 
Output: 1 
Explanation: 
frequency of elements is given by: 
val -> freq[] 
3 -> 1 
4 -> 1 
5 -> 1 
14 -> 4 
15 -> 2 
51 -> 1 
Element 1 has the maximum frequency in the frequency array. 
 

方法：

1. 将arr[]元素的频率存储在地图中，比如map1 ，将arr[] 的元素作为键，将它们的频率作为值。
2. 现在，将map1元素的频率存储在其他地图中，比如map2 。
3. 遍历map2以获取最高元素。
4. 如果有多个最高元素比具有较低值的元素打印。

下面是上述方法的实现：

C++14

// C++14 program for the above approach
#include 
using namespace std;
 
// Function to get the highest
// frequency of frequency array
int findElement(int a[], int n)
{
    // To find the maximum frequency
    // initialize it with INT_MIN
    int mx = INT_MIN;
    int ans = 0;
 
    // Initialize maps to store the
    // count of element in array
    map map1, map2;
 
    // Store the frequency of
    // element of array in map1
    for (int i = 0; i < n; i++) {
        map1[a[i]]++;
    }
 
    // Storing the frequency i.e.,
    // (x.second) which is count of
    // element in array
    for (auto x : map1) {
        map2[x.second]++;
    }
 
    for (auto x : map2) {
 
        // Check if the frequency of
        // element is greater than mx
        if (x.second > mx) {
            mx = x.second;
 
            // Store the value to check
            // when frequency is same
            ans = x.first;
        }
 
        // If frequency of 2 element is
        // same than storing minimum value
        else if (x.second == mx) {
            ans = min(ans, x.first);
        }
    }
 
    // Return the highest frequency
    return ans;
}
 
// Driver Code
int main()
{
    // Given array arr[]
    int arr[] = { 1, 1, 1, 2, 3, 2, 2, 3, 5,
                  5, 5, 5, 4, 4, 4, 4, 4 };
 
    // Size of the array
    int n = sizeof(arr) / sizeof(arr[0]);
 
    // Function Call
    cout << findElement(arr, n) << endl;
}

Java

// Java program for the above approach
import java.util.*;
 
class GFG{
 
// Function to get the highest
// frequency of frequency array
static int findElement(int a[], int n)
{
     
    // To find the maximum frequency
    // initialize it with INT_MIN
    int mx = Integer.MIN_VALUE;
    int ans = 0;
 
    // Initialize maps to store the
    // count of element in array
    Map map1 = new HashMap<>(),
                          map2 = new HashMap<>();
 
    // Store the frequency of
    // element of array in map1
    for(int i = 0; i < n; i++)
    {
        map1.put(a[i], map1.getOrDefault(a[i], 0) + 1);
    }
 
    // Storing the frequency i.e.,
    // (x.second) which is count of
    // element in array
    for(Integer x : map1.values())
    {
        map2.put(x, map2.getOrDefault(x, 0) + 1);
    }
 
    for(Map.Entry x : map2.entrySet())
    {
         
        // Check if the frequency of
        // element is greater than mx
        if (x.getValue() > mx)
        {
            mx = x.getValue();
 
            // Store the value to check
            // when frequency is same
            ans = x.getKey();
        }
 
        // If frequency of 2 element is
        // same than storing minimum value
        else if (x.getValue() == mx)
        {
            ans = Math.min(ans, x.getKey());
        }
    }
 
    // Return the highest frequency
    return ans;
}
 
// Driver code
public static void main (String[] args)
{
     
    // Given array arr[]
    int arr[] = { 1, 1, 1, 2, 3, 2, 2, 3, 5,
                  5, 5, 5, 4, 4, 4, 4, 4 };
     
    // Size of the array
    int n = arr.length;
     
    // Function call
    System.out.println(findElement(arr, n));
}
}
 
// This code is contributed by offbeat

Python3

# Python3 program for the above approach
import sys
 
# Function to get the highest
# frequency of frequency array
def findElement(a, n):
     
    # To find the maximum frequency
    # initialize it with INT_MIN
    mx = -sys.maxsize - 1
    ans = 0
 
    # Initialize maps to store the
    # count of element in array
    map1 = {}
    map2 = {}
 
    # Store the frequency of
    # element of array in map1
    for i in a:
        map1[i] = map1.get(i, 0) + 1
 
    # Storing the frequency i.e.,
    # (x.second) which is count of
    # element in array
    for x in map1:
        map2[map1[x]] = map2.get(map1[x], 0) + 1
 
    for x in map2:
 
        # Check if the frequency of
        # element is greater than mx
        if (map2[x] > mx):
            mx = map2[x]
 
            # Store the value to check
            # when frequency is same
            ans = x
 
        # If frequency of 2 element is
        # same than storing minimum value
        elif (map2[x] == mx):
            ans = min(ans, x)
 
    # Return the highest frequency
    return ans
 
# Driver Code
if __name__ == '__main__':
     
    # Given array arr[]
    arr = [ 1, 1, 1, 2, 3, 2, 2, 3,
            5, 5, 5, 5, 4, 4, 4, 4, 4]
 
    # Size of the array
    n = len(arr)
 
    # Function call
    print(findElement(arr, n))
 
# This code is contributed by mohit kumar 29

C#

// C# program for the above approach
using System;
using System.Collections.Generic;
 
class GFG{
     
// Function to get the highest
// frequency of frequency array
static int findElement(int[] a, int n)
{
     
    // To find the maximum frequency
    // initialize it with INT_MIN
    int mx = Int32.MinValue;
    int ans = 0;
 
    // Initialize maps to store the
    // count of element in array
    Dictionary map1 = new Dictionary(),
                    map2 = new Dictionary();
 
    // Store the frequency of
    // element of array in map1
    for(int i = 0; i < n; i++)
    { 
        if (map1.ContainsKey(a[i]))
            map1[a[i]] = map1[a[i]] + 1;
        else
            map1[a[i]] = 1;
    }
 
    // Storing the frequency i.e.,
    // (x.second) which is count of
    // element in array
    foreach(KeyValuePair xx in map1)
    {
        int x = xx.Value;
        if (map2.ContainsKey(x))
            map2[x] = map2[x] + 1;
        else
            map2[x] = 1;
    }
     
    foreach(KeyValuePair x in map2)
    {
         
        // Check if the frequency of
        // element is greater than mx
        if (x.Value > mx)
        {
            mx = x.Value;
             
            // Store the value to check
            // when frequency is same
            ans = x.Key;
        }
         
        // If frequency of 2 element is
        // same than storing minimum value
        else if (x.Value == mx)
        {
            ans = Math.Min(ans, x.Key);
        }
    }
     
    // Return the highest frequency
    return ans;
}
     
// Driver code
static public void Main ()
{
     
    // Given array arr[]
    int[] arr = { 1, 1, 1, 2, 3, 2, 2, 3, 5,
                  5, 5, 5, 4, 4, 4, 4, 4 };
     
    // Size of the array
    int n = arr.Length;
     
    // Function call
    Console.WriteLine(findElement(arr, n));
}
}
 
// This code is contributed by offbeat

Javascript

// Javascript program for the above approach
 
// Function to get the highest
// frequency of frequency array
function findElement(a, n)
{
    // To find the maximum frequency
    // initialize it with INT_MIN
    var mx = -1000000000;
    var ans = 0;
 
    // Initialize maps to store the
    // count of element in array
    var map1 = new Map(), map2= new Map();
 
    // Store the frequency of
    // element of array in map1
    for (var i = 0; i < n; i++) {
        if(map1.has(a[i]))
            map1.set(a[i], map1.get(a[i])+1)
        else
            map1.set(a[i], 1);
    }
 
    // Storing the frequency i.e.,
    // (x.second) which is count of
    // element in array
    map1.forEach((value, key) => {
         
        if(map2.has(value))
            map2.set(value, map2.get(value)+1)
        else
            map2.set(value, 1);
    });
 
    map2.forEach((value, key) => {
         
        // Check if the frequency of
        // element is greater than mx
        if (value > mx) {
            mx = value;
 
            // Store the value to check
            // when frequency is same
            ans = key;
        }
 
        // If frequency of 2 element is
        // same than storing minimum value
        else if (value == mx) {
            ans = Math.min(ans, key);
        }
    });
 
    // Return the highest frequency
    return ans;
}
 
// Driver Code
// Given array arr[]
var arr = [1, 1, 1, 2, 3, 2, 2, 3, 5,
              5, 5, 5, 4, 4, 4, 4, 4];
// Size of the array
var n = arr.length;
// Function Call
document.write( findElement(arr, n));
 
 
 

输出：

3

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

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。