Javascript：有效地比较两个整数数组

我有两个包含数值的整数数组。我想查看这两个列表，并检查列表之间的共性（或缺乏）。也就是说，我希望遍历数组并查找出现在两个列表中的项目，而在一个单独的函数中，我希望遍历数组并查找第一个而不是第二个列表中的项目

执行此操作的明显方法是嵌套循环：

var containedInFirst = false;
for (var primaryID = 0; primaryID < PrimaryArray.length; primaryID++) {
        containedInFirst = false;
        for (var secondaryID = 0; secondaryID < SecondaryArray.length; secondaryID++) {
            if (PrimaryArray [primaryID] === SecondaryArray[secondaryID]) {
                containedInFirst = true;
                break;
            }
        }

//Do some more stuff based on the value of containedInFirst here
}

var containedfirst=false；
对于（var primaryID=0；primaryID

但考虑到列表可能包含数百或数千条记录，这是一个相当大的工作量和处理器密集型。 因此，我想知道是否有更有效的方法来执行上述代码？不仅仅是实际的搜索，还有比整数数组更有效的方法作为值的容器，或者不使用嵌套for循环遍历和比较内容

---

有没有关于更有效或更优雅的解决方案的想法？

首先对它们进行排序，然后在它们之间进行并行处理

a.sort();
b.sort();

left = []; both = []; right = []; 
i = 0; j = 0;
while (i < a.length && j < b.length) {
    if (a[i] < b[j]) {
        left.push(a[i]);
        ++i;
    } else if (b[j] < a[i]) {
        right.push(b[j]);
        ++j;
    } else {
        both.push(a[i]);
        ++i; ++j;
    }
}
while (i < a.length) {
    left.push(a[i]);
    ++i;
}
while (j < b.length) {
    right.push(b[j]);
    ++j;
}

a.sort（）；
b、 排序（）；
左=[]；两者=[]；右=[]；
i=0；j=0；
而（i

对两个数组进行排序，然后循环一次并比较：

function diff(arrayToCompareTo, comparedArray)
{
  Sort(arrayToCompareTo);
  Sort(comparedArray);

  var difference = [], same = [];
  for(var i = 0; i < arrayToCompareTo.length; ++i)
  {
     if (arrayToCompareTo[i] != comparedArray[i])
        difference.push(comparedArray[i]);
     else
        same.push(comparedArray[i]);
  }

  if (comparedArray.length > arrayToCompareTo.length)
     for(var i = arrayToCompareTo.length; i < comparedArray.length; ++i)
       difference.push(comparedArray[i]);
}

函数差异（数组比较到，比较数组）
{
排序（arrayToCompareTo）；
排序（比较数组）；
var差异=[]，相同=[]；
对于（变量i=0；iArrayTo.length）
对于（变量i=ArrayTo.length；i

这没有经过测试，因此如果出现问题，请告诉我。

---

无论如何，这应该将您设置到正确的方向，因为它最好是O（N），最坏是O（M）。如果

comparedArray.length>arrayCompareTo.length

，它比O（N^2）更有效。请注意，排序需要O（N logn）。

使用两个嵌套循环时，复杂性将为O（N*N）。 对这两个数组进行排序的复杂度为O（n logn）

正如马塞洛·坎托斯（Marcelo Cantos）所说，鸭子摇摇晃晃地走着：）

---

通过并行计算，两者的复杂性为O（n），导致总体复杂性为O（n logn）+O（n），即O（n logn）。

我认为我有效率为O（n）（无需排序）的解决方案，如下所示：

var firstNotSecond;
function CompareIntArrays(arr1, arr2)
{
    firstNotSecond = new Array();

    var arr3 = new Array(); //appear in both
    var arrTemp = new Array(); //used for firstNotSecond
    var usedNumbers = new Array();

    for (var i = 0; i < arr1.length; i++)
    {
        var key = arr1[i];
        usedNumbers[key] = true;
        arrTemp[key + ""] = true;
    }

    for (var i = 0; i < arr2.length; i++)
    {
        var key = arr2[i];
        if (usedNumbers[key])
        {
            arr3[arr3.length] = key;
            arrTemp[key] = false;
        }
    }

    for (var key in arrTemp)
        if (arrTemp[key])
            firstNotSecond[firstNotSecond.length] = parseInt(key);

    return arr3;
}

使用具有100000个项目的阵列进行测试：不到1秒。

---

使用每个阵列有200000个项目进行测试：不到2秒。

另一种可能是在创建阵列时订购这些阵列。我不确定你是否能做到。但是如果可以的话，它会增加向数组中添加元素的复杂性（O（logn）而不是O（1）），但它会将比较算法的复杂性降低到O（n）

每个人都过于复杂化了。这里有一行：

var isEqual = (JSON.stringify(arr1.sort()) === JSON.stringify(arr2.sort()));

---

@塔里亚马：我的解决方案足够好吗？如何改进？我的算法感觉有点生疏。@Thariama:你的解决方案已经足够好了，但是你没有注意到你想要的第二个功能（得到所有没有区别的元素）@Thariama:修复了，谢谢。我对复杂性的看法正确吗？我的方法对大型阵列足够好吗？我所描述的复杂性很好（不是O（N），因为排序算法采用O（N log N））@Thariama:Marcelo Cantos的解决方案是否因为更具特色而更好？只是对“优雅”的一个建议part=）在webworker中运行该任务，如果浏览器支持它们，则必须维护顺序吗？数组是否已排序？数组中有大整数吗？这如何回答OP的问题“我想遍历数组，找到第一个数组中的项而不是第二个数组中的项”？我想你把这个问题过于简化了。这正是我来这里的目的，比较两个是否相等。谢谢大家!@蒂莫西简单而聪明，非常适合小名单

var isEqual = (JSON.stringify(arr1.sort()) === JSON.stringify(arr2.sort()));