在 Javascript 数组中查找第一个重复的数字

Question

我需要找到前两个数字并显示如下索引：

var arrWithNumbers = [2,5,5,2,3,5,1,2,4];

所以第一个重复的数字是2，所以变量firstIndex的值应该是0。我必须使用for循环。

var numbers = [7, 5, 7, 6, 6, 4, 9, 10, 2, 11];
var firstIndex

for (i = numbers[0]; i <= numbers.length; i++) {
  firstIndex = numbers[0]
  if (numbers[i] == firstIndex) {
    console.log(firstIndex);
    break;
  }
}

Answer 1

您可以将Array#indexOf 方法与fromIndex 参数一起使用。

var numbers = [7, 5, 7, 6, 6, 4, 9, 10, 2, 11];

// iterate upto the element just before the last
for (var i = 0; i < numbers.length - 1; i++) {
  // check the index of next element
  if (numbers.indexOf(numbers[i], i + 1) > -1) {
    // if element present log data and break the loop
    console.log("index:", i, "value: ", numbers[i]);
    break;
  }
}

---

更新： 使用对象来引用元素的索引会更好。

var numbers = [7, 5, 7, 6, 6, 4, 9, 10, 2, 11],
  ref = {};

// iterate over the array
for (var i = 0; i < numbers.length; i++) {
  // check value already defined or not
  if (numbers[i] in ref) {
    // if defined then log data and brek loop
    console.log("index:", ref[numbers[i]], "value: ", numbers[i]);
    break;
  }
  // define the reference of the index
  ref[numbers[i]] = i;
}

Answer 2

很多很好的答案.. 也可以按如下方式在功能上和高效地完成这项工作；

var arr = [2,5,5,2,3,5,1,2,4],
   frei = arr.findIndex((e,i,a) => a.slice(i+1).some(n => e === n)); // first repeating element index
console.log(frei)

If 可能会被证明是有效的，因为 .findIndex() 和 .some() 函数都会在满足条件后立即终止。

Answer 3

您可以使用两个for 循环检查每个值 与每个值。如果发现重复值，则迭代停止。

此提案使用labeled statement 来打破外循环。

var numbers = [1, 3, 6, 7, 5, 7, 6, 6, 4, 9, 10, 2, 11],
    i, j;

outer: for (i = 0; i < numbers.length - 1; i++) {
    for (j = i + 1; j < numbers.length; j++) {
        if (numbers[i] === numbers[j]) {
            console.log('found', numbers[i], 'at index', i, 'and', j);
            break outer;
        }
    }
} 

Answer 4

遍历每个项目并查找是否在不同索引上找到相同的项目，如果是，则它是重复的，只需将其保存到重复变量并中断循环

var numbers = [7, 5, 7, 6, 6, 4, 9, 10, 2, 11];
var duplicate = null;
for (var i = 0; i < numbers.length; i++) {
  if (numbers.indexOf(numbers[i]) !== i) {
    duplicate = numbers[i];
    break; // stop cycle 
  }
}
console.log(duplicate);

Answer 5

var numbers = [7, 5, 7, 6, 6, 4, 9, 10, 2, 11];
var map = {};
    
for (var i = 0; i < numbers.length; i++) {
   if (map[numbers[i]] !== undefined) {
       console.log(map[numbers[i]]);
       break;
   } else {
       map[numbers[i]] = i;
   }
}

好的，让我们分解一下。我们在这里所做的是创建一个数字映射到它们第一次出现的索引。因此，当我们遍历数字数组时，我们检查它是否在我们的数字映射中。如果是，我们已经找到它并在我们的地图中返回该键的值。否则，我们将数字作为键添加到我们的映射中，它指向它第一次出现的索引。我们使用映射的原因是它非常快 O(1)，所以我们的整体运行时间是 O(n)，这是在未排序数组上执行此操作的最快速度。

Answer 6

作为替代方案，您可以使用indexOf 和lastIndexOf，如果值不同，则存在多次重复，您可以中断循环；

function getFirstDuplicate(arr) {
  for (var i = 0; i < arr.length; i++) {
    if (arr.indexOf(arr[i]) !== arr.lastIndexOf(arr[i])) 
      return arr[i];
  }
}

var arrWithNumbers = [2, 5, 5, 2, 3, 5, 1, 2, 4];
console.log(getFirstDuplicate(arrWithNumbers))

var numbers = [1, 3, 6, 7, 5, 7, 6, 6, 4, 9, 10, 2, 11]
console.log(getFirstDuplicate(numbers))

Answer 7

我有同样的任务并想出了这个非常基本的解决方案：

var arr = [7,4,2,4,5,1,6,8,9,4];
var firstIndex = 0;

for(var i = 0; i < arr.length; i++){
  for( var j = i+1; j < arr.length; j++){
    if(arr[i] == arr[j]){
      firstIndex = arr[i];
      break;      
    }

  }
}
console.log(firstIndex);

第一个 for 循环从数组中获取第一个元素（编号 7），然后另一个 for 循环检查所有其他元素，等等。

这里重要的是在第二个循环中定义 j 为 i+1，否则，任何元素都会在相同的索引和 firstIndex 处找到相同的数字 将在所有循环完成后获得最后一个的值。

Answer 8

为了降低上述答案的时间复杂度，您可以使用以下解决方案：

function getFirstRecurringNumber(arrayOfNumbers) {
  const hashMap = new Map();

  for (let number of arrayOfNumbers) { // Time complexity: O(n)
    const numberDuplicatesCount = hashMap.get(number);

    if (numberDuplicatesCount) {
      hashMap.set(number, numberDuplicatesCount + 1);

      continue;
    }

    hashMap.set(number, 1); // Space complexity: O(n)
  }

  for (let entry of hashMap.entries()) { // Time complexity: O(i)
    if (entry[1] > 1) {
      return entry[0];
    }
  }
}

// Time complexity: O(n + i) instead of O(n^2)
// Space complexity: O(n)

Answer 9

使用下面的代码，我可以得到数组中出现的第一个“5”。 .some() 方法一旦找到匹配项就会停止循环。

let james = [5, 1, 5, 8, 2, 7, 5, 8, 3, 5];
let onlyOneFives = [];
james.some(item =>  {
    //checking for a condition. 
    if(james.indexOf(item) === 0) {
        //if the condition is met, then it pushes the item to a new array and then   
        //returns true which stop the loop

        onlyOneFives.push(item);
         return james.indexOf(item) === 0;
   }
})

console.log(onlyOneFives)

Answer 10

创建一个带有数字的数组的函数，在其中执行以下操作： 首先，实例化一个空对象。 其次，创建一个 for 循环，遍历数组的每个元素，并为每个元素添加它们到空对象并检查对象的长度是否已更改，如果没有，则意味着您添加了一个已经存在的元素所以你可以退货：

//Return first recurring number of given array, if there isn't return undefined.

const firstRecurringNumberOf = array =>{
    objectOfArray = {};

    for (let dynamicIndex = 0; dynamicIndex  < array.length; dynamicIndex ++) {
        const elementsBeforeAdding = (Object.keys(objectOfArray)).length;0
        objectOfArray[array[dynamicIndex]] = array[dynamicIndex]
        const elementsAfterAdding = (Object.keys(objectOfArray)).length;

        if(elementsBeforeAdding == elementsAfterAdding){ //it means that the element already existed in the object, so it didnt was added & length doesnt change.
             return array[dynamicIndex];
        }
    }

    return undefined;
}

console.log(firstRecurringNumberOf([1,2,3,4])); //returns undefined
console.log(firstRecurringNumberOf([1,4,3,4,2,3])); //returns 4

Answer 11

var addIndex = [7, 5, 2, 3, 4, 5, 7,6, 2];
var firstmatch = [];
for (var i = 0; i < addIndex.length; i++) {

    if ($.inArray(addIndex[i], firstmatch) > -1) {
        return false;
    }
    firstmatch.push(addIndex[i]);
}