给定N组时间间隔，任务是找到与给定间隔集不重叠的间隔。
例子：
Input: interval arr[] = { {1, 3}, {2, 4}, {3, 5}, {7, 9} }
Output:
[5, 7]
Explanation:
The only interval which doesn’t overlaps with the other intervals is [5, 7].
Input: interval arr[] = { {1, 3}, {9, 12}, {2, 4}, {6, 8} }
Output:
[4, 6]
[8, 9]
Explanation:
There are two intervals which don’t overlap with other intervals are [4, 6], [8, 9].
方法：想法是根据开始时间对给定的时间间隔进行排序，如果连续间隔不重叠，则它们之间的差异就是空闲间隔。
以下是步骤：
- 根据开始时间对给定的一组间隔进行排序。
- 遍历所有区间集并检查连续区间是否重叠。
- 如果间隔（比如间隔 a &间隔 b ）不重叠，那么由[a.end, b.start]形成的对集是非重叠间隔。
- 如果间隔重叠，则检查下一个连续间隔。
下面是上述方法的实现：
C++
// C++ program for the above approach
#include "bits/stdc++.h"
using namespace std;
// interval with start time & end time
struct interval {
int start, end;
};
// Comparator function to sort the given
// interval according to time
bool compareinterval(interval i1, interval i2)
{
return (i1.start < i2.start);
}
// Function that find the free interval
void findFreeinterval(interval arr[], int N)
{
// If there are no set of interval
if (N <= 0) {
return;
}
// To store the set of free interval
vector > P;
// Sort the given interval according
// starting time
sort(arr, arr + N, compareinterval);
// Iterate over all the interval
for (int i = 1; i < N; i++) {
// Previous interval end
int prevEnd = arr[i - 1].end;
// Current interval start
int currStart = arr[i].start;
// If ending index of previous
// is less than starting index
// of current, then it is free
// interval
if (prevEnd < currStart) {
P.push_back({ prevEnd,
currStart });
}
}
// Print the free interval
for (auto& it : P) {
cout << "[" << it.first << ", "
<< it.second << "]" << endl;
}
}
// Driver Code
int main()
{
// Given set of interval
interval arr[] = { { 1, 3 },
{ 2, 4 },
{ 3, 5 },
{ 7, 9 } };
int N = sizeof(arr) / sizeof(arr[0]);
// Function Call
findFreeinterval(arr, N);
return 0;
} Java
// Java program for the above approach
import java.util.*;
class GFG {
// Interval with start time & end time
static class Interval
{
int start, end;
Interval(int start, int end)
{
this.start = start;
this.end = end;
}
}
// Function that find the free interval
static void findFreeinterval(int[][] arr, int N)
{
// If there are no set of interval
if (N <= 0)
{
return;
}
// To store the set of free interval
ArrayList p = new ArrayList<>();
// Sort the given interval according
// starting time
Arrays.sort(arr, new Comparator()
{
public int compare(int[] a, int[] b)
{
return a[0] - b[0];
}
});
// Iterate over all the interval
for (int i = 1; i < N; i++)
{
// Previous interval end
int prevEnd = arr[i - 1][1];
// Current interval start
int currStart = arr[i][0];
// If ending index of previous
// is less than starting index
// of current, then it is free
// interval
if (prevEnd < currStart)
{
Interval interval = new Interval(prevEnd,
currStart);
p.add(interval);
}
}
// Print the free interval
for (int i = 0; i < p.size(); i++)
{
System.out.println("[" + p.get(i).start +
", " + p.get(i).end + "]");
}
}
// Driver code
public static void main(String[] args)
{
// Given set of interval
int[][] arr = { { 1, 3 },
{ 2, 4 },
{ 3, 5 },
{ 7, 9 } };
int N = arr.length;
// Function Call
findFreeinterval(arr, N);
}
}
// This code is contributed by offbeat Python3
# Python3 program for the above approach
def findFreeinterval(arr, N):
# If there are no set of interval
if N < 1:
return
# To store the set of free interval
P = []
# Sort the given interval according
# Starting time
arr.sort(key = lambda a:a[0])
# Iterate over all the interval
for i in range(1, N):
# Previous interval end
prevEnd = arr[i - 1][1]
# Current interval start
currStart = arr[i][0]
# If Previous Interval is less
# than current Interval then we
# store that answer
if prevEnd < currStart:
P.append([prevEnd, currStart])
# Print the intervals
for i in P:
print(i)
# Driver code
if __name__ == "__main__":
# Given List of intervals
arr = [ [ 1, 3 ], [ 2, 4 ],
[ 3, 5 ], [ 7, 9 ] ]
N = len(arr)
# Function call
findFreeinterval(arr, N)
# This code is contributed by Tokir ManvaJavascript
输出：
[5, 7]时间复杂度： O(N*log N) ，其中 N 是间隔集的数量。