Question

我有以下程序，该程序查找数组“ a”，然后在出现频率最高的数组中输出值。但是，我要实现的另一个条件是，在平局中，两个不同的值出现相等的时间，则输出最低的值。

因此，下面的代码带有数组：

int a[] = {34, 34, 20, 20, 15};

它输出34，但是我希望它输出20，因为这是一个较低的值，在数组中出现的次数也一样。

public class Arrays3 {
    public static void main(String[] args){
        int a[] = {34, 34, 20, 20, 15};
        mode(a);
    }
    public static int mode(int[] a) {
        int[] counts = new int[101];
        int maxCount = 0;
        int maxKey = 0;

        for(int i = 0; i < a.length; i++) {
            counts[a[i]]++;
            if(counts[a[i]] > maxCount) {
                maxCount = counts[a[i]];
                maxKey = a[i];
            }
        }
        System.out.println(maxKey);
        return maxKey;
    }
}

Answer 1

您可以对照maxKey进行检查，然后执行以下操作：

 if(counts[a[i]] == maxCount && counts[a[i]] < maxKey) {
       maxKey = counts[a[i]];
 }

因此，如果有平局，maxKey将设置为较小的元素。然后，如果count[a[i]]大于maxCount，maxKey将被覆盖并成为最常出现的元素：

for(int i = 0; i < a.length; i++) {
     counts[a[i]]++;

     if(counts[a[i]] > maxCount) {
          maxCount = counts[a[i]];
          maxKey = a[i];
      }
      if(counts[a[i]] == maxCount && counts[a[i]] < maxKey) {
        maxKey = a[i];
      }
}
System.out.println(a[maxKey]);

输出

Answer 2

一个有趣的解决方案（我写得很有趣）是，首先通过流传输数组并将Map与Collectors.groupingBy一起使用来创建频率Collectors.counting()。

然后，我们可以流式传输并再次使用Collectors.groupingBy创建一个Map<Long, SortedSet<Integer>>（键是频率，值是具有该频率的数组中值的排序集合）。

最后，我们可以对Map进行排序，以使频率最高，然后从SortedSet中获取最低的元素：

int[] a = {34, 34, 20, 20, 15};

var lowest = Arrays.stream(a)
                   .boxed()
                   .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()))
                   .entrySet()
                   .stream()
                   .collect(Collectors.groupingBy(Map.Entry::getValue,
                           Collectors.mapping(Map.Entry::getKey, Collectors.toCollection(TreeSet::new))))
                   .entrySet()
                   .stream()
                   .sorted(Comparator.comparing(Map.Entry::getKey, Comparator.reverseOrder()))
                   .map(Map.Entry::getValue)
                   .mapToInt(TreeSet::first)
                   .findFirst();

lowest.ifPresent(System.out::println);

输出：

Answer 3

您想寻求最小值，所以我建议放置int maxKey = Integer.MAX_VALUE;

然后，每次找到更好的计数，我们都必须进行比较以更新maxKey 毕竟，解决方案看起来像这样

int[] counts = new int[101];
int maxCount = 0;
int maxKey = Integer.MAX_VALUE;

for(int i = 0; i < a.length; i++) {
    counts[a[i]]++;
    if(counts[a[i]] >= maxCount) {
        maxCount = counts[a[i]];
        if(a[i] < maxKey) maxKey = a[i];

    }
}
System.out.println(maxKey);
return maxKey;

编码有趣

查找数组中最频繁的值，如果有平局，则选择最低的值

3 个答案: