通过比较 Javascript 中的 2 个数组来查找缺失的元素

Question

出于某种原因，我很难解决这个问题。我需要这个 JS 函数，它接受 2 个数组，比较 2，然后返回缺少元素的字符串。例如。查找 currentArray 中缺少的元素，该元素在前一个数组中存在。

function findDeselectedItem(CurrentArray, PreviousArray){

var CurrentArrSize = CurrentArray.length;
var PrevousArrSize = PreviousArray.length;

// Then my brain gives up on me...
// I assume you have to use for-loops, but how do you compare them??

return missingElement;

}

提前致谢！我不是要代码，但即使只是朝着正确的方向推动或提示可能会有所帮助......

Answer 1

问题陈述：

在 currentArray 中找到前一个数组中缺少的元素。

previousArray.filter(function(x) {  // return elements in previousArray matching...
    return !currentArray.includes(x);  // "this element doesn't exist in currentArray"
})

（这与编写两个嵌套的 for 循环一样糟糕，即 O(N²) 时间*）。如有必要，可以通过从currentArray 创建一个临时对象并将其用作 O(1) 查询的哈希表来提高效率。例如：）

var inCurrent={}; currentArray.forEach(function(x){ inCurrent[x]=true });

那么我们有一个临时查找表，例如

previousArray = [1,2,3]
currentArray = [2,3];
inCurrent == {2:true, 3:true};

那么该函数不需要每次都重复搜索currentArray，这将是一个O(N)的子步骤；它可以在 O(1) 时间内立即检查它是否在 currentArray 中。由于.filter 被调用了 N 次，因此总时间为 O(N) 而不是 O(N²)：

previousArray.filter(function(x) {
    return !inCurrent[x]
})

或者，这里是for循环样式：

var inCurrent = {};
var removedElements = []
for(let x of currentArray)
    inCurrent[x] = true;
for(let x of previousArray)
    if(!inCurrent[x])
        removedElements.push(x)
        //break; // alternatively just break if exactly one missing element
console.log(`the missing elements are ${removedElements}`)

或者只是使用现代数据结构，这使得代码更加明显：

var currentSet = new Set(currentArray);
return previousArray.filter(x => !currentSet.has(x))

*（旁注：或者技术上，正如我在更一般的情况下说明的那样，其中 >1 个元素被取消选择，O(M*N) 时间）

Answer 2

这应该可行。您还应该考虑数组元素实际上也是数组的情况。 indexOf 可能无法按预期工作。

function findDeselectedItem(CurrentArray, PreviousArray) {

   var CurrentArrSize = CurrentArray.length;
   var PreviousArrSize = PreviousArray.length;

   // loop through previous array
   for(var j = 0; j < PreviousArrSize; j++) {

      // look for same thing in new array
      if (CurrentArray.indexOf(PreviousArray[j]) == -1)
         return PreviousArray[j];

   }

   return null;

}

Answer 3

看看下划线difference函数：http://documentcloud.github.com/underscore/#difference

Answer 4

我知道这是代码，但尝试查看差异示例以了解方式：

var current = [1, 2, 3, 4],
    prev = [1, 2, 4],
    isMatch = false,
    missing = null;

var i = 0, y = 0,
    lenC = current.length,
    lenP = prev.length;

for ( ; i < lenC; i++ ) {
    isMatch = false;
    for ( y = 0; y < lenP; y++ ) {
        if (current[i] == prev[y]) isMatch = true;
    }
    if ( !isMatch ) missing = current[i]; // Current[i] isn't in prev
}

alert(missing);

---

或者使用ECMAScript 5 indexOf:

var current = [1, 2, 3, 4],
    prev = [1, 2, 4],
    missing = null;

var i = 0,
    lenC = current.length;

for ( ; i < lenC; i++ ) {
    if ( prev.indexOf(current[i]) == -1 ) missing = current[i]; // Current[i] isn't in prev
}

alert(missing);

而与时

var current = [1, 2, 3, 4],
    prev = [1, 2, 4],
    missing = null,
    i = current.length;

while(i) {
    missing = ( ~prev.indexOf(current[--i]) ) ? missing : current[i];
}

alert(missing);

Answer 5

这是我的方法（也适用于重复条目）：- //这里的第二个参数实际上是当前数组

function(previousArray, currentArray) {
    var hashtable=[]; 

    //store occurances of elements in 2nd array in hashtable
    for(var i in currentArray){
        if(hashtable[currentArray[i]]){
            hashtable[currentArray[i]]+=1; //add 1 for duplicate letters
        }else{
            hashtable[currentArray[i]]=1; //if not present in hashtable assign 1
        }
    }
    for(var i in previousArray){
            if(hashtable[previousArray[i]]===0 || hashtable[previousArray[i]] === undefined){ //if entry is 0 or undefined(means element not present)
                return previousArray[i]; //returning the missing element
            }
    else{
             hashtable[previousArray[i]]-=1; //reduce count by 1
        }

    }
}

逻辑是我创建了一个名为哈希表的空白数组。我们首先迭代 currentArray 并将元素用作索引，将值用作从 1 开始的计数（这有助于在存在重复条目的情况下）。然后我们遍历 previousArray 并查找索引，如果它们匹配，我们将值计数减 1。如果第二个数组的元素根本不存在，那么我们的未定义检查条件将触发并返回它。如果存在重复，则每次减 1，当遇到 0 时，该元素作为缺失元素返回。