# Insert Interval Leetcode Solution

In this post, we are going to solve the Insert Interval Leetcode Solution problem of Leetcode. This Leetcode problem is done in many programming languages like C++, Java, and Python.

## Problem

You are given an array of nonoverlapping intervals `intervals` where `intervals[i] = [starti, endi]` represent the start and the end of the `ith` interval and `intervals` is sorted in ascending order by `starti`. You are also given an interval `newInterval = [start, end]` that represents the start and end of another interval.

Insert `newInterval` into `intervals` such that `intervals` is still sorted in ascending order by `starti` and `intervals` still does not have any overlapping intervals (merge overlapping intervals if necessary).

Return `intervals` after the insertion.

Example 1:

```Input: intervals = [[1,3],[6,9]], newInterval = [2,5]
Output: [[1,5],[6,9]]
```

Example 2:

```Input: intervals = [[1,2],[3,5],[6,7],[8,10],[12,16]], newInterval = [4,8]
Output: [[1,2],[3,10],[12,16]]
Explanation: Because the new interval [4,8] overlaps with [3,5],[6,7],[8,10].
```

Constraints:

• `0 <= intervals.length <= 104`
• `intervals[i].length == 2`
• `0 <= starti <= endi <= 105`
• `intervals` is sorted by `starti` in ascending order.
• `newInterval.length == 2`
• `0 <= start <= end <= 105`

Now, lets see the leetcode solution of Insert Interval Leetcode Solution.

### Insert Interval Leetcode Solution in Python

```class Solution:
def insert(self, intervals: List[List[int]], newInterval: List[int]) -> List[List[int]]:
n = len(intervals)
ans = []
i = 0

while i < n and intervals[i][1] < newInterval[0]:
ans.append(intervals[i])
i += 1

while i < n and intervals[i][0] <= newInterval[1]:
newInterval[0] = min(newInterval[0], intervals[i][0])
newInterval[1] = max(newInterval[1], intervals[i][1])
i += 1

ans.append(newInterval)

while i < n:
ans.append(intervals[i])
i += 1

return ans
```

### Insert Interval Leetcode Solutionin CPP

```class Solution {
public:
vector<vector<int>> insert(vector<vector<int>>& intervals,
vector<int>& newInterval) {
const int n = intervals.size();
vector<vector<int>> ans;
int i = 0;

while (i < n && intervals[i][1] < newInterval[0])
ans.push_back(intervals[i++]);

// Merge overlapping intervals
while (i < n && intervals[i][0] <= newInterval[1]) {
newInterval[0] = min(newInterval[0], intervals[i][0]);
newInterval[1] = max(newInterval[1], intervals[i][1]);
++i;
}

ans.push_back(newInterval);

while (i < n)
ans.push_back(intervals[i++]);

return ans;
}
};
```

### Insert Interval Leetcode Solution in Java

```class Solution {
public int[][] insert(int[][] intervals, int[] newInterval) {
final int n = intervals.length;
List<int[]> ans = new ArrayList<>();
int i = 0;

while (i < n && intervals[i][1] < newInterval[0])

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