59. 螺旋矩阵 II

题目链接：力扣

解题思路：类似于54. 螺旋矩阵 

找规律，模拟矩阵的访问，每访问一个位置，就对该位置进行赋值，

观察螺旋顺序：行(向右)--> 列(向下)-->行(向左)-->列(向上)-->行(向右)-->...

可以发现行和列是交替的，并且两次遍历行和列时的方向和上次访行和列问的方向正好相反。

比如上次访问行是向右的，则下次再次访问行时则是向左的，下次再次访问时则是向右的，列的规律也相同

并且每次访问行和列时需要遍历的元素也是有规律的，对于m行n列的矩阵来说，假设rowNum表示已经访问过了几行，colNum表示已经访问过了几列，则对于当前正在访问的行或者列来说，需要访问的元素个数满足下列规律：

1. 对于行，当前需要访问的元素个数：n-colNum，矩阵的列数减去已经访问的列数就是当前行需要访问的元素个数，访问列的时候，一整列的元素都已经访问过了，这次访问行时访问过的列中的元素不需要再次访问
2. 对于列，当前需要访问的元素个数：m-rowNum，矩阵的行数减去已经访问的行数就是当前列需要访问的元素个数，访问行的时候，一整行的元素已经访问过了，这次访问列时访问过的行中的元素不需要再次访问

可以使用两个变量currentRow和currentCol，表示当前正在访问的行和列，rowAdd=1和colAdd=1表示行和列的方向：

1. 访问行时：每次令currentCol=currentCol+colAdd，直到访问n-colNum个元素为止，然后令colAdd=-colAdd（下次访问行时按照相反的方向访问），rowNum++(已经访问过的行的数量加1)
2. 访问列时：每次令currentRow=currentRow+rowAdd，直到访问m-rowNum个元素为止，然后令rowAdd=-rowAdd(下次列时按照相反的方向访问)，colNum++
3. 无论访问行还是列，都将当前正在访问的元素matrix[currentRow][currentCol]加入到结果result中

可以使用一个标记rowFlag交替访问行和列，当result元素中的个数等于m*n时，结束

使用一个全局变量currentNum=1依次给每个访问的元素赋值，每次赋值完，自增1

AC代码：

class Solution {
    public static int[][] generateMatrix(int n) {
        int[][] result = new int[n][n];

        int currentNum = 1;

        int rowNum = 0;
        int colNum = 0;
        boolean rowFlag = true;

        int rowAdd = 1;
        int colAdd = 1;

        int currentRow = 0;
        int currentCol = -1;
        while (currentNum != n * n + 1) {
            if (rowFlag) {//遍历当前行
                int num = n - colNum;
                while (num > 0) {
                    currentCol += colAdd;
                    result[currentRow][currentCol] = currentNum++;
                    num--;
                }
                rowFlag = false;
                colAdd = -colAdd;
                rowNum++;
            } else {//遍历当前列
                int num = n - rowNum;
                while (num > 0) {
                    currentRow += rowAdd;
                    result[currentRow][currentCol] = currentNum++;
                    num--;
                }
                rowFlag = true;
                rowAdd = -rowAdd;
                colNum++;
            }
        }
        return result;
    }
}

时间复杂度O(n)，空间复杂度O(n^2)

更简洁的做法：时间和空间复杂度和上面代码一样，不过代码更加简短

从外层向内层填数字，每次填一圈，填完最外层一圈，然后在填内层的一圈，每一圈填数字的顺序按照：上边界的行（从左到右）-->右边界的列(从上到下) --> 下边界的行(从右到左) -->左边界的列(从下到上)

这时需要定义四个边界，left，right，top，bottom，分别表示当前正在填写的外圈的四个边界，具体算法如下：

1. 初始值：left=0，right = n-1，top=0，bottom=n-1，currentNum=1
2. 当currentNum小于n*n-1时，循环对外层边界填数字：
   1. 对上边界的行填数字：
      1. result[top][i]=currentNum++;
   2. 上边界已经填写完，修改上边界：top++
   3. 对右边界的列填数字：
      1. result[i][right]=currentNum++;
   4. 右边界已经填写完，修改右边界：right--
   5. 对下边界的行填数字
      1. result[bottom][i]=currentNum++;
   6. 下边界已经填写完，修改下边界：bottom--
   7. 对左边界的列填数字
      1. result[i][left]=currentNum++
   8. 左边界已经填写完，修改左边界：left++

AC代码

class Solution {
    public static int[][] generateMatrix(int n) {
        int left = 0;
        int right = n - 1;
        int top = 0;
        int bottom = n - 1;
        int currentNum = 1;
        int[][] result = new int[n][n];
        while (currentNum < n * n+1) {
            //上边界，从左到右
            for (int i = left; i <= right; i++)
                result[top][i] = currentNum++;
            top++;

            //右边界，从上到下
            for (int i = top; i <= bottom; i++)
                result[i][right] = currentNum++;
            right--;

            //下边界，从右到左
            for (int i = right; i >= left; i--)
                result[bottom][i] = currentNum++;
            bottom--;

            //左边界，从下到上
            for (int i = bottom; i >= top; i--)
                result[i][left] = currentNum++;
            left++;
        }
        return result;
    }
}