Java 如何查找数组的模式（如果存在）。如果有多个模式，则返回NaN

正如标题所述，我需要找到数组的模式。但是，对此有一些规定：

1） 如果不存在模式（即每个元素只出现一次或相等的次数），则返回

Double.NaN

2） 如果存在多个模式（即，

{1,2,2,3,4,5,5,6}

将给出两种模式，2和5）返回

Double.NaN

基本上，如果它确实是数组的模式，它应该只返回数组的一个元素，并且至少比所有其他元素出现一次。任何其他时间，它都应该返回

Double.NaN

我当前的代码返回一个模式。但是，如果两个数字相等，则返回两个数字中的后一个作为模式，而不是

NaN

。此外，如果不存在模式，则不返回

NaN

感谢您的帮助

以下是我到目前为止的情况：

public double mode(){
    double[] holder = new double[data.length];
    double tempMax = 0, permMax = 0, location = 0, arrayMode = 0; 
    for (int i = 0; i < data.length; ++i) {
        int count = 0;
        for (int j = 0; j < data.length; ++j) {
            if (data[j] == data[i])
                ++count;
        }
        holder[i] = count;
    }

    for (int w = 0; w < holder.length; w++){
    if (holder[w] > tempMax){
        tempMax = holder[w];
        arrayMode = data[w];
    }
    }
    permMax = arrayMode;

    return permMax;
}

公共双模式（）{
double[]holder=新的double[data.length]；
双tempMax=0，permMax=0，location=0，arrayMode=0；
对于（int i=0；itempMax）{
tempMax=支架[w]；
arrayMode=数据[w]；
}
}
permMax=阵列模式；
返回最大值；
}

最好的方法是对数组进行排序，然后从头到尾根据找到的最大值计算每个数组的实例数。如果确实需要保持数字的原始顺序，请首先复制数组

public static double mode (double[] data) {
  double maxnum = Double.NaN;
  double num = 0;
  int maxcount = 0;
  int count = 0;
  double[] used = Arrays.copyOf(data, data.length);
  Arrays.sort(data);
  for (int i = 0; i < used.length; i++) {
    if (used[i] == num) {
      count++;
    }
    else {
      num = used[i];
      count = 1;
    }
    if (count == maxCount) {
      maxnum = Double.NaN;
    }
    if (count > maxCount) {
      maxnum = num;
      maxcount = count;
    }
  }
  return maxnum;
}

公共静态双模式（双[]数据）{
double maxnum=double.NaN；
双数=0；
int maxcount=0；
整数计数=0；
double[]used=Arrays.copyOf（data，data.length）；
数组。排序（数据）；
for（int i=0；i最大计数）{
maxnum=num；
最大计数=计数；
}
}
返回maxnum；
}

这个问题很容易找到重复项，例如

话虽如此，我想添加另一个解决方案：

public double findMode(int[] inArray) {
        List<Integer> il = IntStream.of(inArray).boxed().collect(Collectors.toList());
        int maxFreq = 0;
        double value = 0;
        for (Integer i : ia){
            if (Collections.frequency(il, i) > maxFreq && i != value){
                maxFreq = Collections.frequency(il, i);
                value = i;
            } else if (Collections.frequency(il, i) == maxFreq && i != value) {
                value = Double.NaN; 
            }
        }
        return value;
}

公共双findMode（int[]inArray）{
List il=IntStream.of（inArray.boxed（）.collect（Collectors.toList（））；
int maxFreq=0；
双值=0；
for（整数i:ia）{
if（Collections.frequency（il，i）>maxFreq&&i！=值）{
maxFreq=收集频率（il，i）；
值=i；
}else if（Collections.frequency（il，i）=maxFreq&&i！=值）{
值=Double.NaN；
}
}
返回值；
}

它将

int[]

转换为

列表

，并使用

Collections.frequency

方法获取每个值的出现次数

---

免责声明：我可能错过了一些优化。

几乎没有理由不让mode成为带有双[]参数的静态方法。您建议我按照链接代码所说的去做，但将count=0更改为count=1吗？或者在我现有的方法中实现您在这里列出的内容？我修改了您链接到return Double.NaN的代码中最后一个if-else分支，而不是选择两者中较低的一个。谢谢大家的帮助！所以你要对它进行排序，找到每个元素的频率，然后将频率与之前的最大频率进行比较。如果大于上一个，则变为最大值。如果等于，则返回NaN，如果小于，则最大值保持不变？@slowdawg84基本上是的