如何查找其他重叠数字范围之间的空闲数字范围

Question

I have n Arrays. Each array have m elements. Each element m consist of two attributes [numbers].

{
  start: x
  end: y
}

A start- and a end-number, both together describe a range. So start is every time smaller than end. I try to find the free number ranges (again with start and end), they are between the range elements in all arrays. Additional the result is bounded in an range.

For example:

var boundary = {
    start: 0,
    end: 600
};

// for example i use two arrays with ranges, but in reality they are n (>= 1)
var numbersRanges1 = [
    {start: 100, end: 120},
    {start: 180, end: 200},
    {start: 400, end: 500}
];

var numbersRanges2 = [
    {start: 10, end: 80},
    {start: 150, end: 220},
    {start: 480, end: 500}
];

// result should look like
var expected = [
    {start: 0, end: 10},
    {start: 80, end: 100},
    {start: 120, end: 150},
    {start: 220, end: 400},
    {start: 500, end: 600}
];

That is my working solution at the moment ( JS Bin )

var boundary = {
    start: 0,
    end: 600
};

// for example i use two arrays with ranges, but in reality they are n (>= 1)
var numbersRanges1 = [
    {start: 100, end: 120},
    {start: 180, end: 200},
    {start: 400, end: 500}
];

var numbersRanges2 = [
    {start: 10, end: 80},
    {start: 150, end: 220},
    {start: 480, end: 500}
];

// result should look like
var expected = [
    {start: 0, end: 10},
    {start: 80, end: 100},
    {start: 120, end: 150},
    {start: 220, end: 400},
    {start: 500, end: 600}
];

// merge arrays
var mergedRanges = numbersRanges1.concat(numbersRanges2);


// sort by start
function sortByStart(a, b){
    return a.start - b.start;
}

mergedRanges = mergedRanges.sort(sortByStart);

// group overlapping ranges
for(var i = 1; i < mergedRanges.length; i++){
    var range1 = mergedRanges[i-1];
    var range2 = mergedRanges[i];

    if((range1.start <= range2.end) && (range1.end >= range2.start)){
        range2.start = Math.min(range1.start, range2.start);
        range2.end = Math.max(range1.end, range2.end);
        mergedRanges.splice(i-1, 1);
    }
}

// go throw merged ranges and save ranges between in addition array
var freeRanges = [];

if(mergedRanges[0].start > boundary.start){
    freeRanges.push({
        start: boundary.start,
        end: mergedRanges[0].start
    });
}

for(var i = 1, mergedLen = mergedRanges.length; i <  mergedLen; i++){
    freeRanges.push({
        start: mergedRanges[i-1].end,
        end: mergedRanges[i].start
    });
}

if(mergedRanges[mergedLen-1].end < boundary.end){
    freeRanges.push({
        start: mergedRanges[mergedLen-1].end,
        end: boundary.end
    });
}

console.log(freeRanges);
console.log(expected);

The script run on a node.js server. Because we do a lot of concurrent calculation like these, i try to find an resource-efficient and performant algorithm for that. Is there a better way to achieve that? Are they any pitfalls in my code, that we lead to performance issues?

Answer 1

Here's a simplified version for you.

// for example i use two arrays with ranges, but in reality they are n (>= 1)
var numbersRanges1 = [
    {start: 100, end: 120},
    {start: 180, end: 200},
    {start: 400, end: 500}
];

var numbersRanges2 = [
    {start: 10, end: 80},
    {start: 150, end: 220},
    {start: 480, end: 500}
];

var boundary = {
    start: 0,
    end: 600
};

// merge arrays
var mergedRanges = numbersRanges1.concat(numbersRanges2);

// sort by start
function sortByStart(a, b){
    return a.start - b.start;
}

mergedRanges = mergedRanges.sort(sortByStart);

// go throw merged ranges and save ranges between in addition array
var freeRanges = [];

var start=0;
mergedRanges.forEach(function(one) {
  if(one.start<start) return;
  freeRanges.push({start:start,end:one.start});
  start=one.end;
});

if(start<boundary.end) {
  freeRanges.push({start:start,end:boundary.end});
}

console.log(JSON.stringify(freeRanges,null,2));