Question

我正在尝试使用数组和数据结构构建当前的逻辑。我正在尝试使用for循环实现逻辑

function getRepeatingNumber(arr) {

  for (var i = 0; i < arr.length; i++) {
    for (var j = i + 1; j < arr.length; j++) {
      if (arr[i] === arr[j]) {
        return arr[i];
      }
    }
  }
  return undefined;
}
getRepeatingNumber([2, 3, 6, 5, 2]);

上面的函数接受数组并返回数组中的重复项，因此在上述情况下它将返回2。但是，如果我有一个类似arr [2,3,3,6,5,2的数组怎么办？ ]在这种情况下，它应该返回3，但由于外部循环的索引[0]为2，因此返回2作为答案。

如何实现一个函数，该函数返回重复项的首次出现。

Answer 1

与其在之后 j的部分中i进行迭代，不如在 i之前的部分进行迭代：

function getRepeatingNumber(arr){
    for (var i = 1; i < arr.length; i++) {
        for (var j = 0; j < i; j++) {
            if (arr[i] === arr[j]) {
                return arr[i];
            }
        }
    }
}
console.log(getRepeatingNumber([2,3,3,6,5,2]));

请注意，不需要显式return undefined，这已经是默认行为。

您还可以使用indexOf来缩短代码一点：

function getRepeatingNumber(arr){
    for (var i = 1; i < arr.length; i++) {
        if (arr.indexOf(arr[i]) < i) {
            return arr[i];
        }
    }
}
console.log(getRepeatingNumber([2,3,3,6,5,2]));

您甚至可以决定使用find －如果不匹配（在我们的情况下没有重复项），它将返回undefined：

function getRepeatingNumber(arr){
    return arr.find((a, i) => {
        if (arr.indexOf(a) < i) {
            return true;
        }
    });
}
console.log(getRepeatingNumber([2,3,3,6,5,2]));

如果对大型数组执行此操作，那么具有线性时间复杂度的解决方案就变得很重要。在这种情况下，Set会很有用：

function getRepeatingNumber(arr){
    var set = new Set;
    return arr.find(a => {
        if (set.has(a)) return true;
        set.add(a);
    });
}
console.log(getRepeatingNumber([2,3,3,6,5,2]));

如果您喜欢函数功能和单行代码，那么：

const getRepeatingNumber = r=>(t=>r.find(a=>[t.has(a),t.add(a)][0]))(new Set);
console.log(getRepeatingNumber([2,3,3,6,5,2]));

Answer 2

您需要一个数据结构来跟踪第一个出现的索引。

我的建议是使用数组存储所有重复数字的索引。按升序对数组进行排序，然后从数组的第一个索引处返回项目。

function getRepeatingNumber(arr){
 var resultIndexArr = [];
 var count = 0;
 var flag = 0;
 for(var i=0;i<arr.length;i++)
 {
  for(var j=i+1;j<arr.length;j++)
   {
    if(arr[i] === arr[j])
    {
	 flag = 1;
	 resultIndexArr[count++] = j;
    }
   }
 }
 
 resultIndexArr.sort((a, b) => a - b);
 
 var resultIndex = resultIndexArr[0];
 if(flag === 1)
  return arr[resultIndex];
 else
  return;
}

console.log(getRepeatingNumber([2,3,6,5,2])); // test case 1
  
console.log(getRepeatingNumber([2,3,3,6,5,2])); // test case 2

console.log(getRepeatingNumber([2,5,3,6,5,2])); // test case 3

这将返回正确的结果，但这不是最佳解决方案。最好的解决方案是将项目存储在数组中，检查每次迭代是否已在数组中存在该项目，如果存在则返回该项目。

Answer 3

作为一名JavaScript开发人员，您应该熟悉函数式编程和高阶函数，因此请检查文档以进一步了解一些有用的函数：例如filter-find-reduce -findIndex地图...

Documentation

现在回答您的问题：

首先，您应该逐步进行思考：

获取数组中某项的出现作为函数：

const arr = [2, 5, 6, 2, 4, 5, 6, 8, 2, 5, 2]

const res = arr.reduce((numberofOcc, item) => {
  if (item === 2)
    numberofOcc++

    return numberofOcc
}, 0);

console.log(`result without function ${res}`);

/* so my function will be */


const occurenceFun = (num, arr) => {
  return arr.reduce((numberofOcc, item) => {
    if (item === num)
      numberofOcc++

      return numberofOcc
  }, 0);

}

console.log(`result using my function ${occurenceFun(2, arr)}`);

现在我有了此功能，因此可以在另一个函数中使用它来获取我在数组中出现的较高次数

const arr = [1, 2, 5, 6, 8, 7, 2, 2, 2, 10, 10, 2]

const occurenceFun = (num, arr) => {
  return arr.reduce((numberofOcc, item) => {
    if (item === num)
      numberofOcc++

      return numberofOcc
  }, 0);

}



/*let's create our function*/

const maxOccurenceFun = arr => {
  let max = 0;

  arr.forEach(el => {
    if (max < occurenceFun(el, arr)) {
      max = el
    }
  })

  return max;

}

console.log(`the max occurence in this array is : ${maxOccurenceFun(arr)}`);

如何使用for循环返回数组中重复项的首次出现？

3 个答案: