算法之插入区间

给出一个无重叠的 ，按照区间起始端点排序的区间列表。

在列表中插入一个新的区间，你需要确保列表中的区间仍然有序且不重叠（如果有必要的话，可以合并区间）。

示例 1:

输入: intervals = [[1,3],[6,9]], newInterval = [2,5]
输出: [[1,5],[6,9]]
示例 2:

输入: intervals = [[1,2],[3,5],[6,7],[8,10],[12,16]], newInterval = [4,8]
输出: [[1,2],[3,10],[12,16]]
解释: 这是因为新的区间 [4,8] 与 [3,5],[6,7],[8,10] 重叠。

思路：先找到能合并的位置，不能合并的放到res；然后进行合并；合并完后，将不能合并的加入到res

static public class Interval {
          int start;
          int end;
          Interval() { start = 0; end = 0; }
          Interval(int s, int e) { start = s; end = e; }
      }


    static  class Solution {
        public List<Interval> insert(List<Interval> intervals, Interval newInterval) {
            List<Interval> res=new LinkedList<>();
            if(intervals.size()==0||intervals==null){
                res.add(newInterval);
                return res;
            }



            //解题思路
            //（1）先用while循环换来找到 start 值小于 该区间start的 pre 和 cur （如果能够合并，就必定 是与这两者之一合并
            //（2） 然后用while循环找到不能继续合并的区间

            Interval pre_interval=null;
            Interval cur_interval=null;
            int pos=0;
            //尝试寻找能把 newInterval夹在中间的间隔
            //需要考虑的情况有：  （1）找到了，但pre为null  （2）找到了，能不能跟pre合并   （3）找到了，能不能跟cur合并    （4）找不到
            while (pos<intervals.size()){
                pre_interval=cur_interval;
                cur_interval=intervals.get(pos);

                if(cur_interval.start<=newInterval.start){
                    if(pre_interval!=null){
                        res.add(pre_interval);
                    }

                    pos++;
                }
                else {
                    break;
                }
            }




            //如果一直找不到呢
            if(pos==intervals.size()){
                //看一下最后一个能不能合并
                //如果不能合并

                if(cur_interval.end<newInterval.start){
                    res.add(cur_interval);
                    res.add(newInterval);
                    return res;
                }
                else {
                    newInterval.start=cur_interval.start;
                    newInterval.end=newInterval.end>=cur_interval.end?newInterval.end:cur_interval.end;
                    res.add(newInterval);

                    return res;
                }
            }
            else {

                //如果能够找到
                //先看一下能不能和pre合并,如果能合并就合并了
                if(pre_interval!=null){
                    //如果能合并
                    if(pre_interval.end>=newInterval.start){
                        newInterval.start=pre_interval.start;
                        newInterval.end=newInterval.end>=pre_interval.end?newInterval.end:pre_interval.end;
                    }
                    else {
                        res.add(pre_interval);
                    }

                }

                //然后看一下 呢哇Interval能不能和cur合并  （1）如果不能合并   （2）能够合并，合并一些后就不能合并了    （3）跟剩下所有都能合并
                //找到不能继续合并的位置：
                int flag=0;
                for(int i=pos;i<intervals.size();i++){
                    cur_interval=intervals.get(i);
                    //如果能够合并,已知newInterval的start较小
                    if (flag == 0) {
                        if(newInterval.end>=cur_interval.start){
                            newInterval.end=newInterval.end>=cur_interval.end?newInterval.end:cur_interval.end;
                        }
                        else {
                                res.add(newInterval);
                                res.add(cur_interval);

                                flag=1;
                        }

                    }
                    else {
                        res.add(cur_interval);
                    }
                }
                if(flag==0){
                    res.add(newInterval);
                }
            }

            return res;





        }
    }

class Solution {
        public List<Interval> insert(List<Interval> intervals, Interval newInterval) {
            List<Interval> res = new LinkedList<>();
            if (intervals.size() == 0 || intervals == null) {
                res.add(newInterval);
                return res;
            }
            int len=intervals.size();
            int cur_pos=0;
            Interval cur_interval;

            //将哪些肯定不相交的先放进去
            while (cur_pos<len){
                cur_interval=intervals.get(cur_pos);
                if(cur_interval.end<newInterval.start){
                    //肯定不相交
                    res.add(cur_interval);
                    cur_pos++;
                }
                else {
                    break;
                }
            }

            //合并所有能够合并的  只要能保证 newInterval的end大于等于 cur的start，就一定能相交
            while (cur_pos<len){
                cur_interval=intervals.get(cur_pos);
                if(newInterval.end>=cur_interval.start){
                    newInterval.start=Math.min(newInterval.start,cur_interval.start);
                    newInterval.end=Math.max(newInterval.end,cur_interval.end);
                    cur_pos++;
                }
                else {
                    break;
                }
            }

            res.add(newInterval);
            while (cur_pos<len){
                res.add(intervals.get(cur_pos));
                cur_pos++;
            }

            return res;
        }
    }