Question

我需要找到一个双精度数组的中间值（在Java中）而不修改它（因此选择结束）或分配大量新内存。我也不在乎找到确切的中位数，但在10％之内就可以了（所以如果中位数将分类后的数组拆分为40％-60％就可以了）。

如何有效地实现这一目标？

考虑到rfreak的建议，ILMTitan和Peter我写了这段代码：

public static double median(double[] array) {
    final int smallArraySize = 5000;
    final int bigArraySize = 100000;
    if (array.length < smallArraySize + 2) { // small size, so can just sort
        double[] arr = array.clone();
        Arrays.sort(arr);
        return arr[arr.length / 2];
    } else if (array.length > bigArraySize) { // large size, don't want to make passes
        double[] arr = new double[smallArraySize + 1];
        int factor = array.length / arr.length;
        for (int i = 0; i < arr.length; i++)
            arr[i] = array[i * factor];
        return median(arr);
    } else { // average size, can sacrifice time for accuracy
        final int buckets = 1000;
        final double desiredPrecision = .005; // in percent
        final int maxNumberOfPasses = 10; 
        int[] histogram = new int[buckets + 1];
        int acceptableMin, acceptableMax;           
        double min, max, range, scale,
            medianMin = -Double.MAX_VALUE, medianMax = Double.MAX_VALUE;
        int sum, numbers, bin, neighborhood = (int) (array.length * 2 * desiredPrecision);
        for (int r = 0; r < maxNumberOfPasses; r ++) { // enter search for number around median
            max = -Double.MAX_VALUE; min = Double.MAX_VALUE; 
            numbers = 0;
            for (int i = 0; i < array.length; i ++)
                if (array[i] > medianMin && array[i] < medianMax) {
                    if (array[i] > max) max = array[i];
                    if (array[i] < min) min = array[i];
                    numbers ++;
                }
            if (min == max) return min;
            if (numbers <= neighborhood) return (medianMin + medianMax) / 2;
            acceptableMin = (int) (numbers * (50d - desiredPrecision) / 100);
            acceptableMax = (int) (numbers * (50d + desiredPrecision) / 100);
            range = max - min;
            scale = range / buckets;
            for (int i = 0; i < array.length; i ++)
                histogram[(int) ((array[i] - min) / scale)] ++;
            sum = 0;
            for (bin = 0; bin <= buckets; bin ++) {
                sum += histogram[bin];
                if (sum > acceptableMin && sum < acceptableMax)
                    return ((.5d + bin) * scale) + min;
                if (sum > acceptableMax) break; // one bin has too many values
            }
            medianMin = ((bin - 1) * scale) + min;
            medianMax = (bin * scale) + min;
            for (int i = 0; i < histogram.length; i ++)
                histogram[i] = 0;
        }
        return .5d * medianMin + .5d * medianMax;
    }       
}

这里我考虑了数组的大小。如果它很小，那么只需排序并获得真正的中位数。如果它非常大，则对其进行采样并得到样本的中位数，否则迭代地对这些值进行分组，看看中位数是否可以缩小到可接受的范围。

我对此代码没有任何问题。如果有人发现有问题，请告诉我。

谢谢。

Answer 1

假设你的意思是中位数而不是平均数。另外假设您正在使用相当大的double []，或者内存不会成为排序副本和执行精确中位数的问题。 ...

只需最少的额外内存开销，你就可以运行一个O（n）算法，这个算法会进入大球场。我试试这个，看看它有多准确。

两次通过。

首先找到最小值和最大值。创建一组表示最小和最大之间的均匀间隔数字范围的存储桶。进行第二次传递并“计算”每个箱中落入多少个数字。然后，您应该能够合理估计中位数。如果使用int []存储桶，则使用1000个桶只需4k。数学应该很快。

唯一的问题是准确性，我认为您应该能够调整存储桶的数量以获得数据集的错误范围。

我确信有一个比我更好的数学/统计背景的人可以提供精确的尺寸来获得你想要的误差范围。

Answer 2

随机选取少量数组元素，并找出其中位数。

Answer 3

继OP之后的问题;如何从更大的数组中提取N值。

以下代码显示了查找大型数组的中位数所需的时间，然后显示了查找固定大小值选择的中位数所需的时间。固定大小选择具有固定成本，但随着原始阵列的大小增加而越来越不准确。

以下打印

Avg time 17345 us. median=0.5009231700563378
Avg time 24 us. median=0.5146687617507585

代码

double[] nums = new double[100 * 1000 + 1];
for (int i = 0; i < nums.length; i++) nums[i] = Math.random();

{
    int runs = 200;
    double median = 0;
    long start = System.nanoTime();
    for (int r = 0; r < runs; r++) {
        double[] arr = nums.clone();
        Arrays.sort(arr);
        median = arr[arr.length / 2];
    }
    long time = System.nanoTime() - start;
    System.out.println("Avg time " + time / 1000 / runs + " us. median=" + median);
}
{
    int runs = 20000;
    double median = 0;
    long start = System.nanoTime();
    for (int r = 0; r < runs; r++) {
        double[] arr = new double[301]; // fixed size to sample.
        int factor = nums.length / arr.length; // take every nth value.
        for (int i = 0; i < arr.length; i++)
            arr[i] = nums[i * factor];
        Arrays.sort(arr);
        median = arr[arr.length / 2];
    }
    long time = System.nanoTime() - start;
    System.out.println("Avg time " + time / 1000 / runs + " us. median=" + median);
}

为了满足你不创建对象的要求，我会将固定大小的数组放在ThreadLocal中，这样就不会有正在进行的对象创建。您可以调整数组的大小以适应您希望函数的速度。

Answer 4

1）新内存有多少？它是否排除数据的排序副本或数据引用？

2）您的数据是否重复（有许多不同的值）？如果是，那么您对（1）的回答不太可能导致问题，因为您可以使用查找映射和数组执行某些操作：例如映射和一个简短的数组和一个适当调整的比较对象。

3）“接近均值”近似的典型情况更可能是O（n.log（n））。大多数排序算法仅使用病理数据降级为O（n ^ 2）。此外，假设您能够负担得起分类副本，确切的中位数将（通常）为O（n.log（n））。

4）随机抽样（a-la dan04）比选择平均值附近的值更准确，除非您的分布表现良好。例如泊松分布和对数正态都有不同的中位数。

不可变数组的近似中值

4 个答案: