力扣第57题 困难难度 插入区间。暴力解法 考虑所有的情况，180行代码。做出来就和没做出来一球样，重点标记，以后重做！

题目：

暴力解法代码，考虑所有情况：

public int[][] insert(int[][] intervals, int[] newInterval) {
        if(intervals.length==0){
            int[][]res = new int[1][2];
            res[0][0]=newInterval[0];
            res[0][1]=newInterval[1];
            return res;
        }
            
        int intervalsCount = 0; //将把原有的这么多个区间合并为1个区间
        //找到合并后区间的left,刚好小于等于newInterval[0]的数
        int left=0,right = 0;
        int i = 0,j = 0;
        for(i = 0 ; i < intervals.length ; i++){
            if(intervals[i][0] > newInterval[0]){
                left = i;
                break;
            }
        }
        left--;
        
        if(left<-1)
            left=-1;
        else if(left==-1)
            left=0;
        if (intervals[left][1] < newInterval[0])
            left++;
        if(i == intervals.length){
            if(newInterval[0]>intervals[i-1][1]){
                int[][]res = new int[intervals.length+1][2];
                for(int k = 0 ; k < intervals.length ; k++){
                    res[k][0]=intervals[k][0];
                    res[k][1]=intervals[k][1];
                }
                res[intervals.length][0]=newInterval[0];
                res[intervals.length][1]=newInterval[1];
                return res;
            }
            left = i-1;
            
        }
        //找到合并后区间的right，刚好大于等于newInterval[1]的数
        for(j = left ; j < intervals.length ; j++){
            intervalsCount++;
            if(intervals[j][1] == newInterval[1]){
                right = j;
                break;
            }
            else if(intervals[j][1] > newInterval[1]){
                right = j-1;
                intervalsCount--;
                if(right<left){
                    if (newInterval[1] < intervals[left][0]) {
                        left = -1;
                        break;
                    }
                    right=left;
                    intervalsCount=1;
                    break;
                }
                //再判断一下j指向的第一个数是不是正好大于等于newInterval[1]
                if(newInterval[1]>=intervals[j][0]){
                    right++;
                    intervalsCount++;
                }
                break;
            }
        }
        if(j==intervals.length){
            if(newInterval[1]>=intervals[intervals.length-1][0])
                right = intervals.length-1;
            else
                right = -1;
        }
        //开始构造返回的数组
        if(left==-1){
            int[][]res = new int[intervals.length+1][2];
            res[0][0]=newInterval[0];
            res[0][1]=newInterval[1];
            for(int k = 0,l=1 ; k < intervals.length ; k++,l++){
                res[l][0]=intervals[k][0];
                res[l][1]=intervals[k][1];
            }
            res = merge(res);
            return res;
        }
        if(right==-1){
            int[][]res = new int[left+1][2];
            for(int k = 0 ; k < left ; k++){
                res[k][0]=intervals[k][0];
                res[k][1]=intervals[k][1];
            }
            res[left][0]=intervals[left][0];
            res[left][1]=newInterval[1];
            return res;
        }
        int[][]res = new int[intervals.length-intervalsCount+1][2];
        for(int k = 0 ; k < left ; k++){
            res[k][0]=intervals[k][0];
            res[k][1]=intervals[k][1];
        }
        res[left][0] = intervals[left][0] < newInterval[0] ? intervals[left][0] : newInterval[0];
        res[left][1]=newInterval[1]>intervals[right][1]?newInterval[1]:intervals[right][1];
        for(int k = left+1,l=right+1 ; l<intervals.length;l++,k++){
            res[k][0]=intervals[l][0];
            res[k][1]=intervals[l][1];
        }
        return res;
    }


    //第56题的合并区间
    public int[][] merge(int[][] intervals) {
        //0和1，则返回自身
        if (intervals.length<=1)
            return intervals;
        //先排序
        Map<Integer, Integer> map = new TreeMap<Integer, Integer>();
        for (int i = 0; i < intervals.length; i++) {
            //注意 TreeMap只允许相同的key只有一个，因此如果新的key对应的value大，则更新，否则不更新
            if(map.containsKey(intervals[i][0])&&intervals[i][1]<map.get(intervals[i][0]))
                continue;
            map.put(intervals[i][0], intervals[i][1]);
        }
        //使用set的迭代器来遍历map
        Set<Integer> keySet = map.keySet();
        Iterator<Integer> iterator = keySet.iterator();
        int i = 0;
        while (iterator.hasNext()) {
            intervals[i][0] = iterator.next();
            intervals[i][1] = map.get(intervals[i][0]);
            i++;
        }
        //开始合并区间
        List<Integer[]> list = new ArrayList<>();
        i = 0;
        while (i < intervals.length-1) {
            if(intervals[i][1]>=intervals[i+1][0]){
                Integer[] arr = new Integer[2];
                arr[0]=intervals[i][0];
                int max = intervals[i+1][1]>intervals[i][1]?intervals[i+1][1]:intervals[i][1];
                arr[1]= max;
                i++;
                while (i < intervals.length-1 && max>=intervals[i+1][0]){
                    arr[1]=intervals[i+1][1]>arr[1]?intervals[i+1][1]:arr[1];
                    i++;
                    //更新max
                    max = arr[1];
                }
                list.add(arr);
                i++;
            }
            else {
                list.add(new Integer[]{intervals[i][0],intervals[i][1]});
                i++;
            }
        }
        //最后看一下intervals[intervals.length-1][1]这个数是不是大于list中最后一个数组的第二个数，如果大于的话，则加入
        if(list.get(list.size()-1)[1] < intervals[intervals.length-1][1]){
            list.add(new Integer[]{intervals[intervals.length-1][0], intervals[intervals.length-1][1]});
        }

        int[][] resArr = new int[list.size()][2];
        for(i=0;i<list.size();i++){
            resArr[i][0]=list.get(i)[0];
            resArr[i][1]=list.get(i)[1];
        }
        return resArr;
    }