在给定间隔中找到不重叠的间隔

给定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].

方法：想法是根据开始时间对给定的时间间隔进行排序，如果连续的时间间隔不重叠，则它们之间的差就是自由时间间隔。
步骤如下：

1. 根据开始时间对给定的时间间隔集进行排序。
2. 遍历所有间隔集，并检查连续的间隔是否重叠。
3. 如果时间间隔(例如，时间间隔a和时间间隔b )不重叠，则由[a.end，b.start]组成的对对是不重叠的时间间隔。
4. 如果间隔重叠，则检查下一个连续间隔。

下面是上述方法的实现：

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;
}

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 Manva

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

输出：

[5, 7]

时间复杂度： O(N * log N) ，其中N是间隔集的数量。