**Problem Statement:** Given an array of intervals, merge all the overlapping intervals and return an array of non-overlapping intervals.

**Examples**

Example 1:Input:intervals=[[1,3],[2,6],[8,10],[15,18]]Output:[[1,6],[8,10],[15,18]]Explanation:Since intervals [1,3] and [2,6] are overlapping we can merge them to form [1,6] intervals.Example 2:Input:[[1,4],[4,5]]Output:[[1,5]]Explanation:Since intervals [1,4] and [4,5] are overlapping we can merge them to form [1,5].

**Solution**

** Disclaimer**:

*Don’t jump directly to the solution, try it out yourself first.*

*Problem Link*

*.*

**Solution:**

In this article, in order to understand the concept in a better way, we have assumed the intervals in the form** (start, end)**. The first and second elements of each interval can be assumed as the start and end of that particular interval. We are going to use this convention i.e. the names, start and end, throughout the article.

**Naive Approach (Brute-force)**:

**Approach:**

The steps are as follows:

- First, we will group the closer intervals by sorting the given array of intervals(
*if it is not already sorted*). - After that, we will select one interval at a time using a loop(
) and insert it into our answer list(*say i**if the answer list is empty or the current interval cannot be merged with the last interval of the answer list*). While traversing and inserting we will skip the intervals that lie in the last inserted interval of our answer list. - Now, for each interval arr[i], using another loop (
) we are going to check the rest of the intervals(*say j**i.e. From index i+1 to n-1*) if they can be merged with the selected interval. - Inside loop j, we will continue to merge all the intervals that lie in the selected interval.
**How to check if the current interval can be merged with the selected interval:**We will compare the current interval’s start with the end of the selected interval. If the start is smaller or equal to the end, we can conclude the current interval can be a part of the selected interval. So, we will update the selected interval’s end with thein the answer list(*maximum(current interval’s end, selected interval’s end)**not in the original array*).

- We will break out of loop j, from the first element that cannot be a part of the selected interval.
**How to check if the current interval is not a part of the selected interval:**We will compare the current interval’s start with the end of the selected interval. If the start is greater than the end, we can conclude the current interval cannot be a part of the selected interval.

- Finally, we will return the answer list.

**Intuition: **

The intuition of this approach is pretty straightforward. We are just grouping close intervals by sorting the given array. After that, we merge an interval with the other by checking if one can be a part of the other interval. For this checking, we are first selecting a particular interval using a loop and then we are comparing the rest of the intervals using another loop.

**Note: ***For a better understanding of intuition, please watch the video at the bottom of the page.*

**Code**:

## C++ Code

```
function mergeOverlappingIntervals(arr) {
const n = arr.length; // size of the array
//sort the given intervals:
arr.sort((a, b) => a[0] - b[0]);
const ans = [];
for (let i = 0; i < n; i++) { // select an interval:
let start = arr[i][0];
let end = arr[i][1];
//Skip all the merged intervals:
if (ans.length && end <= ans[ans.length - 1][1]) {
continue;
}
//check the rest of the intervals:
for (let j = i + 1; j < n; j++) {
if (arr[j][0] <= end) {
end = Math.max(end, arr[j][1]);
} else {
break;
}
}
ans.push([start, end]);
}
return ans;
}
const arr = [[1, 3], [8, 10], [2, 6], [15, 18]];
const ans = mergeOverlappingIntervals(arr);
console.log("The merged intervals are:");
for (let it of ans) {
console.log(`[${it[0]}, ${it[1]}]`);
}
```

**Output: **[[1,6],[8,10],[15,18]]

**Time Complexity: **O(N*logN) + O(2*N), where N = the size of the given array.**Reason: **Sorting the given array takes ** **O(N*logN) time complexity. Now, after that, we are using 2 loops i and j. But while using loop i, we skip all the intervals that are merged with loop j. So, we can conclude that every interval is roughly visited twice(roughly, once for checking or skipping and once for merging). So, the time complexity will be 2*N instead of N^{2}.

**Space Complexity: **O(N), as we are using an answer list to store the merged intervals. Except for the answer array, we are not using any extra space.

## Java Code

```
import java.util.*;
public class tUf {
public static List<List<Integer>> mergeOverlappingIntervals(int[][] arr) {
int n = arr.length; // size of the array
//sort the given intervals:
Arrays.sort(arr, new Comparator<int[]>() {
public int compare(int[] a, int[] b) {
return a[0] - b[0];
}
});
List<List<Integer>> ans = new ArrayList<>();
for (int i = 0; i < n; i++) { // select an interval:
int start = arr[i][0];
int end = arr[i][1];
//Skip all the merged intervals:
if (!ans.isEmpty() && end <= ans.get(ans.size() - 1).get(1)) {
continue;
}
//check the rest of the intervals:
for (int j = i + 1; j < n; j++) {
if (arr[j][0] <= end) {
end = Math.max(end, arr[j][1]);
} else {
break;
}
}
ans.add(Arrays.asList(start, end));
}
return ans;
}
public static void main(String[] args) {
int[][] arr = {{1, 3}, {8, 10}, {2, 6}, {15, 18}};
List<List<Integer>> ans = mergeOverlappingIntervals(arr);
System.out.print("The merged intervals are: \n");
for (List<Integer> it : ans) {
System.out.print("[" + it.get(0) + ", " + it.get(1) + "] ");
}
System.out.println();
}
}
```

**Output: **[[1,6],[8,10],[15,18]]

**Time Complexity: **O(N*logN) + O(2*N), where N = the size of the given array.**Reason: **Sorting the given array takes ** **O(N*logN) time complexity. Now, after that, we are using 2 loops i and j. But while using loop i, we skip all the intervals that are merged with loop j. So, we can conclude that every interval is roughly visited twice(roughly, once for checking or skipping and once for merging). So, the time complexity will be 2*N instead of N^{2}.

**Space Complexity: **O(N), as we are using an answer list to store the merged intervals. Except for the answer array, we are not using any extra space.

## Python Code

```
from typing import List
def mergeOverlappingIntervals(arr: List[List[int]]) -> List[List[int]]:
n = len(arr) # size of the array
# sort the given intervals:
arr.sort()
ans = []
for i in range(n): # select an interval:
start, end = arr[i][0], arr[i][1]
# Skip all the merged intervals:
if ans and end <= ans[-1][1]:
continue
# check the rest of the intervals:
for j in range(i + 1, n):
if arr[j][0] <= end:
end = max(end, arr[j][1])
else:
break
ans.append([start, end])
return ans
if __name__ == '__main__':
arr = [[1, 3], [8, 10], [2, 6], [15, 18]]
ans = mergeOverlappingIntervals(arr)
print("The merged intervals are:")
for it in ans:
print(f"[{it[0]}, {it[1]}]", end=" ")
print()
```

**Output: **[[1,6],[8,10],[15,18]]

**Time Complexity: **O(N*logN) + O(2*N), where N = the size of the given array.**Reason: **Sorting the given array takes ** **O(N*logN) time complexity. Now, after that, we are using 2 loops i and j. But while using loop i, we skip all the intervals that are merged with loop j. So, we can conclude that every interval is roughly visited twice(roughly, once for checking or skipping and once for merging). So, the time complexity will be 2*N instead of N^{2}.

**Space Complexity: **O(N), as we are using an answer list to store the merged intervals. Except for the answer array, we are not using any extra space.

## JavaScript

```
function mergeOverlappingIntervals(arr) {
const n = arr.length; // size of the array
//sort the given intervals:
arr.sort((a, b) => a[0] - b[0]);
const ans = [];
for (let i = 0; i < n; i++) { // select an interval:
let start = arr[i][0];
let end = arr[i][1];
//Skip all the merged intervals:
if (ans.length && end <= ans[ans.length - 1][1]) {
continue;
}
//check the rest of the intervals:
for (let j = i + 1; j < n; j++) {
if (arr[j][0] <= end) {
end = Math.max(end, arr[j][1]);
} else {
break;
}
}
ans.push([start, end]);
}
return ans;
}
const arr = [[1, 3], [8, 10], [2, 6], [15, 18]];
const ans = mergeOverlappingIntervals(arr);
console.log("The merged intervals are:");
for (let it of ans) {
console.log(`[${it[0]}, ${it[1]}]`);
}
```

**Output: **[[1,6],[8,10],[15,18]]

**Time Complexity: **O(N*logN) + O(2*N), where N = the size of the given array.**Reason: **Sorting the given array takes ** **O(N*logN) time complexity. Now, after that, we are using 2 loops i and j. But while using loop i, we skip all the intervals that are merged with loop j. So, we can conclude that every interval is roughly visited twice(roughly, once for checking or skipping and once for merging). So, the time complexity will be 2*N instead of N^{2}.

**Space Complexity: **O(N), as we are using an answer list to store the merged intervals. Except for the answer array, we are not using any extra space.

**Optimal Approach**:

**Intuition: **

In the previous approach, while checking the intervals, we first selected an interval using a loop and then compared it with others using another loop. But in this approach, we will try to do the same using a single loop. Let’s understand how:

We will start traversing the given array with a single loop. At the first index, as our answer list is empty, we will insert the first element into the answer list. While traversing afterward we can find two different cases:

**Case 1: If the current interval can be merged with the last inserted interval of the answer list:**In this case, we will update the end of the last inserted interval with the

**and continue moving afterward**

*maximum(current interval’s end, last inserted interval’s end)*

*.***Case 2: If the current interval cannot be merged with the last inserted interval of the answer list:**In this case, we will insert the current interval in the answer array as it is. And after this insertion, the last inserted interval of the answer list will obviously be updated to the current interval.

**Note:** *Within the previous approach,** **we have already discussed* *how to check if the current interval can or cannot be merged with the other interval*.

**Approach:**

The steps are as follows:

- First, we will group the closer intervals by sorting the given array of intervals(
*if it is not already sorted*). - After that, we will start traversing the array using a loop(
) and insert the first element into our answer list(*say i**as the answer list is empty*). - Now, while traversing we will face two different cases:
**Case 1: If the current interval can be merged with the last inserted interval of the answer list:**In this case, we will update the end of the last inserted interval with theand continue moving afterward*maximum(current interval’s end, last inserted interval’s end)**.***Case 2: If the current interval cannot be merged with the last inserted interval of the answer list:**In this case, we will insert the current interval in the answer array as it is. And after this insertion, the last inserted interval of the answer list will obviously be updated to the current interval.

- Thus the answer list will be updated with the merged intervals and finally, we will return the answer list.

**Intuition: **Since we have sorted the intervals, the intervals which will be merging are bound to be adjacent. We kept on merging simultaneously as we were traversing through the array and when the element was non-overlapping we simply inserted the element in our answer list.

**Dry Run:**

This dry run will further simplify the concept:

The selected interval at each step is marked with yellow.

**Note: ***For a better understanding of intuition, please watch the video at the bottom of the page.*

**Code**:

## C++ Code

```
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> mergeOverlappingIntervals(vector<vector<int>> &arr) {
int n = arr.size(); // size of the array
//sort the given intervals:
sort(arr.begin(), arr.end());
vector<vector<int>> ans;
for (int i = 0; i < n; i++) {
// if the current interval does not
// lie in the last interval:
if (ans.empty() || arr[i][0] > ans.back()[1]) {
ans.push_back(arr[i]);
}
// if the current interval
// lies in the last interval:
else {
ans.back()[1] = max(ans.back()[1], arr[i][1]);
}
}
return ans;
}
int main()
{
vector<vector<int>> arr = {{1, 3}, {8, 10}, {2, 6}, {15, 18}};
vector<vector<int>> ans = mergeOverlappingIntervals(arr);
cout << "The merged intervals are: " << "\n";
for (auto it : ans) {
cout << "[" << it[0] << ", " << it[1] << "] ";
}
cout << endl;
return 0;
}
```

**Output: **[[1,6],[8,10],[15,18]]

**Time Complexity: **O(N*logN) + O(N), where N = the size of the given array.**Reason: **Sorting the given array takes ** **O(N*logN) time complexity. Now, after that, we are just using a single loop that runs for N times. So, the time complexity will be O(N).

**Space Complexity: **O(N), as we are using an answer list to store the merged intervals. Except for the answer array, we are not using any extra space.

## Java Code

```
import java.util.*;
public class Main {
public static List<List<Integer>> mergeOverlappingIntervals(int[][] arr) {
int n = arr.length; // size of the array
//sort the given intervals:
Arrays.sort(arr, new Comparator<int[]>() {
public int compare(int[] a, int[] b) {
return a[0] - b[0];
}
});
List<List<Integer>> ans = new ArrayList<>();
for (int i = 0; i < n; i++) {
// if the current interval does not
// lie in the last interval:
if (ans.isEmpty() || arr[i][0] > ans.get(ans.size() - 1).get(1)) {
ans.add(Arrays.asList(arr[i][0], arr[i][1]));
}
// if the current interval
// lies in the last interval:
else {
ans.get(ans.size() - 1).set(1,
Math.max(ans.get(ans.size() - 1).get(1), arr[i][1]));
}
}
return ans;
}
public static void main(String[] args) {
int[][] arr = {{1, 3}, {8, 10}, {2, 6}, {15, 18}};
List<List<Integer>> ans = mergeOverlappingIntervals(arr);
System.out.print("The merged intervals are: \n");
for (List<Integer> it : ans) {
System.out.print("[" + it.get(0) + ", " + it.get(1) + "] ");
}
System.out.println();
}
}
```

**Output: **[[1,6],[8,10],[15,18]]

**Time Complexity: **O(N*logN) + O(N), where N = the size of the given array.**Reason: **Sorting the given array takes ** **O(N*logN) time complexity. Now, after that, we are just using a single loop that runs for N times. So, the time complexity will be O(N).

**Space Complexity: **O(N), as we are using an answer list to store the merged intervals. Except for the answer array, we are not using any extra space.

## Python Code

```
from typing import List
def mergeOverlappingIntervals(arr: List[List[int]]) -> List[List[int]]:
n = len(arr) # size of the array
# sort the given intervals:
arr.sort()
ans = []
for i in range(n):
# if the current interval does not
# lie in the last interval:
if not ans or arr[i][0] > ans[-1][1]:
ans.append(arr[i])
# if the current interval
# lies in the last interval:
else:
ans[-1][1] = max(ans[-1][1], arr[i][1])
return ans
if __name__ == '__main__':
arr = [[1, 3], [8, 10], [2, 6], [15, 18]]
ans = mergeOverlappingIntervals(arr)
print("The merged intervals are:")
for it in ans:
print(f"[{it[0]}, {it[1]}]", end=" ")
print()
```

**Output: **[[1,6],[8,10],[15,18]]

**Time Complexity: **O(N*logN) + O(N), where N = the size of the given array.**Reason: **Sorting the given array takes ** **O(N*logN) time complexity. Now, after that, we are just using a single loop that runs for N times. So, the time complexity will be O(N).

**Space Complexity: **O(N), as we are using an answer list to store the merged intervals. Except for the answer array, we are not using any extra space.

## JavaScript

```
function mergeOverlappingIntervals(arr) {
const n = arr.length;
// sort the given intervals
arr.sort((a, b) => a[0] - b[0]);
const ans = [arr[0]];
for (let i = 1; i < n; i++) {
const last = ans[ans.length - 1];
const curr = arr[i];
// if the current interval overlaps with the last interval
if (curr[0] <= last[1]) {
last[1] = Math.max(last[1], curr[1]);
}
// if the current interval does not overlap with the last interval
else {
ans.push(curr);
}
}
return ans;
}
const arr = [[1, 3], [8, 10], [2, 6], [15, 18]];
const ans = mergeOverlappingIntervals(arr);
console.log("The merged intervals are:");
for (let it of ans) {
console.log(`[${it[0]}, ${it[1]}]`);
}
```

**Output: **[[1,6],[8,10],[15,18]]

**Time Complexity: **O(N*logN) + O(N), where N = the size of the given array.**Reason: **Sorting the given array takes ** **O(N*logN) time complexity. Now, after that, we are just using a single loop that runs for N times. So, the time complexity will be O(N).

**Space Complexity: **O(N), as we are using an answer list to store the merged intervals. Except for the answer array, we are not using any extra space.

Special thanks toPranav Padawe,Sudip GhoshandKRITIDIPTA GHOSHfor contributing to this article on takeUforward. If you also wish to share your knowledge with the takeUforward fam,please check out this article