Easy

题目描述

给你一个由正整数组成的数组 nums。

返回 nums 中具有 最大频数 的元素的 总频数。

元素的 频数 是该元素在数组中出现的次数。

示例 1：

输入：nums = [1,2,2,3,1,4]
输出：4
解释：元素 1 和 2 的频数都是 2，这是数组中的最大频数。
因此具有最大频数的元素的总数是 4。

示例 2：

输入：nums = [1,2,3,4,5]
输出：5
解释：数组的所有元素的频数都是 1，这是最大频数。
因此具有最大频数的元素的总数是 5。

提示：

  • 1 <= nums.length <= 100
  • 1 <= nums[i] <= 100

解题思路

这道题需要我们找到数组中出现频数最高的元素，然后计算所有具有最高频数的元素的总出现次数。

解题思路：

  1. 统计频数：首先遍历数组，使用哈希表（字典）统计每个元素的出现频数
  2. 找到最大频数：遍历哈希表，找出所有元素中的最大频数
  3. 计算总频数：再次遍历哈希表，将所有频数等于最大频数的元素的频数累加起来

算法步骤：

  • 用哈希表记录每个数字的出现次数
  • 找到哈希表中的最大值（最大频数）
  • 统计所有值等于最大频数的键的频数总和

这个解法的优点是思路清晰，代码简洁，适合这道简单题目。由于数据范围较小（数组长度和元素值都不超过100），时间复杂度和空间复杂度都是可接受的。

代码实现

class Solution {
public:
    int maxFrequencyElements(vector<int>& nums) {
        unordered_map<int, int> freq;
        
        // 统计每个元素的频数
        for (int num : nums) {
            freq[num]++;
        }
        
        // 找到最大频数
        int maxFreq = 0;
        for (auto& pair : freq) {
            maxFreq = max(maxFreq, pair.second);
        }
        
        // 计算具有最大频数的元素总数
        int result = 0;
        for (auto& pair : freq) {
            if (pair.second == maxFreq) {
                result += pair.second;
            }
        }
        
        return result;
    }
};

class Solution:
    def maxFrequencyElements(self, nums: List[int]) -> int:
        from collections import Counter
        
        # 统计每个元素的频数
        freq = Counter(nums)
        
        # 找到最大频数
        max_freq = max(freq.values())
        
        # 计算具有最大频数的元素总数
        result = sum(count for count in freq.values() if count == max_freq)
        
        return result

public class Solution {
    public int MaxFrequencyElements(int[] nums) {
        Dictionary<int, int> freq = new Dictionary<int, int>();
        
        // 统计每个元素的频数
        foreach (int num in nums) {
            if (freq.ContainsKey(num)) {
                freq[num]++;
            } else {
                freq[num] = 1;
            }
        }
        
        // 找到最大频数
        int maxFreq = 0;
        foreach (var pair in freq) {
            maxFreq = Math.Max(maxFreq, pair.Value);
        }
        
        // 计算具有最大频数的元素总数
        int result = 0;
        foreach (var pair in freq) {
            if (pair.Value == maxFreq) {
                result += pair.Value;
            }
        }
        
        return result;
    }
}

/**
 * @param {number[]} nums
 * @return {number}
 */
var maxFrequencyElements = function(nums) {
    const freq = {};
    for (const num of nums) {
        freq[num] = (freq[num] || 0) + 1;
    }
    
    const maxFreq = Math.max(...Object.values(freq));
    
    return Object.values(freq).filter(f => f === maxFreq).reduce((sum, f) => sum + f, 0);
};
在 LeetCode 上运行： 力扣中文版 LeetCode 国际版

复杂度分析

复杂度类型复杂度说明
时间复杂度O(n)需要遍历数组统计频数，然后遍历哈希表找最大频数和计算结果，总体为 O(n)
空间复杂度O(n)使用哈希表存储元素频数，最坏情况下所有元素都不相同，需要 O(n) 空间

相关题目