Easy

题目描述

给你一个整数数组 nums，返回出现频率最高的偶数元素。

如果存在多个频率相同的偶数元素，返回其中最小的一个。如果不存在偶数元素，返回 -1。

示例 1：

输入：nums = [0,1,2,2,4,4,1]
输出：2
解释：
偶数元素有 0、2 和 4。其中，2 和 4 出现次数最多。
我们返回最小的那个，也就是 2。

示例 2：

输入：nums = [4,4,4,9,2,4]
输出：4
解释：4 是出现次数最多的偶数元素。

示例 3：

输入：nums = [29,47,21,41,13,37,25,7]
输出：-1
解释：不存在偶数元素。

提示：

  • 1 <= nums.length <= 2000
  • 0 <= nums[i] <= 10^5

解题思路

这是一道典型的哈希表计数问题，解题思路如下：

方法一：哈希表计数（推荐）

  1. 遍历数组，使用哈希表统计每个偶数元素的出现频率
  2. 在统计过程中记录最大频率和对应的最小偶数
  3. 当遇到频率更高的偶数时更新结果，频率相同但数值更小时也要更新

方法二：两次遍历 第一次遍历统计所有偶数频率，第二次遍历找出符合条件的结果。但相比方法一效率稍低。

优化细节：

  • 可以在一次遍历中同时完成计数和结果更新
  • 判断偶数使用位运算 (num & 1) == 0 比取模运算更高效
  • 只需要关注偶数元素，忽略奇数可以减少哈希表大小

时间复杂度为 O(n)，空间复杂度为 O(k)，其中 k 是不同偶数的个数。

代码实现

class Solution {
public:
    int mostFrequentEven(vector<int>& nums) {
        unordered_map<int, int> count;
        int maxFreq = 0;
        int result = -1;
        
        for (int num : nums) {
            if (num % 2 == 0) {
                count[num]++;
                if (count[num] > maxFreq || (count[num] == maxFreq && num < result)) {
                    maxFreq = count[num];
                    result = num;
                }
            }
        }
        
        return result;
    }
};

class Solution:
    def mostFrequentEven(self, nums: List[int]) -> int:
        count = {}
        max_freq = 0
        result = -1
        
        for num in nums:
            if num % 2 == 0:
                count[num] = count.get(num, 0) + 1
                if count[num] > max_freq or (count[num] == max_freq and num < result):
                    max_freq = count[num]
                    result = num
        
        return result

public class Solution {
    public int MostFrequentEven(int[] nums) {
        Dictionary<int, int> count = new Dictionary<int, int>();
        int maxFreq = 0;
        int result = -1;
        
        foreach (int num in nums) {
            if (num % 2 == 0) {
                if (count.ContainsKey(num)) {
                    count[num]++;
                } else {
                    count[num] = 1;
                }
                
                if (count[num] > maxFreq || (count[num] == maxFreq && num < result)) {
                    maxFreq = count[num];
                    result = num;
                }
            }
        }
        
        return result;
    }
}

var mostFrequentEven = function(nums) {
    const evenCount = new Map();
    
    for (const num of nums) {
        if (num % 2 === 0) {
            evenCount.set(num, (evenCount.get(num) || 0) + 1);
        }
    }
    
    if (evenCount.size === 0) return -1;
    
    let maxFreq = 0;
    let result = -1;
    
    for (const [num, freq] of evenCount) {
        if (freq > maxFreq || (freq === maxFreq && num < result)) {
            maxFreq = freq;
            result = num;
        }
    }
    
    return result;
};
在 LeetCode 上运行： 力扣中文版 LeetCode 国际版

复杂度分析

复杂度类型复杂度说明
时间复杂度O(n)需要遍历整个数组一次
空间复杂度O(k)k 是数组中不同偶数的个数，最坏情况下为 O(n)

相关题目