Question

这应该是一个简单的算法，但我无法绕过逻辑。我需要使用2个数组并仅保留在一个数组或另一个数组中找到的值，而不是两者。

例如，如果我有

arr1 [1,2,3,6]

arr2 [2,3,4,5,7]

我希望再次有2个阵列

arr1 [1,6]
arr2 [4,5,7]

编辑：

我删除了旧代码并添加了一些其他工作代码。仍然不是很漂亮，但至少工作。我需要做的就是将arr3存储到arr1，将arr4存储到arr2中。

    var arr3 = [];
    var arr4 = [];

    var foundMatch = false;

    //find all arr1 elements that don't match arr2 elements
    //store into arr4
    for(var i=0; i<arr1.length; i++)
    {
        foundMatch = false;
        for(var j=0; j<arr2.length; j++)
        {
            if(arr1[i] == arr2[j])
            {
                console.log("match found for [%s] [%s]", i, j);
                foundMatch = true;
                break;
            }
        }
        if(!foundMatch)
        {
            arr4.push(arr1[i]);
        }
    }

    //find all arr2 elements not in arr1
    //store in arr3
    for(var i=0; i<arr2.length; i++)
    {
        foundMatch = false;
        for(var j=0; j<arr1.length; j++)
        {
            if(arr2[i] == arr1[j])
            {
                console.log("match found for [%s] [%s]", i, j);
                foundMatch = true;
                break;
            }
        }
        if(!foundMatch)
        {
            arr3.push(arr2[i]);
        }
    }

Answer 1

您尝试为{2} A - B和B - A获取A和B

arr1 = [1,2,3,6]
arr2 = [2,3,4,5,7]

var required1 = arr1.filter((x) => arr2.indexOf(x) < 0)
var required2 = arr2.filter((x) => arr1.indexOf(x) < 0)

console.log(required1, required2);

Answer 2

时间复杂度方面最快的解决方案是从一个阵列创建Set或hash - ＆gt; O(N)，然后迭代另一个来比较元素是否不是集合 - ＆gt; O(M) - ＆gt;然后将其添加到diffs数组。这里的主要好处是Set查找时间是不变的。此解决方案还具有O(N)的空间复杂度，用于构建集合。

您也可以对其他数组重复此操作，总计O(N) + O(M) + O(N) + O(M)，当删除常数因子时，只有O(N+M)时间复杂度。

为第二个数组构建集合会使总空间复杂度为O(N+M)。

// Total complexity
// Time:  O(N+M)
// Space: O(N+M)

// time complexities for each step shown bellow

let N = [1,2,3,6]
let M = [2,3,4,5,7]

const setForN = new Set(N); // O(N)
const setForM = new Set(M); // O(M)

// O(N + M) at this point

const answerN = N.filter(n => !setForM.has(n)) // O(N)
const answerM = M.filter(m => !setForN.has(m)) // O(M)

// O(N + M) + O(N + M) at this point, which is just O(N + M)

console.log(answerN, answerM);

ES5解决方案：

var N = [1,2,3,6]
var M = [2,3,4,5,7]

var setOfNumbers = function(arr) {
  return arr.reduce(function(set, item) {
    return Object.defineProperty(set, item, { value: item });
  }, Object.create(null));
}
var setForN = setOfNumbers(N);
var setForM = setOfNumbers(M);

var answerN = N.filter(function(n) { return typeof setForM[n] !== 'number' });
var answerM = M.filter(function(m) { return typeof setForN[m] !== 'number' });

console.log(answerN, answerM);

另一种方法是针对N中的每个元素执行其他答案建议的内容。 O(N)，检查M中是否存在 - ＆gt; O(M)，并将其添加到diffs数组中。重复另一个数组。

这具有更好，恒定的空间复杂度O(1)但速度更慢的二次O(N*M)时间。

// Total Complexity:
// Time:  O(N*M)
// Space: O(1)

let N = [1,2,3,6]
let M = [2,3,4,5,7]

// For every element in N -> O(N)
// Iterate through M and check if it's there -> O(M)
// Total: O(N*M)
const answerN = N.filter(n => !M.includes(n));

// For every element in M -> O(M)
// Iterate through N and check if it's there -> O(N)
// Total: O(M*N)
const answerM = M.filter(m => !N.includes(m));

// O(N*M) + O(M*N) at this point, which is just O(N*M)

console.log(answerN, answerM);

Answer 3

您可以使用数组过滤器方法检查2个数组的交集：考虑以下代码，创建2个仅包含唯一值的新数组：

let arr1 = [1,2,3,6];
let arr2 =  [2,3,4,5,7];

let newArr1 = arr1.filter((itm)=>{
    return arr2.indexOf(itm) == -1
});

let newArr2 = arr2.filter((itm)=>{
    return arr1.indexOf(itm) == -1
});

选择newArr1和newArr2是：

[1, 6] 
[4, 5, 7]

Answer 4

var arr1 = [1,2,3,6],

    arr1Copy = arr1,

    arr2 = [2,3,4,5,7];

arr1 = arr1.filter(function(outerItem){
  return !arr2.some(function(innerItem){
    return outerItem === innerItem;
  })
})

arr2 = arr2.filter(function(outerItem){
  return !arr1Copy.some(function(innerItem){
    return outerItem === innerItem;
  })
})

比较2个数组的差异（找到对称差异）

4 个答案: