双循环性能问题

Question

对于含糊的标题表示歉意，真的不知道如何描述这个问题。

我最近遇到了一种情况，我必须遍历一个对象数组来比较多个值，我选择在 for 循环中使用 for 循环来比较每个对象与其他每个对象。

虽然这适用于小型阵列，但一旦我的阵列变得更大（比如 10,000 个对象），性能往往会成为一个大问题。

这个数组包含这些类型的对象：

[{ char: '_', from: 0, to: 2, chrLength: 2 },
{ char: '_', from: 0, to: 7, chrLength: 7 },
{ char: 'a', from: 1, to: 3, chrLength: 2 },
{ char: 'a', from: 1, to: 6, chrLength: 5 },
{ char: '_', from: 2, to: 7, chrLength: 5 },
{ char: 'a', from: 3, to: 6, chrLength: 3 }]

我的想法是我只能选择from 和to 不与任何其他对象重叠的对象。 （from 和 to 是另一个数组中的索引）

所以对于示例数组，可能的结果是：

[{ char: '_', from: 0, to: 2, chrLength: 2 },
 { char: 'a', from: 1, to: 3, chrLength: 2 },
 { char: 'a', from: 1, to: 6, chrLength: 5 },
 { char: 'a', from: 3, to: 6, chrLength: 3 }]

我的处理方式如下：

var canUse = true,
    posibilities = [];
for(i = 0; i < l; i++) {
    canUse = true;
    for(var j = 0; j < l; j++) {
        if((results[i].from < results[j].from && results[i].to > results[j].to)) {
            canUse = false;
            break;
        }
    }

    if(canUse) posibilities.push(results[i]);
}

看到较大数组的性能非常糟糕，我想知道是否有更好的解决方案来做到这一点？

Answer 1

这是想法（Demo）：

1. 您需要某种支持 O(log n) 的插入和删除操作的自平衡树。为了简单起见，我使用了红黑树。
2. 您需要使用间隔的中点作为键，即(from + to)/2。
3. 假设您已经将k 项目“插入”到您的树中并且即将插入k+1。您的步骤是：
4. 如果k+1 覆盖了根 - 忽略它。
5. 如果 k+1 被根覆盖 - 从树中移除根并再次尝试。
6. 通过比较 k+1 的中点与根的中点，继续向左或右子树。
7. 插入所有内容后，遍历生成的树，收集每个节点。
8. 利润...通过将其与自身连接，我使用了您的数组的 4 倍。我的机器在 Chrome 下的结果是 116 毫秒（冷启动）和 64 毫秒（预热后）。

代码

 function process() {
    console.log('Processing results of length: ' + l);

    console.time('Processing');

    var comparator = function(a, b) { //Comparator to build a tree
           return a.mid - b.mid;
        },
        isAinB = function(a, b) { //util function to check if a is inside b
            return b.from < a.from && b.to > a.to;    
        },
        rbtree = new RBTree(comparator), //Build an empty tree
        i = results.length - 1, item, posibilities = [];

    function check(root, x) { //Recursive checker
        var data;        

        if(!root) { //Either tree is empty or we've reached a leaf
            rbtree.insert(x);
            return;
        }

        data = root.data;

        if(isAinB(data, x)) { //4
            return;    
        }
        if(isAinB(x, data)) { //5
            rbtree.remove(data);
            check(rbtree._root, x);
            return;
        }    

        check(root[comparator(data, x) > 0 ? 'left' : 'right'], x); //6
    }

    for(; i >= 0; i--) { 
        item = results[i];
        item.mid = (item.from + item.to)/2; //2
        check(rbtree._root, item); //3
    }

    rbtree.each(function(item) { //7
        posibilities.push(item);
    });
    console.timeEnd('Processing');

    console.log(posibilities.length);
}

顺便说一句，我用过这个RBTree implementation。不知道是不是最好的:)

Answer 2

首先对chrLength 属性上的对象进行排序。当您查找阻止对象被包含的对象时，您只需检查至少短两个字符的对象。

results.sort(function(x, y){ return x.chrLength - y.chrLength; });

var posibilities = [];
for (var i = 0; i < l; i++) {
  var canUse = true, len = results[i].chrLength - 2;
  for (var j = 0; results[j].chrLength <= len; j++) {
    if((results[i].from < results[j].from && results[i].to > results[j].to)) {
      canUse = false;
      break;
    }
  }
  if(canUse) posibilities.push(results[i]);
}

使用您的示例数据，这会将检查次数从原始代码中的 36 次减少到仅 8 次。

比较：http://jsfiddle.net/Guffa/5jsSb/

编辑：

您可以创建一个数组，其中每个项目都是具有相同chrLength 的对象数组，然后根据from 属性对每个数组进行排序。这样您就可以轻松地跳到对象开始重叠的点，并在它们不再重叠时停止比较：

var map = [];
for (var i = 0; i < l; i++) {
  var ch = results[i].chrLength;
  while (map.length <= ch) map.push([]);
  map[ch].push(results[i]);
}
for (var i = 1; i < map.length; i++) {
  map[i].sort(function(x, y){ return x.from - y.from; });
}

var posibilities = [];
for (var i = 0; i < l; i++) {
  var canUse = true, len = results[i].chrLength - 2, from = results[i].from, to = results[i].to;
  for (var j = 1; canUse && j <= len; j++) {
    if (map[j][map[j].length - 1].from > from) {
      var k;
      for (k = 0; map[j][k].from <= from; k++);
      for (;k < map[j].length && map[j][k].from < to; k++) {
        if (map[j][k].to < to) {
          canUse = false;
          break;
        }
      }
    }
  }
  if(canUse) posibilities.push(results[i]);
}

这会将from 和to 属性的检查分为两个阶段，因此完整检查的数量（评估map[j][k].to < to）实际上小于对象的总数。

免责声明：您自然需要验证代码是否正确。我检查了结果中的项目数量是否相同，但我没有比较每个项目。

Answer 3

对于初学者来说，一旦canUse 是false，您就不需要继续使用内部循环了。

您可以添加 break; 或将第二个 for 循环更改为：

for (var j = 0; canUse && (j < l); j++)

你可能会看到一个有用的加速。