# Insert Interval Problem in Java

The Insert Interval problem is a well-known coding problem in which you are given a set of non-overlapping intervals, and a new interval, and your task is to insert the new interval into the set of intervals in a way that ensures the intervals remain non-overlapping. The problem is commonly asked in coding interviews and can be solved using a simple algorithm in Java. Here is one possible solution to the Insert Interval problem in Java:

InsertInterval.java

``````public class InsertInterval {
public int[][] insert(int[][] intervals, int[] newInterval) {
List<int[]> result = new ArrayList<>();
int i = 0;
int n = intervals.length;
// Add all intervals that come before the new interval
while (i < n && intervals[i][1] < newInterval[0]) {
i++;
}
// Merge all intervals that overlap with the new interval
while (i < n && intervals[i][0] <= newInterval[1]) {
newInterval[0] = Math.min(newInterval[0], intervals[i][0]);
newInterval[1] = Math.max(newInterval[1], intervals[i][1]);
i++;
}
while (i < n) {
i++;
}
// Convert the list to an array and return it
return result.toArray(new int[result.size()][2]);
}
}``````

The above code is a Java program that takes in an array of intervals and a new interval and returns a new array of intervals with the new interval merged with any overlapping intervals. To test the program, you can create an instance of the InsertInterval class and call its insert() method with some sample inputs. Here's an example:

``````InsertInterval ii = new InsertInterval();
int[][] intervals = {{1,3}, {6,9}};
int[] newInterval = {2,5};
int[][] result = ii.insert(intervals, newInterval);
for (int[] interval : result) {
System.out.print(Arrays.toString(interval) + " ");
}``````

Output:

`[1, 5] [6, 9],`

The output which is the merged interval.This will insert the new interval into the intervals array and return the result.

The Insert Interval problem requires us to insert a new interval into a given set of non-overlapping intervals, such that the resulting intervals are still non-overlapping. The intervals are represented as a 2D array of integers, where each row represents an interval, and the first and second columns represent the start and end points of the interval, respectively. The algorithm we use to solve the problem is as follows:

• We start by iterating through the intervals array, adding all the intervals that come before the new interval to a result list. We can do this by checking the end point of each interval and comparing it with the start point of the new interval. If the end point is less than the start point, we know that the interval comes before the new interval and we can add it to the result list.
• Next, we iterate through the intervals array again, merging all the intervals that overlap with the new interval. We can do this by checking the start point of each interval and comparing it with the end point of the new interval. If the start point is less than or equal to the end point, we know that the interval overlaps with the new interval, and we update the start and end points of the new interval accordingly.
• Once we have merged all overlapping intervals, we add the new interval to the result list.
• Finally, we iterate through the remaining intervals in the intervals array and add them to the result list.
• We convert the result list to a 2D array and return it.

By using this algorithm, we can insert the new interval into the set of non-overlapping intervals in a way that ensures the intervals remain non-overlapping. The time complexity of this algorithm is O(n), where n is the number of intervals in the given set, and the space complexity is O(n) as well, since we are using a result list to store the intervals. Here's the complete Java code for the solution:

InsertInterval.java

``````public class InsertInterval {
public int[][] insert(int[][] intervals, int[] newInterval) {
List<int[]> result = new ArrayList<>();
int i = 0;
int n = intervals.length;
// Add all intervals that come before the new interval
while (i < n && intervals[i][1] < newInterval[0]) {
i++;
}
// Merge all intervals that overlap with the new interval
while (i < n && intervals[i][0] <= newInterval[1]) {
newInterval[0] = Math.min(newInterval[0], intervals[i][0]);
newInterval[1] = Math.max(newInterval[1], intervals[i][1]);
i++;
}
while (i < n) {
i++;
}
// Convert the list to an array and return it
return result.toArray(new int[result.size()][2]);
}
public static void main(String[] args) {
int[][] intervals = {{1,3},{6,9}};
int[] newInterval = {2,5};
InsertInterval solution = new InsertInterval();
int[][] result = solution.insert(intervals, newInterval);
System.out.println(Arrays.deepToString(result));
}
}
``````

Output:

`[[1, 5], [6, 9]]`

It shows that the new interval {2,5} has been inserted into the intervals array, and the resulting intervals are still non-over

The insert interval problem involves adding a new interval to a list of existing intervals, while ensuring that the resulting intervals do not overlap or have gaps between them. Here is an example problem statement. Given a list of non-overlapping intervals sorted by their start time, insert a new interval into the list and merge any overlapping intervals. To solve this problem in Java, we can use a combination of iteration and conditional logic. Here are the general steps:

• Create a new list to store the merged intervals.
• Iterate over the existing intervals in the list, comparing their end time to the start time of the new interval.
• If the existing interval ends before the start of the new interval, add it to the new list as-is.
• If the existing interval starts after the end of the new interval, add the new interval to the new list and then add the remaining intervals as-is.
• If the existing interval overlaps with the new interval, merge them by updating the end time of the new interval.
• After iterating over all the intervals, add the new interval to the new list if it hasn't already been added.
• Return the new list of merged intervals.

It is just a general outline, and the specific implementation will depend on the details of the problem and the specific requirements of the input and output formats.

• Given a list of non-overlapping intervals sorted by their start time, insert a new interval into the list and merge any overlapping intervals.
• To solve this problem, we can start by creating a new list to store the merged intervals. Then, we can iterate over the existing intervals in the input list, comparing their end time to the start time of the new interval.
• If the existing interval ends before the start of the new interval, we can add it to the new list as-is. If the existing interval starts after the end of the new interval, we can add the new interval to the new list and then add the remaining intervals as-is.
• If the existing interval overlaps with the new interval, we can merge them by updating the end time of the new interval to the maximum of the existing and new intervals' end times. We can continue iterating over the remaining intervals, merging any additional overlaps as we go.
• Finally, after iterating over all the intervals, we can add the new interval to the new list if it hasn't already been added. Then, we can return the new list of merged intervals.
• One of the key advantages of using a list to store the merged intervals is that it allows for dynamic resizing, which is necessary when adding the newInterval and overlapping intervals. If a fixed-size array was used instead, it would require copying the array to a new, larger array each time a new interval needed to be added, which would be less efficient.
• Another advantage of using a list is that it provides a simpler and more intuitive interface for adding and removing elements. The add method is used to add intervals to the list, and the toArray method is used to convert the list to an array. This makes the code more readable and easier to maintain.
• The InsertInterval program could be further optimized by avoiding the use of the Math.min and Math.max methods when updating the newInterval. Instead, separate variables could be used to track the minimum start and maximum end values, and then these values could be used to create the new interval when the overlap check is complete. This would eliminate the need for unnecessary method calls.