力扣刷题日记

螺旋矩阵2

模拟题，注意好边界问题，以及中间点的处理。

class Solution {
    public int[][] generateMatrix(int n) {
        int loop =  n / 2;  // 每个圈循环几次，例如n为奇数3，那么loop = 1 只是循环一圈，矩阵中间的值需要单独处理
        int mid = n/2;// 矩阵中间的位置，例如：n为3， 中间的位置就是(1，1)，n为5，中间位置为(2, 2)
        int[][] res = new int[n][n];
        int startx = 0,starty=0; // 定义每循环一个圈的起始位置
        int count = 1;  // 定义填充数字
        int offset = 1;// 需要控制每一条边遍历的长度，每次循环右边界收缩一位
        int i, j;


        while (loop--!=0) { // 判断 边界后，loop从1开始
            // 模拟上侧从左到右
            i=startx;
            j=starty;
	// 下面开始的四个for就是模拟转了一圈
            // 模拟填充上行从左到右(左闭右开)
               for (j = starty; j < n - offset; j++) {
                res[startx][j] = count++;
            }

            // 模拟右侧从上到下
            for (i = startx; i < n - offset; i++) {
                res[i][j] = count++;
            }

            // 模拟下侧从右到左
           for (; j > starty; j--) {
                res[i][j] = count++;
            }

            // 模拟左侧从下到上
                 for (; i > startx; i--) {
                res[i][j] = count++;
            }

            startx++;
            starty++;
             offset += 1;
        }

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

        return res;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

螺旋矩阵

class Solution {
    public List<Integer> spiralOrder(int[][] matrix) {
      List<Integer> arr = new ArrayList<>();
        int left = 0, right = matrix[0].length-1;
        int top = 0, down = matrix.length-1;
        
        while (true) {
             for (int i = left; i <= right; ++i) {
                 arr.add(matrix[top][i]);
             }
             top++;
             if (top > down) break;
             for (int i = top; i <= down; ++i) {
                 arr.add(matrix[i][right]);
             }
             right--;
             if (left > right) break;
             for (int i = right; i >= left; --i) {
                 arr.add(matrix[down][i]);
             }
             down--;
             if (top > down) break;
             for (int i = down; i >= top; --i) {
                 arr.add(matrix[i][left]);
             }
             left++;
             if (left > right) break;
             
        }
        return arr;


    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

剑指 Offer 29. 顺时针打印矩阵

class Solution {
    public int[] spiralOrder(int[][] matrix) {
        if(matrix.length == 0) return new int[0];
        int l = 0, r = matrix[0].length - 1, t = 0, b = matrix.length - 1, x = 0;
        int[] res = new int[(r + 1) * (b + 1)];
        while(true) {
            for(int i = l; i <= r; i++) res[x++] = matrix[t][i]; // left to right.
            if(++t > b) break;
            for(int i = t; i <= b; i++) res[x++] = matrix[i][r]; // top to bottom.
            if(l > --r) break;
            for(int i = r; i >= l; i--) res[x++] = matrix[b][i]; // right to left.
            if(t > --b) break;
            for(int i = b; i >= t; i--) res[x++] = matrix[i][l]; // bottom to top.
            if(++l > r) break;
        }
        return res;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

做了这三题总结下来，这类题就是模拟好顺时针旋转，注意好边界点的改变就可以了，其实大体都差不多，不同之处在于一个存在 ArrayList 一个存在 数组当中。