【算法设计与分析】合并区间

本文介绍: 在这个例子中，贪心思想体现在按照区间的起始值进行排序，并在遍历过程中合并重叠的区间。通过一次排序和一次线性遍历，我们就能够完成区间的合并，而不需要复杂的数据结构或算法。具体来说，通过将区间按照起始值升序排序，我们确保了在遍历时，当前区间与之前已合并的区间有序。如果有重叠，则检查当前区间的结束值是否大于上一个合并区间的结束值。如果当前区间与上一个合并区间没有重叠，将其添加到列表中。一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间。将当前区间的起始值与上一个合并区间的结束值（空间复杂度：O(log⁡n)

示例 1：

输入：intervals = [[1,3],[2,6],[8,10],[15,18]]
输出：[[1,6],[8,10],[15,18]]
解释：区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].

示例 2：

输入：intervals = [[1,4],[4,5]]
输出：[[1,5]]
解释：区间 [1,4] 和 [4,5] 可被视为重叠区间。

区间合并的贪心思想。贪心算法的基本思想是每一步都选择当前状态下最优的解，而不考虑全局最优解。在这个例子中，贪心思想体现在按照区间的起始值进行排序，并在遍历过程中合并重叠的区间。

具体来说，通过将区间按照起始值升序排序，我们确保了在遍历时，当前区间与之前已合并的区间有序。然后，通过比较当前区间的起始值和上一个合并区间的结束值，我们可以确定是否需要合并这两个区间。

这种贪心策略的优势在于它的简单性和高效性。通过一次排序和一次线性遍历，我们就能够完成区间的合并，而不需要复杂的数据结构或算法。当然，这种方法前提是输入的区间是无重叠的。

class Solution {
    public int[][] merge(int[][] intervals) {
            Arrays.sort(intervals,(a, b)->a[0]-b[0]);
            int[] last; 
            List<int[]> list=new ArrayList();
            int row=intervals.length;
            int col=intervals[0].length;
            if(intervals.length<=1){
                return intervals;
            }
             list.add(intervals[0]);
             last=intervals[0];
            for(int i=1;i<row;i++){
                //现在的第一位 与 list中最后一个第二位 比较 》0说明5 4
               int temp= intervals[i][0]-last[1];

              if(temp>0){
                  list.add(intervals[i]);
                  last=intervals[i];
              }else{
                  
                  if(last[1]>intervals[i][1]){
                     continue;
                  }else{
                       list.remove(last);
                       int[] arr= new int[2];
                      arr[0]=last[0];
                      arr[1]=intervals[i][1];
                      list.add(arr);
                       last=arr;

                  }

              }
            }
              return list.toArray(new int[list.size()][2]);
    }
}

时间复杂度：O(nlog⁡n)