用于在两个数组中查找公共元素的 Javascript 程序

Question

最近我有一个面试问题如下： 让我们考虑我们有两个不同长度的排序数组。需要在两个数组中找到共同的元素。

var a=[1,2,3,4,5,6,7,8,9,10];
var b = [2,4,5,7,11,15];
for(var i=0;i<a.length;i++){
    for(var j=0;j<b.length;j++){
        if(a[i]==b[j]){
            console.log(a[i],b[j])
        }
    }
}

我像上面那样写的。面试官说现在假设 a 有 2000 个元素，b 有 3000 个元素。那你是怎么写得更有效率的呢？

请用示例代码解释您的答案。这样我可以更清楚地理解。

Answer 1

我有时发现将一个列表转换为哈希集很方便。

var hashA = {};
for(var i=0; i<a.length; i++) {hashA[a[i]] = true;}

然后你可以搜索哈希集。

for(var i=0; i<b.length; i++) {if(hashA[b[i]]) {console.log(b[i]);}}

这当然不如二分搜索快，因为你必须花时间来构建哈希集，但它还不错，如果你需要保留列表并在未来进行大量搜索，它可能是最好的选择.另外，我知道 javascript 对象不仅仅是哈希集，它很复杂，但大多数情况下效果都很好。

不过，老实说，对于 3000 个项目，我不会更改代码。那还不足以成为一个问题。这将在 30 毫秒内运行。因此，它还取决于它运行的频率。一小时一次？忘掉它。每毫秒一次？绝对要优化它。

Answer 2

The easiest way!!

var a = [1,2,3,4,5,6,7,8,9,10];
var b = [2,4,5,7,11,15];

for(let i of a){
  if(b.includes(i)){
    console.log(i)
  }
}


--------- OR --------------

var c = a.filter(value => b.includes(value))
console.log(c)

Answer 3

不确定，但这可能会有所帮助

let num1 = [2, 3, 6, 6, 5];
let num2 = [1, 3, 6, 4];
var array3 = num1.filter((x) => {
  return num2.indexOf(x) != -1
})
console.log(array3);

Answer 4

如果我们谈论的是在两个数组之间找到共同元素的算法，那么这是我的看法。

function common(arr1, arr2) {
 var newArr = [];
 newArr = arr1.filter(function(v){ return arr2.indexOf(v) >= 0;}) 
 newArr.concat(arr2.filter(function(v){ return newArr.indexOf(v) >= 0;}));
 return newArr;
}

但如果你还要考虑性能，那么你也应该尝试其他方法。

首先在此处检查 javascript 循环的性能，它将帮助您找出最佳方法

https://dzone.com/articles/performance-check-on-different-type-of-for-loops-a

https://hackernoon.com/javascript-performance-test-for-vs-for-each-vs-map-reduce-filter-find-32c1113f19d7

Answer 5

您可以使用第一个数组（无论它们是否已排序）构建散列，然后迭代第二个数组并检查散列中是否存在！

let arr1 = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140, 150],
  arr2 = [15,30,45,60,75,90,105,120,135,150,165]
  hash = arr1.reduce((h,e)=> (h[e]=1, h), {}), //iterate first array once
  common = arr2.filter(v=>hash[v]); //iterate secod array once
  
  console.log('Cpmmon elements: ', common);

Answer 6

由于数组是排序的，所以二分查找是关键。

基本上，您正在搜索数组中的项目。

您将项目与数组的中间索引（长度/2）进行比较

如果两者相等，你就找到了。

如果项低于数组中间索引处的项，则将项与索引长度 / 4 -> ((0 + 长度 / 2) / 2) 的索引进行比较，如果低于，则在索引 ( (length / 2) + length) / 2（上半部分的中间）等等。

这样，如果在示例中您必须在 40 000 长度的数组中搜索项目，更糟糕的是，您会发现该项目不在经过 16 次比较的数组中：

我在一个有 40000 个索引的数组中搜索“某物”，我能找到它的最小索引是 0，最大值是 39999。

"something" > arr[20000]。让我们假设。我知道现在要搜索的最小索引是 20001，最大值是 39999。我现在正在搜索中间的 (20000 + 39999) / 2。

现在，"something" < arr[30000]，它将搜索范围从索引 20001 限制到 29999。(20000 + 30000) / 2 = 25000。

"something" > arr[25000]，我要从 25001 搜索到 29999。(25000 + 30000) / 2 = 27500

"something" < arr[27500]，我要从 25001 搜索到 27499。(25000 + 27500) / 2 = 26250

"something" > arr[26250]，我必须从 26251 搜索到 27499。(26250 + 27500) / 2 = 26875

"something" < arr[26875]，我要从 26251 搜索到 26874。(26250 + 26875) / 2 = 26563

等等......当然，你必须四舍五入以避免浮动索引

var iteration = 1;

function bSearch(item, arr)
{
    var minimumIndex = 0;
    var maximumIndex = arr.length - 1;
    var index = Math.round((minimumIndex + maximumIndex) / 2);

    while (true)
    {
        ++iteration;
        if (item == arr[index])
        {
            arr.splice(0, minimumIndex);
            return (true);
        }
        if (minimumIndex == maximumIndex)
        {
            arr.splice(0, minimumIndex);
            return (false);
        }
        if (item < arr[index])
        {
            maximumIndex = index - 1;
            index = Math.ceil((minimumIndex + maximumIndex) / 2);
        }
        else
        {
            minimumIndex = index + 1;
            index = Math.floor((minimumIndex + maximumIndex) / 2);
        }
    }
}

var arrA;
var arrB;

for (var i = 0; i < arrA.length; ++i)
{
    if (bSearch(arrA[i], arrB))
        console.log(arrA[i]);
}
console.log("number of iterations : " + iteration);

Answer 7

我们可以迭代一个数组并在另一个数组中找到重复项，但是每次找到匹配项时，我们都会移动到匹配的元素 + 1 以进行嵌套循环中的下一次迭代。它之所以有效，是因为两个数组都已排序。所以每个匹配的数组都比较短（从左到右）。

我们也可以在第二个数组的元素大于第一个时打破嵌套循环（从右到左更短），因为我们永远找不到匹配项（因为数组是有序，只剩下更大的值），这里和示例在两个 10k 元素的数组中查找重复项大约需要 15 毫秒：

var arr = [];
var arr2 = [];

for(let i = 0; i<9999; i++){
    arr.push(i);
    arr2.push(i+4999)
}

var k = 0;//<-- the index we start to compare
var res = [];

for (let i = 0; i < arr2.length; i++) {
  for (let j = k; j < arr.length; j++) {
    if (arr2[i] === arr[j]) {
      res.push(arr2[i]);
      k = j + 1;//<-- updates the index
      break;
    } else if (arr[j] > arr2[i]) {//<-- there is no need to keep going
      break;
    }
  }
}

console.log(res.length)

我没有打印 res，因为它有 5000 个元素。

Answer 8

由于两个数组都已排序，因此只需保存最新的匹配索引。然后从这个索引开始你的内部循环。

var lastMatchedIndex = 0;
for(var i=0;i<a.length;i++){
    for(var j=lastMatchIndex ;j<b.length;j++){
        if(a[i]==b[j]){
            console.log(a[i],b[j]);
            lastMatchedIndex = j;
            break;
        }
    }
}

==================

更新：

正如 Xufox 在 cmets 中提到的，如果 a[i] 低于 b[i] 那么你有中断循环，因为它没有继续循环的意义。

var lastMatchedIndex = 0;
for(var i=0;i<a.length;i++){
    if(a[i]<b[i]){
        break;
    }   
    for(var j=lastMatchIndex ;j<b.length;j++){
        if(a[i]==b[j]){
            console.log(a[i],b[j]);
            lastMatchedIndex = j;
            break;
        }
        if(a[i]<b[j]){
            lastMatchedIndex = j;
            break;
        }         
    }
}

Answer 9

最佳策略是将比较次数和数组读数降至最低。

理论上你想要的是交替你正在处理的列表，以避免不必要的比较。鉴于列表已排序，我们知道列表中任何索引左侧的数字都不能小于当前索引。

假设以下列表A = [1,5]、列表B = [1,1,3,4,5,6] 和索引a 和b 都从0 开始，您会希望您的代码如下所示：

A[a] == 1, B[b] == 1
A[a] == B[b] --> add indexes to results and increase b (B[b] == 1)
A[a] == B[b] --> add indexes to results and increase b (B[b] == 3)
A[a] < B[b] --> don't add indexes to results and increase a (A[a] == 5)
A[a] > B[b] --> don't add indexes to results and increase b (B[b] == 4)
A[a] > B[b] --> don't add indexes to results and increase b (B[b] == 5)
A[a] == B[b] --> add indexes to results and increase b (B[b] == 6)
A[a] < B[b] --> don't add indexes to results and increase a (A is at the end, so we terminate and return results)

下面是我的 JavaScript 执行上述算法：

//Parameters
var listA = [];
var listB = [];
//Parameter initialization
(function populateListA() {
    var value = 0;
    while (listA.length < 200) {
        listA.push(value);
        value += Math.round(Math.random());
    }
})();
(function populateListB() {
    var value = 0;
    while (listB.length < 300) {
        listB.push(value);
        value += Math.round(Math.random());
    }
})();
//Searcher function
function findCommon(listA, listB) {
    //List of results to return
    var results = [];
    //Initialize indexes
    var indexA = 0;
    var indexB = 0;
    //Loop through list a
    while (indexA < listA.length) {
        //Get value of A
        var valueA = listA[indexA];
        var result_1 = void 0;
        //Get last result or make a first result
        if (results.length < 1) {
            result_1 = {
                value: valueA,
                indexesInA: [],
                indexesInB: []
            };
            results.push(result_1);
        }
        else {
            result_1 = results[results.length - 1];
        }
        //If higher than last result, make new result
        //Push index to result
        if (result_1.value < valueA) {
            //Make new object
            result_1 = {
                value: valueA,
                indexesInA: [indexA],
                indexesInB: []
            };
            //Push to list
            results.push(result_1);
        }
        else {
            //Add indexA to list
            result_1.indexesInA.push(indexA);
        }
        //Loop through list b
        while (indexB < listB.length) {
            //Get value of B
            var valueB = listB[indexB];
            //If b is less than a, move up list b
            if (valueB < valueA) {
                indexB++;
                continue;
            }
            //If b is greather than a, break and move up list a
            if (valueB > valueA) {
                break;
            }
            //If b matches a, append index to result
            result_1.indexesInB.push(indexB);
            //Move up list B
            indexB++;
        }
        //Move up list A
        indexA++;
    }
    //Return all results with values in both lines
    return results.filter(function (result) { return result.indexesInB.length > 0; });
}
//Run
var result = findCommon(listA, listB);
//Output
console.log(result);

Answer 10

您可以通过检查每个数组的索引来使用嵌套方法，并通过增加索引来查找值。如果找到相等的值，则增加两个索引。

时间复杂度：最大。 O(n+m)，其中n是数组a的长度，m是数组b的长度。

var a = [1, 2, 3, 4, 5, 6, 8, 10, 11, 15], // left side
    b = [3, 7, 8, 11, 12, 13, 15, 17],     // right side
    i = 0,                                 // index for a
    j = 0;                                 // index for b

while (i < a.length && j < b.length) {     // prevent running forever
    while (a[i] < b[j]) {                  // check left side
        ++i;                               // increment index
    }
    while (b[j] < a[i]) {                  // check right side
        ++j;                               // increment
    }
    if (a[i] === b[j]) {                   // check equalness
        console.log(a[i], b[j]);           // output or collect
        ++i;                               // increment indices
        ++j;
    }
}