Question

我正在尝试解决一个程序，以使用JavaScript查找数组中任何一对元素之间的最小绝对差。输入将参数作为数组元素。输出返回数组中任意两个元素之间的最小绝对差

例如，输入为[1,2,4]，输出为1

有关该问题的详细说明，请参见this链接。

在我的代码中，当给出包含1000个元素的输入数组时，它会编译并显示由于超时而终止，但是它适用于较小尺寸的输入数组

我认为错误来自性能和复杂性问题。我研究了问题，但仍然坚持如何进行进一步的步骤

我的代码：

    var arr = [..] //array containing 1000 elements
    var count = minimumAbsoluteDifference(arr);
    console.log(count);
    function minimumAbsoluteDifference(arr) {
        var diff = []; var index = 0;
        arr.sort((a, b) => { return (a - b); });
        for (var i = 0; i < arr.length-1; i++){
            for (var j = i+1; j < arr.length; j++){
                if (i != j) {
                    diff[index] = Math.abs(arr[i] - arr[j]);
                    console.log("index", i, j);
                    index++;
                }
            }
        }
        var minAbsoluteDifference = Math.min(...diff);
        return minAbsoluteDifference;
    }

Answer 1

对数组进行排序后，任意两个元素之间的最小绝对差将必需在两个相邻元素之间。因此，您可以将嵌套的for循环（O(N^2)）更改为单个for循环（O(N)）（尽管排序功能仍为O(N log N)，因此总体复杂度仅降低为O(N log N)）：

function minimumAbsoluteDifference(arr) {
    var diff = [];
    arr.sort((a, b) => a - b);
    for (var i = 0; i < arr.length - 1; i++) {
        if (i < arr.length - 1) {
            diff.push(Math.abs(arr[i] - arr[i + 1]));
        }
    }
    var minAbsoluteDifference = Math.min(...diff);
    return minAbsoluteDifference;
}

这在大多数情况下都是可行的，但是另一个问题是，HackerRank似乎以不合理的巨大数组（例如，单个数组中有100000个项目）来调用此函数，所以

Math.min(...diff)

将导致

RangeError：超出了最大调用堆栈大小

请在每次迭代时调用Math.min：

function minimumAbsoluteDifference(arr) {
    var lowestDiff = Infinity;
    arr.sort((a, b) => a - b);
    for (var i = 0; i < arr.length - 1; i++) {
        lowestDiff = Math.min(lowestDiff, Math.abs(arr[i] - arr[i + 1]));
    }
    return lowestDiff;

}

Answer 2


  for (var i = 0; i < arr.length - 1; i++) {
      var j = i+1;//only check the diff with next neighbor
      diff[index] = Math.abs(arr[i] - arr[j]);
      console.log("index", i, j);
      index++;
  }

Answer 3

这是使用Array.map方法的绝佳机会，因为它使我们能够访问要迭代的currentValue，迭代的索引以及当前正在减少的数组。该函数的外观如下：

function minimumAbsoluteDifference(array) {
  const sortedArray = [...array].sort((a, b) => a - b);
  let difference = sortedArray[sortedArray.length - 1];

  sortedArray.map((currentValue, index, array) => {
    const currentMinDifference = Math.abs(currentValue - array[index + 1]);

    if (currentMinDifference < difference) {
      difference = currentMinDifference;
    }
  });

  return difference;
}

首先，我们对数组进行排序以使其易于使用，然后将差异初始化为数组中最大的项。

然后，我们使用提供的回调函数（以currentValue，索引和数组作为参数）在已排序数组上调用map方法。

在map方法内部，我们将计算当前数字与下一个数字之间的绝对差。如果当前迭代的绝对差小于difference，那么我们发现数组中的绝对差更小。

这一直持续到最后。

使用JavaScript查找数组中任意两对元素之间的最小绝对差时出错

3 个答案: