通过比较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-loop风格：

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))

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
        }

    }
}

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