如何解决日期列表中频率最高星期几平局时返回最早星期的问题？

问题说明 #

现有Java方法mostFrequentDayOfWeek接收SimpleDate数组，用于返回数组中出现频率最高的星期几缩写。当前方法能正确返回频率最高的星期几，但当多个星期几出现频率相同时，无法返回星期顺序更早的那一个（例如周二"Tue"与周五"Fri"频率相同时，应返回"Tue"）。

待完善的mostFrequentDayOfWeek方法 #

public static String mostFrequentDayOfWeek( SimpleDate[] dates ) {
        int maxcount = 0;
        String freqDay = "";
        Vector<String> days = new Vector<String>();

        for (int i = 0; i < dates.length; i++) {

            int count = 0;
            for (int j = 0; j < dates.length; j++) {
                if (dayOfWeek(dates[i]).equals(dayOfWeek(dates[j]))) {
                    count++;
                }
            }

            if (count > maxcount) {
                maxcount = count;
                freqDay = dayOfWeek(dates[i]);
            }

            else if (count == maxcount) {
                Vector<String> days;
                days = new Vector<String>();
                days.add(dayOfWeek(dates[i]));
                freqDay = days.get(i);
                
            }
        }
        return freqDay;
    }

瓶颈代码段 #

else if (count == maxcount) {
                
                
                days.add(dayOfWeek(dates[i]));
                freqDay = days.get(i);
                
            }

解决方案 #

实现思路 #

1. 定义星期优先级：根据业务需求（星期顺序更早的优先），给每个星期几分配优先级数值，数值越小优先级越高。
2. 高效统计频率：使用Map统计每个星期几的出现次数，避免原方法双重循环的O(n²)低效问题。
3. 确定结果：先找到最高频率值，再按照优先级顺序遍历，返回第一个达到最高频率的星期几，确保平局时取优先级更早的。

完整实现代码 #

包含优先级定义的修改后方法

import java.util.HashMap;
import java.util.Map;

public class DateUtils {
    // 定义星期优先级：数值越小，优先级越高（符合Mon > Tue > Wed > Thu > Fri > Sat > Sun的顺序）
    private static final Map<String, Integer> DAY_PRIORITY = new HashMap<>();
    static {
        DAY_PRIORITY.put("Mon", 0);
        DAY_PRIORITY.put("Tue", 1);
        DAY_PRIORITY.put("Wed", 2);
        DAY_PRIORITY.put("Thu", 3);
        DAY_PRIORITY.put("Fri", 4);
        DAY_PRIORITY.put("Sat", 5);
        DAY_PRIORITY.put("Sun", 6);
    }

    public static String mostFrequentDayOfWeek(SimpleDate[] dates) {
        if (dates == null || dates.length == 0) {
            return "";
        }

        // 统计每个星期几的出现频率
        Map<String, Integer> dayFrequency = new HashMap<>();
        for (SimpleDate date : dates) {
            String day = dayOfWeek(date);
            dayFrequency.put(day, dayFrequency.getOrDefault(day, 0) + 1);
        }

        // 找到最高频率
        int maxCount = 0;
        for (int count : dayFrequency.values()) {
            if (count > maxCount) {
                maxCount = count;
            }
        }

        // 按优先级顺序遍历，返回第一个达到最高频率的星期几
        String result = "";
        int highestPriority = Integer.MAX_VALUE;
        for (Map.Entry<String, Integer> entry : dayFrequency.entrySet()) {
            String day = entry.getKey();
            int count = entry.getValue();
            int priority = DAY_PRIORITY.get(day);

            if (count == maxCount && priority < highestPriority) {
                highestPriority = priority;
                result = day;
            }
        }

        return result;
    }

    // 用于获取星期几缩写的dayOfWeek方法
    public static String dayOfWeek(SimpleDate date) {
        // 调用SimpleDate的getter方法获取日、月、年
        int day = date.getDay();     
        int month = date.getMonth(); 
        int year = date.getYear();   
        int Z, X, Y, W, C, D;
        String nameofday = ""; // 方法返回值

        if(month < 3){
            month = month + 12;
            year = year - 1;
        }
        C = year % 100;
        D = year / 100;
        W = 13*( month + 1 )/5;
        X = C / 4;
        Y = D / 4;
        Z = W + X + Y + day + C - 2 * D;
        day = Z % 7;

        if(day<0){
            day += 7;
        }
        // 根据计算结果转换为星期缩写
        switch(day){
            case 0 : nameofday = "Sat";break;
            case 1 : nameofday = "Sun";break;
            case 2 : nameofday = "Mon";break;
            case 3 : nameofday = "Tue";break;
            case 4 : nameofday = "Wed";break;
            case 5 : nameofday = "Thu";break;
            case 6 : nameofday = "Fri";break;
        }
        return nameofday;
    }
}

关键修改说明 #

1. 优先级Map：通过静态初始化块定义每个星期的优先级，确保星期顺序的优先级逻辑清晰可维护。
2. 频率统计优化：使用HashMap一次遍历完成频率统计，时间复杂度从O(n²)降至O(n)，效率大幅提升。
3. 平局处理逻辑：遍历频率Map时，同时比较优先级，只保留频率最高且优先级最高的星期几，完美解决平局场景的需求。

内容的提问来源于stack exchange，提问作者Ebrahim Al-Aghbari