处理大数字时功能变慢

Question

我编写了一个脚本，它不会给出一组数据的实际平均值，而是返回一个包含大多数数据点的窗口。让我展示一些代码：

time.tic()
var selectedAverage = 0;
var highestPointCount = 0;
for (var i = 1; (i*step) <= maxValue; i++) {
    var dataPointCount = 0;
    for (var j = 0; j < myArray.length; j++) {
        if (myArray[j] >= minValue+(i-1)*step && myArray[j] <= minValue+i*step) {
            dataPointCount++;
        }
    }
    if (dataPointCount > highestPointCount) {
        highestPointCount = dataPointCount;
        selectedAverage = (minValue+(i-1)*step)+Math.round(0.5*step);
    }
}
console.log(time.toct().ms) 
return selectedAverage;

首先通过从最大值中减去最小值然后乘以 10 来计算步长值。因此有 10 个“水平”窗口。然后脚本计算每个窗口内的数据点数量并返回适当的平均值。

然而，当传入一个较大数字的数组（例如 1.000.000）时，脚本的速度似乎非常慢（有时超过 200 倍）。数组长度大约为 200，但总是相同的长度，因此它必须与实际值相关联。知道哪里出错了吗？

编辑： 获取步长值的代码：

var minValue = myArray.min();
var maxValue = myArray.max();
var step = Math.round((maxValue-minValue)/10);
if (step === 0) {
    step = 1
}

.min() 和 .max() 是附加到 Array 的原型。但这一切都进行得非常快。我已经测量了每一步，是 for 循环变慢了。

Answer 1

如果我正确理解了您的算法，这应该会消除所有不必要的计算并且速度会更快：

var arr = [];
var maxQty=0;
var wantedAverage = 0;
for (var j = 0; j < 11; j++) {
    arr[j]=0;
}
for (var j = 0; j < myArray.length; j++) {
    var stepIndex = Math.floor((myArray[j]-minValue)/step)
    arr[stepIndex]+=1;

    if(arr[stepIndex] > maxQty ){
        wantedAverage = minValue + stepIndex*step +Math.round(0.5*step);
        maxQty = arr[stepIndex]
    }
}
console.log(maxQty, wantedAverage)

我们只遍历数组的每个元素一次，并计算它所属窗口的索引，将数量数组加一。然后如果我们在窗口中找到更多的点，我们会更新wantedAverage

Answer 2

我对你的问题有两种不同的看法：

1. 删除了不必要的/重复的计算

在您的嵌套代码中，您每次都会为 minValue、i 和 step 的相同值计算 minValue+(i-1)*step 和 minValue+i*step。 您应该在它变成的第二个 for 循环之前将其拉起：

var dataPointCount = 0;
var lowerLimit = minValue+(i-1)*step;
var higherLimit = minValue+1*step;
for (var j = 0; j < myArray.length; j++) {
    if (myArray[j] >= lowerLimit && myArray[j] <= higherLimit) {
        dataPointCount++;
    }
}

1. 您在处理大数据阵列时受到严重的性能影响，这可能是由内存交换引起的。从您的角度来看，您正在处理单个数组实例，但是当您拥有如此大的数组时，JavaScript VM 不太可能访问连续的内存空间来保存所有这些值。 JavaScript VM 很可能必须处理从操作系统获取的多个内存块，并且必须花费额外的精力来翻译在读/写期间哪个值在哪里。