通過在Javascript中比較2個數組來找到缺失的元素

Question

由於某種原因，我在圍繞這個問題時遇到了一些嚴重的困難。我需要這個接受2個數組的JS函數，比較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

這應該工作。您還應該考慮數組元素實際上也是數組的情況。 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 2

看看下劃線difference功能：http://documentcloud.github.com/underscore/#difference

Answer 3

我知道這是代碼，但嘗試看到不同的例子來理解方式：

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 4

問題陳述：

發現了在這是有前一陣在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)) 

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時，該元素將作爲缺失元素返回。