如何在不使用 Java 中的 Arrays 类（例如，不排序）的情况下找到数组中最频繁的值？

你可以试试这个：

public static Double getPopularElement(double[] a) {
  int count = 1,tempCount;
  double popular = a[0];
  double temp;
  boolean isUnique = false;
  for (int i = 0; i < (a.length - 1); i++) {
    temp = a[i];
    tempCount = 0;
    for (int j = 1; j < a.length; j++) {
      if (temp == a[j])
        tempCount++;
    }
    if (tempCount > count) {
      isUnique = true;
      popular = temp;
      count = tempCount;
    } else if (tempCount == count) {
      isUnique = false;
    }
  }
  return isUnique ? popular : Double.NaN;
}

测试运行：

{1.0,2.0,3.0} == NaN

{1.0,3.0,3.0} == 3.0

测试：

[20.0,20.0] = 20.0
[1.0,4.0,5.0,6.0,7.0] = NO MODE
[1.0,8.0,7.0,6.0] = [3.0,6.0]
[4.0,5.0] = [4.0,5.0]
[-1.0,-1.0,2.0] = [-1.0,2.0]

代码：

public class Mode {
    public static void main(String[] args) {
        double test1[] = { 20.0,20.0 };
        double test2[] = { 1.0,7.0 };
        double test3[] = { 1.0,6.0 };
        double test4[] = { 4.0,5.0 };

        System.out.println(getMode(test1));
        System.out.println(getMode(test2));
        System.out.println(getMode(test3));
        System.out.println(getMode(test4));
    }

    private static String getMode(double arr[]) {
        double checked[] = new double[arr.length];
        int occurrences[] = new int[arr.length];

        for (int i = 0; i < arr.length; ++i) {
            if (!arrayContains(checked,arr[i])) {
                checked[i] = arr[i];
                occurrences[i] = arrayCount(arr,arr[i]);
            }
        }

        int lowest[] = sorted(occurrences,true);
        int highest[] = sorted(occurrences,false);

        if (arraysEqual(lowest,highest) && highest.length > 1) {
            return "NO MODE";
        }

        int j = 0;
        Double modes[] = new Double[arr.length];
        int most_occurrence = highest[0];
        for (int i = 0; i < occurrences.length; ++i) {
            if (occurrences[i] == most_occurrence) {
                modes[j++] = arr[i];
            }
        }

        double result[] = removeNullValues(modes);
        return result.length == 0 ? "Error" : result.length > 1 ? arrayToString(result) : Double.toString(result[0]);
    }

    private static boolean arrayContains(double arr[],double value) {
        return arrayCount(arr,value) > 0;
    }

    private static int arrayCount(double arr[],double value) {
        int count = 0;
        for (int i = 0; i < arr.length; ++i) {
            if (arr[i] == value) {
                ++count;
            }
        }
        return count;
    }

    private static boolean arraysEqual(int a[],int b[]) {
        if (a.length != b.length) {
            return false;
        }

        for (int i = 0; i < a.length; ++i) {
            if (a[i] != b[i]) {
                return false;
            }
        }
        return true;
    }

    private static double[] removeNullValues(Double arr[]) {
        Double result[] = new Double[arr.length];

        int j = 0;
        for (int i = 0; i < result.length; ++i) {
            if (arr[i] != null) {
                result[j++] = arr[i];
            }
        }

        // trim array
        double realResult[] = new double[j];
        for (int i = 0; i < j; ++i) {
            realResult[i] = result[i];
        }
        return realResult;
    }

    private static void sort(int arr[],boolean ascending) {
        int t = 0;
        for(int i = 0; i < arr.length; ++i) {
            for(int j = 0; j < arr.length - 1; ++j) {
                if (ascending ? arr[j + 1] < arr[j] : arr[j + 1] > arr[j]) {
                    t = arr[j + 1];
                    arr[j + 1] = arr[j];
                    arr[j] = t;
                }
            }
        }
    }

    private static int[] sorted(int arr[],boolean ascending) {
        int result[] = new int[arr.length];
        for (int i = 0; i < arr.length; ++i) {
            result[i] = arr[i];
        }

        sort(result,ascending);
        return result;
    }

    public static String arrayToString(double[] a) {
        int iMax = a.length - 1;
        if (iMax == -1) {
            return "[]";
        } else {
            String res = "[";

            int i = 0;
            while(true) {
                res += a[i];
                if (i == iMax) {
                    return res + "]";
                }

                res += ",";
                ++i;
            }
        }
    }
}

下面的解决方案平均为 O(nlog(n))。

想法是先对数组进行排序，然后只迭代一次以找到重复次数最多的数字。

public static Double getMostFrequentElement(double[] a) {
    quickSort(a,a.length-1); // Instead of Arrays.sort(a); O(nlog(n))
    return getMostFrequentElementInSortedArray(a); // O(n)
}

private static double getMostFrequentElementInSortedArray(double[] sortedArr) {
    if(sortedArr.length == 0){
        return Double.NaN;
    }else if(sortedArr.length == 1){
        return sortedArr[0];
    }

    int maxCount = 1,currCount = 1;
    double result = Double.NaN,curr = sortedArr[0];

    for (int i = 1; i < sortedArr.length; i++) {
        if (curr == sortedArr[i]) {
            currCount++;

            if (currCount == maxCount) {
                result = Double.NaN;
            } else if (currCount > maxCount) {
                result = curr;
                maxCount = currCount;
            }
        } else {
            curr = sortedArr[i];
            currCount = 1;
        }
    }

    return result;
}

// Sorting
public static void quickSort(double[] arr,int begin,int end) {
    if (begin < end) {
        int partitionIndex = partition(arr,begin,end);

        quickSort(arr,partitionIndex-1);
        quickSort(arr,partitionIndex+1,end);
    }
}

private static int partition(double[] arr,int end) {
    double pivot = arr[end];
    int i = (begin-1);

    for (int j = begin; j < end; j++) {
        if (arr[j] <= pivot) {
            i++;
            double swapTemp = arr[i];
            arr[i] = arr[j];
            arr[j] = swapTemp;
        }
    }

    double swapTemp = arr[i+1];
    arr[i+1] = arr[end];
    arr[end] = swapTemp;

    return i+1;
}

输出示例：

getMostFrequentElement(new double[]{20.0,20.0}); // 20.0
getMostFrequentElement(new double[]{1.0,7.0}); // NaN
getMostFrequentElement(new double[]{1.0,1.0,1.0}); // 1.0
getMostFrequentElement(new double[]{2.0,1.0}); // 1.0
getMostFrequentElement(new double[]{3.0,2.0}); // 2.0
getMostFrequentElement(new double[]{1.0,7.0}); // 1.0
getMostFrequentElement(new double[]{2.0,7.0}); // 2.0
getMostFrequentElement(new double[]{2.0,5.0}); // NaN
getMostFrequentElement(new double[]{2.0}); // 2.0
getMostFrequentElement(new double[]{}); // NaN