Javascript 和集合

Question

想象你在 javascript/NodeJs 中有 3 个列表/数组

1. 数组包含 1.000.000 个数据项
2. 数组包含 100.000 个数据项
3. 数组包含 50.000 个数据项

每个数据项都是一个具有 2 个属性的对象 - 例如日期和价格。 数组 2 和 3 中的所有项都是数组 1 中项的子集/子列表。

我的问题：我如何以最快的方式 - 匹配数组 1 中每个项目的所有日期 - 与数组 2 和 3 中的所有日期 - 匹配数组 1 中的每个项目？

我习惯了 .NET/C# - 'contains(item)' 之类的东西很好......现在在 NodeJS 中我使用 3 个 for 循环 - 这是一种减慢速度的方式......我需要一些索引之类的以加快进程...

数据示例如下：

输入：

array 1: 1,2,3,4,5,6,7,8,10
array 2: 2,3,5,7,9
array 3: 1,4,5,10

输出（写入文件）：

1,'',1
2,2,''
3,3,''
4,'',4
..ect...

Answer 1

如果数组是排序的我猜JS中最快的数组交集算法是这样的

function intersect(a1, a2)
{
  var a1i = 0,
      a2i = 0,
    isect = [];

  while( a1i < a1.length && a2i < a2.length ){
    if (a1[a1i].date < a2[a2i].date) a1i++;
     else if (a1[a1i].date > a2[a2i].date) a2i++;
     else {isect.push(a1i); // they match
           a1i++;
           a2i++;}
  }

  return isect;
}

一旦你得到了交集索引，你就可以轻松地构建你想要的输出。

但是，如果您想提出一个很酷的工具...那么为什么不发明Array.prototype.intersect()

Array.prototype.intersect = function(...a) {
  return [this,...a].reduce((p,c) => p.filter(e => c.includes(e)));
}
var arrs = [[0,2,4,6,8],[4,5,6,7],[4,6]],
     arr = [0,1,2,3,4,5,6,7,8,9];

document.write("<pre>" + JSON.stringify(arr.intersect(...arrs)) + "</pre>");

Answer 2

这是javascript！考虑将数组重组为对象，以便 Date 属性成为键，例如： var arr2 = { '2016-05-13 00:00:01': { prop: 'value', prop2: 'value' }, '2016-05-13 00:00:02': { prop: 'value' , prop2: '值' }, ... }; 这样 arr2[date] 要么返回一个对象，要么返回未定义。如果你有一个对象，将其转换为适合输出的字符串；否则写''或其他。

Answer 3

var t = {}
// loop through once and create a constant time lookup
arr1.forEach(function(item){t[item.date] = {1: item.price, 2: null, 3:null})
arr2.forEach(function(item){if (t[item.date]) t[item.date].2 = item.price})
arr3.forEach(function(item){if (t[item.date]) t[item.date].3 = item.price})

这将是一个线性操作，首先对数据进行排序的权衡可能值得也可能不值得花时间进行排序。

无论哪种方式，它都与三重 JOIN 大致相同，我提供的解决方案是 O(N)，其中嵌套循环可能是 O(N^3)，排序的解决方案仍然可能是 O(Nlog(N )) 只是猜测。

如果日期已经排序，您可能会将日期分桶或进行某种基数搜索，这可能会加快速度。

见：https://en.m.wikipedia.org/wiki/Radix_tree

你也可以通过 Promise 来实现，让它异步运行：

var t = {}
// loop through once and create a constant time lookup
arr1.forEach(function(item){t[item.date] = {1: item.price, 2: null, 3:null})

var promiseArray = arr2.map(function(item){
    return Promise.resolve(item)
        .then(function(item){
              if (t[item.date]) t[item.date].2 = item.price})
         })
// concat the two promise arrays together 
promiseArray.concat(arr3.map(function(item){
    return Promise.resolve(item)
        .then(function(item){
              if (t[item.date]) t[item.date].3 = item.price})
         }))
// resolve all the promises
Promise.all(promiseArray)
    .then(function(){
        // t has results
        debugger
    })

Answer 4

我会尝试首先按您的键属性 (Date, afaiu) 对所有数组进行排序（如果尚未排序），然后在第一个数组上使用单个 for 循环，光标位于另外两个数组中，这将移动到仅当当前项目已写入输出时，下一个项目。这样就不会在整个数组中进行任何“包含”搜索。

例子：

var j = 0;
var k = 0;
for( var i = 0; i < array1.length; ++i ) {
    var out1 = array1[i].date;
    var out2 = j < array2.length && array2[j].date == out1 ? array2[j++].value : '';
    var out3 = k < array3.length && array3[k].date == out1 ? array3[k++].value : '';
    output( out1, out2, out3 );
}