让范围成为两个整数的数组：start和end（例如[40, 42]）。
有两个范围数组（已排序），我想找到计算其交集的最佳方法（这将导致另一个范围数组）：
A = [[1, 3], [7, 9], [12, 18]]
B = [[2, 3], [4,5], [6,8], [13, 14], [16, 17]]
路口：
[[2, 3], [7, 8], [13, 14], [16, 17]]
这个的最佳算法是什么？
天真的方法是用其他所有方法检查每一个，但这显然不是最佳的。
我在VBA中发现了一个类似的问题：Intersection of two arrays of ranges
答案 0 :(得分：6)
由于输入数组已经排序，因此这应该非常简单。我假设任何一个输入数组中的范围彼此不相交（否则，“已排序”将是不明确的）。考虑每个数组中的一个范围（由“当前范围”索引a和b定义）。有几种情况（除了“完全重叠”之外的每种情况都有一个镜像，其中A和B被反转）：
没有交集：
A[a]: |------|
B[b]: |---|
由于数组已排序，A[a]不能与B中的任何内容相交，因此可以跳过它（增量a）。
部分重叠（B[b]超出A[a]）：
A[a]: |-------|
B[b]: |-------|
在这种情况下，将交集添加到输出中，然后增加a，因为A[a]不能与B中的任何其他内容相交。
遏制（可能有一致的结束）：
A[a]: |------|
B[b]: |--|
再次将输出添加到输出和此时间增量b。请注意，进一步的轻微优化是，如果A[a]和B[b]以相同的值结束，那么您也可以增加b，因为B[b]也不能与其他任何内容相交A。 （重合端的情况可能已经集中在部分重叠的情况下。这种情况可能被称为“严格控制”。）
完全重叠：
A[a]: |------|
B[b]: |------|
将交集添加到输出并增加a和b（两个范围都不能与另一个数组中的其他任何内容相交）。
继续迭代上述内容，直到a或b从相应数组的末尾开始运行，然后就完成了。
应该琐碎直接将上述内容翻译成代码。
编辑：要备份最后一句话（好吧，这不是一件小事），这是我在上面的代码版本。由于所有情况，这有点单调乏味，但每个分支都非常简单。
const A = [[1, 3], [7, 9], [12, 18]];
const B = [[2, 3], [4, 5], [6, 8], [13, 14], [16, 17]];
const merged = [];
var i_a = 0,
i_b = 0;
while (i_a < A.length && i_b < B.length) {
const a = A[i_a];
const b = B[i_b];
if (a[0] < b[0]) {
// a leads b
if (a[1] >= b[1]) {
// b contained in a
merged.push([b[0], b[1]]);
i_b++;
if (a[1] === b[1]) {
// a and b end together
i_a++;
}
} else if (a[1] >= b[0]) {
// overlap
merged.push([b[0], a[1]]);
i_a++;
} else {
// no overlap
i_a++;
}
} else if (a[0] === b[0]) {
// a and b start together
if (a[1] > b[1]) {
// b contained in a
merged.push([a[0], b[1]]);
i_b++;
} else if (a[1] === b[1]) {
// full overlap
merged.push([a[0], a[1]]);
i_a++;
i_b++;
} else /* a[1] < b[1] */ {
// a contained in b
merged.push([a[0], a[1]]);
i_a++;
}
} else /* a[0] > b[0] */ {
// b leads a
if (b[1] >= a[1]) {
// containment: a in b
merged.push([a[0], b[1]]);
i_a++;
if (b[1] === a[1]) {
// a and b end together
i_b++;
}
} else if (b[1] >= a[0]) {
// overlap
merged.push([a[0], b[1]]);
i_b++
} else {
// no overlap
i_b++;
}
}
}
console.log(JSON.stringify(merged));
您要求最佳算法。我相信我的非常接近最佳状态。它以线性时间运行，具有两个数组中的范围数，因为每次迭代完成至少一个范围（有时是两个）的处理。它需要恒定的内存加上构建结果所需的内存。
我应该注意，与CertainPerformance（我写这篇文章时唯一的其他答案）的答案不同，我的代码适用于任何类型的数值范围数据，而不仅仅是整数。 （如果您要混合数字和数字的字符串表示，您可能希望在上面用===替换==。 CertainPerformance的算法将范围展平为跨越范围的连续整数数组。如果整数的总数是n，那么他的算法在O（n 2 ）时间和O（n）空间中运行。 （因此，例如，如果其中一个范围是[1,50000]，则需要50,000个数字的存储器和与其平方成正比的时间。）
答案 1 :(得分：4)
@Ted Hopp建议的想法可以用更少的代码行实现，如下所示：
var A = [[1, 3], [7, 9], [12, 18]];
var B = [[2, 3], [4, 5], [6, 8], [13, 14], [16, 17]];
var result = [];
var ai = 0, alength = A.length, ax, ay;
var bi = 0, blength = B.length, bx, by;
while (ai < alength && bi < blength) {
ax = A[ai][0];
ay = A[ai][1];
bx = B[bi][0];
by = B[bi][1];
if (ay < bx) {
// a ends before b
ai++;
} else if (by < ax) {
// b ends before a
bi++;
} else {
// a overlaps b
result.push([ax > bx ? ax : bx, ay < by ? ay : by]);
// the smaller range is considered processed
if (ay < by) {
ai++;
} else {
bi++;
}
}
}
console.log(result);
以下是使用大型数组的综合测试：
var A = [];
var B = [];
var R = [];
(function(rangeArray1, rangeArray2, bruteForceResult) {
// create random, non-overlapping, sorted ranges
var i, n, x, y;
for (i = 0, n = 0; i < 1000; i++) {
x = n += Math.floor(Math.random() * 100) + 1;
y = n += Math.floor(Math.random() * 100);
rangeArray1.push([x, y]);
}
for (i = 0, n = 0; i < 1000; i++) {
x = n += Math.floor(Math.random() * 100) + 1;
y = n += Math.floor(Math.random() * 100);
rangeArray2.push([x, y]);
}
// calculate intersections using brute force
rangeArray1.forEach(function(a) {
rangeArray2.forEach(function(b) {
if (b[1] >= a[0] && a[1] >= b[0]) {
bruteForceResult.push([Math.max(a[0], b[0]), Math.min(a[1], b[1])]);
}
});
});
})(A, B, R);
var result = [];
var ai = 0, alength = A.length, ax, ay;
var bi = 0, blength = B.length, bx, by;
while (ai < alength && bi < blength) {
ax = A[ai][0];
ay = A[ai][1];
bx = B[bi][0];
by = B[bi][1];
if (ay < bx) {
// a ends before b
ai++;
} else if (by < ax) {
// b ends before a
bi++;
} else {
// a overlaps b
result.push([ax > bx ? ax : bx, ay < by ? ay : by]);
// the smaller range is considered processed
if (ay < by) {
ai++;
} else {
bi++;
}
}
}
console.log(JSON.stringify(R) === JSON.stringify(result) ? "test passed" : "test failed");
答案 2 :(得分：2)
非常简单，只需要编写相当数量的代码。将a和b展平为单个元素而不是范围，找到它们的交集，然后再将其转换回范围数组。
const a = [[1, 3], [7, 9], [12, 18]];
const b = [[2, 3], [4,5], [6,8], [13, 14], [16, 17]];
const rangeToArr = ([start, end]) => Array.from({ length: end - start + 1 }, (_, i) => start + i);
const flat = inputArr => inputArr.reduce((arr, elm) => arr.concat(...elm), []);
const aRange = flat(a.map(rangeToArr));
const bRange = flat(b.map(rangeToArr));
const intersection = aRange.filter(num => bRange.includes(num));
console.log(intersection);
// Have the intersection of elements
// now we have to turn the intersection back into an array of ranges again:
const { partialIntersectionRange, thisRangeStarted, lastNum }
= intersection.reduce(({ partialIntersectionRange, thisRangeStarted, lastNum }, num) => {
// Initial iteration only: populate with initial values
if (typeof thisRangeStarted !== 'number') {
return { partialIntersectionRange, thisRangeStarted: num, lastNum: num };
}
// If this element is a continuation of the range from the last element
// then just increment lastNum:
if (lastNum + 1 === num) {
return { partialIntersectionRange, thisRangeStarted, lastNum: num };
}
// This element is not a continuation of the previous range
// so make a range out of [thisRangeStarted, lastNum] and push it to the range array
// (in case thisRangeStarted === lastNum, only push a single value)
if (thisRangeStarted !== lastNum) partialIntersectionRange.push([thisRangeStarted, lastNum]);
else partialIntersectionRange.push([thisRangeStarted]);
return { partialIntersectionRange, thisRangeStarted: num, lastNum: num };
}, { partialIntersectionRange: [] });
if (thisRangeStarted !== lastNum) partialIntersectionRange.push([thisRangeStarted, lastNum]);
else partialIntersectionRange.push([thisRangeStarted]);
console.log(JSON.stringify(partialIntersectionRange));
困难不是交叉逻辑，而是将其格式化为所需的方式。