牛客网刷题之数组（回形插入数组、合并重复区间）

题目一描述：
给定一个整数n，将数字1到n^2n
2
按螺旋的顺序填入n×n的矩阵
例如：
给出的n=3，
你应该返回如下矩阵：

[↵ [ 1, 2, 3 ],↵ [ 8, 9, 4 ],↵ [ 7, 6, 5 ]↵]

题目一分析：
相当于之前的回形打印数组，需要使用四个指针，来表示上下左右四个边界，按照规则向中间压缩。
代码如下：

public class Solution {
    public int[][] generateMatrix(int n) {
     int[][] arr = new int[n][n];
	        int tmp = 1;//当前要插入的数字
	        int left = 0;//左边界
	        int right = n-1;//右边界
	        int top = 0;//上边界
	        int bottom = n-1;//下边界
	        while(tmp <= (n*n)) {
	        //从左向右开始插入
	        	for(int j = left;j <= right;j++) arr[top][j] = tmp++;
	        	top++;//上边界向下移动一个位置
	        	//从上往下移动
				for(int i = top;i <= bottom;i++) arr[i][right] = tmp++;
				right--;//右边界向左移动一个位置
				//从右往左移动
				for(int j = right;j >= left;j--) arr[bottom][j] = tmp++;
				bottom--;//下边界向上移动一个位置
				//从下往上移动
				for(int i = bottom;i >= top;i--)arr[i][left] = tmp++;
				left++;//做边界往右移动一个位置
	        }
	        return arr;
    }

}

题目二描述：
给出一组区间，请合并所有重叠的区间。
例如，
给出[1,3],[2,6],[8,10],[15,18],
返回[1,6],[8,10],[15,18].
题目二分析：
需要将所有的区间进行两两之间进行比较，这样的时间复杂度较高，因此，要采用将区间先按照起点进行排序，再进行比较。这样做的好处是：如果当前的区间与下一个区间不能进行合并，那么其与之后的所有区间均不能合并，无需再比较。
代码如下：

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
/**
 * Definition for an interval.
 * public class Interval {
 *     int start;
 *     int end;
 *     Interval() { start = 0; end = 0; }
 *     Interval(int s, int e) { start = s; end = e; }
 * }
 */
public class Solution {
    public ArrayList<Interval> merge(ArrayList<Interval> intervals) {
        ArrayList<Interval> resinterval = new ArrayList<Interval>();
		if(intervals == null||intervals.size()==0)return resinterval;
		//将区间进行排序
		intervals = sort(intervals);
		Interval tmp = intervals.get(0);
		for(int i = 1;i <= intervals.size();i++) {
			if(i == intervals.size()) {//最后一个区间无需比较直接加入
				resinterval.add(tmp);
			}else if(tmp.end < intervals.get(i).start) {//当前元素与后边的元素集合不能融合,将其加入并使得tmp指向当前的区间
				resinterval.add(tmp);
				tmp = intervals.get(i);
			}else{//能够合并的区间
				tmp = merge(tmp,intervals.get(i));
			}
		}
	     return resinterval;
    }
    
    //集合排序
	public  ArrayList<Interval> sort(ArrayList<Interval> intervals) {
	//		Collections.sort(intervals, new Comparator<Interval>() {
//
//			@Override
//			public int compare(Interval o1, Interval o2) {
//				return o1.start-o2.start;
//			}
//		});
	//lambda表达式，使用集合工具类进行比较区间的起始值（一行代码代替以上好几行！！！）
        Collections.sort(intervals, (o1,o2)->{return o1.start-o2.start;});
		return intervals;
	}
	//合并两个区间，两个区间之间有重复元素
	public  Interval merge(Interval inter1,Interval inter2) {
		if(inter1.start >= inter2.start && inter1.end >= inter2.end) {
			return  new Interval(inter2.start,inter1.end);
		}else if(inter1.start <= inter2.start && inter1.end >= inter2.end) {
			return inter1;
		}else  if(inter1.start <= inter2.start && inter1.end <= inter2.end){
			return new Interval(inter1.start,inter2.end);
		}else {
			return inter2;
		}
	}
}