螺旋矩阵总结

1.螺旋矩阵

总体思路：坚持循环不变量原则，同二分法。
因为在循环中，有许多边界条件，一定要按固定的规则来遍历。

2.例题

2.1 螺旋矩阵 II

注意：上层和右层的边界条件，本人第一次就没有注意到这个细节，导致改了半天。
偏移量这一值的设定。

螺旋矩阵

class Solution {
    //我们严格按照左闭又开的原则进行分组
    //上层：从左向右
    //右层：从上到下
    //下层：从右向左
    //左层：从下到上
    public int[][] generateMatrix(int n) {
        int mid = n/2;//用来确定n为奇数时，中间点的位置
        int[][] ans = new int [n][n];
        int startX=0;//行,起始位置
        int startY=0;//列，起始位置
        int count = n/2;//循环的次数
        int res = 1;//叠加的值
        int offset = 1;//偏移量

        while(count>0){
            int i =startX;
            int j = startY;

            //上层,i不变，j改变
            for(;j<n+startY-offset;j++){
                ans[i][j]=res;
                res++;
            }
            //右层，j不变，i改变
            for(;i<n+startX-offset;i++){
                ans[i][j]=res;
                res++;
            }
            //下层，i不变，j改变
            for(;j>startY;j--){
                ans[i][j]=res;
                res++;
            }
            //左层：j不变，i改变
            for(;i>startX;i--){//这里是值减小，i较大
                ans[i][j]=res;
                res++;
            }
            count--;//循环次数减一
            startX++;
            startY++;
            offset+=2;//偏移量变成2

        }
        if(n%2==1){
            ans[mid][mid]=res;
        }
        return ans;
    }
}

2.2 螺旋矩阵

和上题思路基本一致。都是通过确定边界，一次次循环将值放在集合里输出
同：如果是正方形，且n为奇数，处理方式一样。。。
不同：
1.循环次数：选择行列取商的最小值（产生2，3的特殊情况）
2.当行小于列，且列为奇数，我们要手动输出剩下的值
3.列小于行，且行为奇数同上。。。。

螺旋矩阵

class Solution {
    //我们严格按照左闭右开的原则进行分组
    //上层：从左向右
    //右层：从上到下
    //下层：从右向左
    //左层：从下到上
    public List<Integer> spiralOrder(int[][] matrix) {
        List list = new LinkedList();
        int  startX=0;//行开始的位置
        int  startY=0;//列开始的位置
        int offset = 1;//偏移量
        int count = Math.min(matrix.length,matrix[0].length)/2;//找到行列中的最小值作为循环次数
        int m =matrix[0].length;
        int n = matrix.length;

        while(count>0){
            int i =startX;
            int j =startY;
            //上层，i不变，j变
            for(;j<m+startY-offset;j++){
                list.add(matrix[i][j]);
            }
            //右层，j不变，i变
            for(;i<n+startX-offset;i++){
                list.add(matrix[i][j]);
            }
            //下层，i不变，j变
            for(;j>startY;j--){
                list.add(matrix[i][j]);
            }
            //左层，j不变，i变
            for(;i>startX;i--){
                list.add(matrix[i][j]);
            }
            startX++;//更新初始位置
            startY++;//更新初始位置
            count--;
            offset+=2;//更新偏移量
        }
        //如果是正方形的话，需要特殊处理中间值
        if(m==n&&n%2==1){
            list.add(matrix[m/2][n/2]);
        }
       //针对列小于行且，列不是偶数的时候；
       
        if ( (m > n && n%2!=0) ){
            for (int i = n/2; i < m-n/2; i++) {
                list.add(matrix[n/2][i]);
            }
        }
         //针对行小于列且，行不是偶数的时候，该情况
        //[[1,2,3,4],[5,6,7,8],[9,10,11,12]]
       //若不判断，输出为[1,2,3,4,8,12,11,10,9,5]
       // 带入数字计算，如该数列matrix[i][1]和matrix[i][2]没有输出，那么我们将其输出
        if ( (m < n && m%2 !=0)){
            for (int i = m/2; i < n-m/2; i++) {
                list.add(matrix[i][m/2]);
            }
        }

        return list;

    }
}