Update non overlapping interval problem

Author: sudheerj

README.md

@@ -228,11 +228,11 @@ List of Programs related to data structures and algorithms
 
 ### Interval
 
-   1. Insert interval: [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/interval/insertInterval/insertInterval.js) [Playground](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/interval/insertInterval/insertInterval.js) [Documentation](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/interval/insertInterval/insertInterval.md) 
+   1. Insert interval: [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/interval/insertInterval/insertInterval.js) [Playground](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/interval/insertInterval/insertInterval.js) [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/interval/insertInterval/insertInterval.md) 
 
    2. Merge interval: [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/interval/mergeInterval/mergeInterval.js) [Playground](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/interval/mergeInterval/mergeInterval.js) [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/interval/mergeInterval/mergeInterval.md)
 
-   3. Non-overlapping intervals: [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/interval/nonOverlappingIntervals.js)
+   3. Non-overlapping intervals: [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/interval/nonOverlappingIntervals/nonOverlappingIntervals.js) [Playground](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/interval/nonOverlappingIntervals/nonOverlappingIntervals.js) [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/interval/nonOverlappingIntervals/nonOverlappingIntervals.md)
 
    4. Meeting rooms: [JavaScript](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/interval/meetingRooms.js)
 

src/java1/algorithms/interval/NonOverlappingIntervals.java src/java1/algorithms/interval/nonOverlappingIntervals/NonOverlappingIntervals.java

@@ -1,9 +1,9 @@
-package java1.algorithms.interval;
+package java1.algorithms.interval.nonOverlappingIntervals;
 
 import java.util.Arrays;
 
 public class NonOverlappingIntervals {
-    //Greedy approach: TC: O(n logn + n), SC: O(1)
+    //Greedy approach: TC: O(n logn) + O(n), SC: O(1)
     private static int eraseOverlappingIntervals(int[][] intervals) {
         Arrays.sort(intervals, (a, b) -> a[0]-b[0]);
         int minRemove = 0;

src/java1/algorithms/interval/nonOverlappingIntervals/NonOverlappingIntervals.md

@@ -0,0 +1,24 @@
+**Algorithmic Steps**
+This problem is solved with the help of greedy approach. The algorithmic approach can be summarized as follows:
+
+1. First, sort the list of intervals based on their start times. This step helps to keep the overlapping intervals next to each other in the list.
+
+2. Initialize a minimum removal of intervals varaible `minRemove` to 0, which is used to hold the minimum number of intervals to be removed to make non-overlapping intervals. 
+
+3. Initialize previous end value of an interval `prevEnd` with first interval end value. i.e, Here, first interval is considered as non-overlapping interval by default.
+
+4. Iterate through the rest of the intervals, starting from the second interval onwards. For each interval, keep the start(i.e, `start`) and end(i.e, `end`) values for comparing with other intervals.
+
+5. If the start value is greater than the end value of the previous interval, then there is no overlap between the intervals. In this case, you can update the previous end value(`prevEnd`) with the current end value(`end`) of interval.
+
+6. If the start value is less than to end value of the previous interval, then there is overlap between the intervals. In this case, you can increment `minRemove` counter by one. Also, the previous end value needs to be updated by minimum value between previous end value and current value. The intervals with the earliest end times are helpful to minimize the potential overlap with future intervals 
+
+7. Repeat steps 4-5 until all the intervals have been traversed.
+
+8. Return `minRemove` as the minimum number of intervals to be removed to make a non overlapping interval list.
+
+
+**Time and Space complexity:**
+This algorithm has a time complexity of O(n logn) + O(n) ~= O(n), where n is the number of intervals. This is because sort operation typically takes a time complexity of O(n log n) for sorting the list. Thereafter, iteration over the intervals take a time complexity of O(n). So the total time complexity simplifies to O(n log n).
+
+The space complexity of this algorithm is O(1) due to no additional data structure used.

src/javascript/algorithms/interval/nonOverlappingIntervals.js src/javascript/algorithms/interval/nonOverlappingIntervals/nonOverlappingIntervals.js

@@ -1,6 +1,7 @@
-//Greedy approach: TC: O(n logn + n), SC: O(1)
+//Greedy approach: TC: O(n logn) + O(n), SC: O(1)
 
 function eraseOverlappingIntervals(intervals) {
+    intervals.sort((a, b) => a[0]-b[0]);
     let minRemoveCount = 0;
     let prevEnd = intervals[0][1];
 

src/javascript/algorithms/interval/nonOverlappingIntervals/nonOverlappingIntervals.md

@@ -0,0 +1,24 @@
+**Algorithmic Steps**
+This problem is solved with the help of greedy approach. The algorithmic approach can be summarized as follows:
+
+1. First, sort the list of intervals based on their start times. This step helps to keep the overlapping intervals next to each other in the list.
+
+2. Initialize a minimum removal of intervals varaible `minRemove` to 0, which is used to hold the minimum number of intervals to be removed to make non-overlapping intervals. 
+
+3. Initialize previous end value of an interval `prevEnd` with first interval end value. i.e, Here, first interval is considered as non-overlapping interval by default.
+
+4. Iterate through the rest of the intervals, starting from the second interval onwards. For each interval, keep the start(i.e, `start`) and end(i.e, `end`) values for comparing with other intervals.
+
+5. If the start value is greater than the end value of the previous interval, then there is no overlap between the intervals. In this case, you can update the previous end value(`prevEnd`) with the current end value(`end`) of interval.
+
+6. If the start value is less than to end value of the previous interval, then there is overlap between the intervals. In this case, you can increment `minRemove` counter by one. Also, the previous end value needs to be updated by minimum value between previous end value and current value. The intervals with the earliest end times are helpful to minimize the potential overlap with future intervals 
+
+7. Repeat steps 4-5 until all the intervals have been traversed.
+
+8. Return `minRemove` as the minimum number of intervals to be removed to make a non overlapping interval list.
+
+
+**Time and Space complexity:**
+This algorithm has a time complexity of O(n logn) + O(n) ~= O(n), where n is the number of intervals. This is because sort operation typically takes a time complexity of O(n log n) for sorting the list. Thereafter, iteration over the intervals take a time complexity of O(n). So the total time complexity simplifies to O(n log n).
+
+The space complexity of this algorithm is O(1) due to no additional data structure used.