Algo steps for merge intervals

Author: sudheerj

README.md

@@ -228,9 +228,9 @@ List of Programs related to data structures and algorithms
 
 ### Interval
 
-   1. Insert interval: [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/interval/insertInterval.js)
+   1. Insert interval: [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/interval/insertInterval.js) 
 
-   2. Merge interval: [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/interval/mergeInterval.js)
+   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)
 

src/java1/algorithms/array/buySellStock/BuySellStock.md

@@ -1,7 +1,7 @@
 **Algorithmic Steps**
 This problem is solved with the help of sliding window approach to calculate the maximum profit(as known as **greedy algorithm**). The algorithmic approach can be summarized as follows:
 
-1. Write a preliminary case by returning profit as `0` if the number of stock prices are less than  2.
+1. Write a preliminary case by returning profit as `0` if the number of stock prices are less than 2.
 
 2. Initialize `maxProfit` variable as 0 to indicate maximum profit for buying and selling the stock at different days. 
 

src/java1/algorithms/interval/MergeInterval.java

@@ -1,4 +1,4 @@
-package java1.algorithms.interval;
+package java1.algorithms.interval.insertInterval;
 import java.util.*;
 
 public class InsertInterval {

src/java1/algorithms/interval/InsertInterval.java src/java1/algorithms/interval/insertInterval/InsertInterval.java

@@ -0,0 +1,32 @@
+package java1.algorithms.interval.mergeInterval;
+
+import java.util.*;
+
+public class MergeInterval {
+    // TC: O(n log n) + O(n) => O(n log n) SC: O(n)
+    private static int[][] mergeInterval(int[][] intervals) {
+        Arrays.sort(intervals, (a, b) -> a[0]-b[0]);
+        ArrayList<int[]> mergedIntervals = new ArrayList<>();
+        mergedIntervals.add(intervals[0]);
+
+        for(int i=1; i< intervals.length; i++) {
+            int[] currInterval = intervals[i];
+            int[] lastMergedInterval = mergedIntervals.get(mergedIntervals.size()-1);
+            if(lastMergedInterval[1] < currInterval[0]) {
+                mergedIntervals.add(currInterval);
+            } else {
+                lastMergedInterval[1] = Math.max(lastMergedInterval[1], currInterval[1]);
+            }
+        }
+
+        return mergedIntervals.toArray(new int[mergedIntervals.size()][]);
+    }
+
+    public static void main(String[] args) {
+        int[][] intervals1 = {{1,3},{2,6},{8,10},{15,18}};
+        int[][] intervals2 = {{1,5},{5,8}};
+
+        System.out.println(Arrays.deepToString(mergeInterval(intervals1)));
+        System.out.println(Arrays.deepToString(mergeInterval(intervals2)));
+    }
+}

src/java1/algorithms/interval/insertInterval/InsertInterval.md

@@ -0,0 +1,22 @@
+**Algorithmic Steps**
+This problem is solved with the help of sorting intervals followed by merging the intervals through iteration. 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 new list `mergedIntervals` to hold the merged intervals and add the first interval to it. 
+
+3. Iterate through the rest of the intervals, starting from the second interval onwards. For each interval, compare its start value with the end value of the last interval in the merged list.
+
+4. If the start value is greater than the end value of the last interval, then there is no overlap between the intervals. In this case, you can add the current interval as a new entry to the merged list.
+
+5. If the start value is less than or equal to the end value of the last interval, then there is overlap between the intervals. In this case, you can update the end value of the last interval in the merged list to the maximum of the end value of the last interval and the start value of current interval. 
+
+6. Repeat steps 3-5 until all the intervals have been traversed.
+
+7. Return `mergedIntervals` as the final merged intervals.
+
+
+**Time and Space complexity:**
+This algorithm has a time complexity of O(n logn) + 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(n) as we need to store a list containing all the merged intervals.

src/java1/algorithms/interval/mergeInterval/MergeInterval.java

@@ -0,0 +1,24 @@
+// TC: O(n log n) + O(n)=> O(n log n) SC: O(n)
+
+function mergeInterval(intervals) {
+    let mergedIntervals = [];
+    intervals.sort((a, b) => a[0]-b[0]);
+    mergedIntervals.push(intervals[0]);
+
+    for(let i=1; i< intervals.length; i++) {
+        let currInterval = intervals[i];
+        let latestMergeInterval = mergedIntervals[mergedIntervals.length-1];
+        if(latestMergeInterval[1] < currInterval[0]) {
+            mergedIntervals.push(currInterval);
+        } else {
+            mergedIntervals[mergedIntervals.length-1][1] = Math.max(latestMergeInterval[1], currInterval[1]);
+        }
+    }
+
+    return mergedIntervals;
+}
+
+let intervals1 = [[1,3],[2,6],[8,10],[15,18]];
+let intervals2 = [[1,5],[5,8]];
+console.log(mergeInterval(intervals1));
+console.log(mergeInterval(intervals2));

src/java1/algorithms/interval/mergeInterval/MergeInterval.md

@@ -0,0 +1,22 @@
+**Algorithmic Steps**
+This problem is solved with the help of sorting intervals followed by merging the intervals through iteration. 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 new list `mergedIntervals` to hold the merged intervals and add the first interval to it. 
+
+3. Iterate through the rest of the intervals, starting from the second interval onwards. For each interval, compare its start value with the end value of the last interval in the merged list.
+
+4. If the start value is greater than the end value of the last interval, then there is no overlap between the intervals. In this case, you can add the current interval as a new entry to the merged list.
+
+5. If the start value is less than or equal to the end value of the last interval, then there is overlap between the intervals. In this case, you can update the end value of the last interval in the merged list to the maximum of the end value of the last interval and the start value of current interval. 
+
+6. Repeat steps 3-5 until all the intervals have been traversed.
+
+7. Return `mergedIntervals` as the final merged intervals.
+
+
+**Time and Space complexity:**
+This algorithm has a time complexity of O(n logn) + 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(n) as we need to store a list containing all the merged intervals.