合并区间+旋转矩阵

本题源自leetcode

合并区间

给出一个区间的集合，请合并所有重叠的区间。

示例 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] 可被视为重叠区间。

public int[][] merge(int[][] intervals) {
        if(intervals.length==0){//如果传过来的数组为空，返回一个1*2空的元素为0二维数组。
            return new int[1][2];
        };
        //自己写一个比较器，实现compare(T o1, T o2)方法,设定排序规则对指定对象数组进行排序;
        //随时intervals是个二维数组，但 Comparator<>内部的数据类型是int[],而不是int[][];
        //a为第一个参数，b为第二个参数，如果return a-b,则升序排序；
        //a为第一个参数，b为第二个参数，如果return b-a,则降序排序；
        Arrays.sort(intervals,new Comparator<int[]>(){
            public int compare(int[] i1,int[] i2){
                 return i1[0]-i2[0];
            };
        });
        //创建一个长度可变的数组；List<E> list = new ArrayList<E>; 
        //  E      get(int index) 返回此列表中指定位置上的元素。 
        // int     size()   返回此列表中的元素数。
        // void    add(int index, E element) 将指定的元素插入此列表中的指定位置。 
        //Object[] toArray()  按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组。 
        List<int[]> merged = new ArrayList<int[]>();
        merged.add(intervals[0]);
        for(int i=1;i<intervals.length;i++){
            int L = intervals[i][0];
            int R = intervals[i][1];
            if(merged.get(merged.size()-1)[1]>=L){
                merged.get(merged.size()-1)[1]=Math.max(merged.get(merged.size()-1)[1],R);
            }
            else{
                merged.add(intervals[i]);
            } 
        }
        return merged.toArray(new int[merged.size()][]);
    }

旋转矩阵

给你一幅由 N × N 矩阵表示的图像，其中每个像素的大小为 4 字节。请你设计一种算法，将图像旋转 90 度。

示例1
给定 matrix =
[
[1,2,3],
[4,5,6],
[7,8,9]
],
原地旋转输入矩阵，使其变为:
[
[7,4,1],
[8,5,2],
[9,6,3]
]
示例2
给定 matrix =
[
[ 5, 1, 9,11],
[ 2, 4, 8,10],
[13, 3, 6, 7],
[15,14,12,16]
],
原地旋转输入矩阵，使其变为:
[
[15,13, 2, 5],
[14, 3, 4, 1],
[12, 6, 8, 9],
[16, 7,10,11]
]

画出矩阵及其旋转矩阵，寻找规律：

matrix=

	0	1	2
0	1（0，0）	2 （0，1）	3（0，2）
1	4（1，0）	5（1，1）	6 （1，2）
2	7（2，0）	8（2，1）	9 （2，2）

result=

	0	1	2
0	7（0，0）	4 （0，1）	1（0，2）
1	8（1，0）	5（1，1）	2 （1，2）
2	9（2，0）	6（2，1）	3 （2，2）

发现result[i][j]=matrix[j][n-1-i];

public void rotate(int[][] matrix) {
        int length = matrix.length;
        int[][] result = new int[length][length];
        for(int i=0;i<matrix.length;i++){
            for(int j=0;j<matrix[i].length;j++){
                result[i][j]=matrix[length-1-j][i];
            }
        }
        for(int i=0;i<result.length;i++){
            for(int j=0;j<result[i].length;j++){
                matrix[i][j] = result[i][j];
            }
        }
    }

不占用额外内存空间能否做到？