Question

有很多帖子在最简单的方法中找到两个数组中的重复项，但是什么是绝对最快的方式？有没有办法避免使用两个for循环并从addSuppressed时间到O(n^2)时间获取函数？我拥有的数组每个包含约1000个项目。在运行函数之前，我检查哪个数组更长，并将该数组用作O(n)变量。

toCheckAgainst

Answer 1

这可能是另一种实现此目的的方法。您当前的解决方案是在两个阵列上循环并在最长的阵列上循环，这会使大型阵列中的进程变慢，例如，如果一个最长的阵列具有1000个val且更短的阵列具有在这种情况下，只有2个循环1000个值，以找出在这种情况下不能超过2的欺骗。

下面的解决方案循环仅在比其他数组更短的数组上，因为我们只对dupes感兴趣，即使两个数组的长度相同，下面的解决方案也更快，因为在你的解决方案中，你在两个数组上循环，而在下面代码只是循环一个。

在比较Niles代码和我的速度差异方面做了一些测试，看到Niles Code和my code的结果，并且每个1000个值的数组大约快50％

var arr1 = ["Test1", "test2", "test3","test5","test6","test4"];
var arr2 = ["test1", "test4","test5","test6","test2","Test1"];
var result = [];
(arr1.length>arr2.length?arr2:arr1).forEach(function(key) {
    if (-1 != (arr1.length>arr2.length?arr1:arr2).indexOf(key) && -1 == result.indexOf(key)) 
        result.push(key);
}, this);
alert(result); //duplicate values arr

Answer 2

已修改为添加示例代码 如果两个数组（分别为长度“k”和“l”）已经排序，则可以在O（n）中完成。你可以通过合并两个数组（当然不是在内存中，只是在算法上）来完成它，就像在合并排序中使用k + l比较一样。

如果两个数组都没有排序，你可以用O（n log n）（例如上面提到的合并排序）进行O（n²）比较，因为你可以在O中用暴力来完成你的任务（n²）已经在这里排序数组将是多余的。

但并非所有套装都完全未分类，特别是如果它们很大的话。如果我们以quicksort为例，你可以期望平均O（n log n）与O（n log n）比较。但请注意，当集合已经排序时，最快的情况是快速排序是O（n²）！

如果您的数组已排序且不包含重复项，则这是一种非常简单的方法：获取较小数组的各个条目，并在较大的数组中对它们进行二进制搜索 - ＆gt; O（n log n）（二进制搜索是O（log n），你做了n次）。如果保证它不包含重复项，则甚至不必对较小的数组进行排序。

总结：你可以比O（n²）更快地完成它。这取决于输入“实际上”实际获得的速度有多快，但在最佳情况下可以将其降低到O（n）（加上一个小常数），平均为O（n log n）。

'use strict'
var primesieve;
var buffer;
var primelimit;
function clear(where) {
  primesieve[where >>> 5] &= ~((1 << (31 - (where & 31))));
}
function get(where) {
  return ((primesieve[where >>> 5] >>> ((31 - (where & 31)))) &
  1);
}
function nextset(from) {
  while (from < primelimit && !get(from)) {
    from++;
  }
  if (from === primelimit && !get(from)) {
    return - 1;
  }
  return from;
}
function fillsieve(n) {
  var k,
  r,
  j;
  n = n + 1;
  primelimit = n - 1;
  k = Math.ceil(n / 32);
  if (typeof ArrayBuffer !== 'function') {
    buffer = new ArrayBuffer(k * 4);
  } else {
    buffer = k;
  }
  primesieve = new Uint32Array(buffer);
  while (k--) {
    primesieve[k] = 0xffffffff;
  }
  clear(0);
  clear(1);
  for (k = 4; k < n; k += 2) {
    clear(k);
  }
  r = Math.floor(Math.sqrt(n));
  k = 0;
  while (k < n) {
    k = nextset(k + 1);
    if (k > r || k < 0) {
      break;
    }
    for (j = k * k; j < n; j += 2 * k) {
      clear(j);
    }
  }
}
function approx_limit(prime_pi) {
  if (prime_pi < 10) {
    return 30;
  }
  // see first term of expansion of li(x)-li(2)

  return Math.ceil(prime_pi * (Math.log(prime_pi * Math.log(prime_pi))));
}
function primes(prime) {
  var ret,
  k,
  count,
  i;
  ret = [];
  k = 0;
  i = 0;
  count = prime;
  while (count--) {
    k = nextset(k + 1);
    if (k > primelimit || k < 0) {
      break;
    }
    ret[i++] = k;
  }
  return ret;
}
// very simple binary search
Array.prototype.bsearch = function(needle) {
  var mid, lo = 0;
  var hi = this.length - 1;

  while (lo <= hi) {
    mid = Math.floor((lo + hi) / 2);
    if (this[mid] > needle) {
      hi = mid - 1;
    } else if (this[mid] < needle) {
      lo = mid + 1;
    } else {
      return this[mid];
    }
  }
  // assumes no entry "-1", of course
  return -1;
};

var limit = 10 * 1000;
var a, b, b_sorted, u;
var a_length, b_length, u_length;

fillsieve(approx_limit(limit));

// the first array is filled with primes, sorted and unique
a = primes(limit);

// the second array gets filled with an unsorted amount of
// integers between the limits 0 (zero) and "limit".
b = [];
for(var i = 0;i < limit;i++){
  b[i] = Math.floor( Math.random() * (limit + 1));
}
a_length = a.length;
b_length = b.length;

console.log("Length of array a: " + a_length);
console.log("Length of array b: " + b_length);

var start, stop;
u = [];

// Brute-force
start = performance.now();
for(var i = 0; i < a_length; i++){
  for(var j = 0; j< b_length; j++){
    if(a[i] == b[j] && a[i] != u[u.length - 1]){
      u.push(a[i]);
    }
  }
}
stop = performance.now();
console.log("Brute force = " + (stop - start));
console.log("u-length = " + u.length);
console.log(u.join(","));

u = [];
b_sorted = [];
// work on copy
for(var i = 0; i < b_length; i++) b_sorted[i] = b[i];
var entry;

// Sort the unsorted array first, than do a binary search
start = performance.now();
// ECMA-script's arrays sort() function sorts lexically
b_sorted.sort(function(a,b){return a - b;});
for(var i = 0; i < a_length; i++){
  entry = b_sorted.bsearch(a[i])
  if( entry != -1 && entry != u[u.length - 1]){
    u.push(entry);
  }
}
stop = performance.now();
console.log("Binary search = " + (stop - start));
console.log("u-length = " + u.length);
console.log(u.join(","));

使用强力算法在我的小型AMD A8-6600K上运行大约56秒，在二分之一搜索中大约40毫秒（是的，毫秒秒！），该数字甚至包括排序数组。

查找两个数组javascript之间重复的最快方法

2 个答案: