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

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

输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字。

示例 1：

输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]
输出：[1,2,3,6,9,8,7,4,5]
示例 2：

输入：matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]
输出：[1,2,3,4,8,12,11,10,9,5,6,7]

来源：力扣（LeetCode）
链接：点击跳转https://leetcode-cn.com/problems/shun-shi-zhen-da-yin-ju-zhen-lcof

---

思路：
首先要明确的一点是，这道题不能用深度优先遍历（DFS），一开始我用的这个方法，写完了发现这道题是需要一直遍历右👉，直到不能往右了在一直遍历下👇。。。
说白了就是一直右👉，一直下👇，一直左👈，一直上👆。

而DFS则是遇到一个格子，按照右下左上的方式试探，每走一步都是要右下左上这种。

所以正确的思路应该是：

1. 先创建一个和原二维数组一样大小的boolean[][]数组，用来判断是否已经走过。
2. 若没超出边界或格子为走过，一直循环遍历右，然后下，然后左，然后上
3. 再创建一个循环把刚刚写的四个循环包裹，每一个大循环都要依次遍历右下左上

代码如下：

class Solution {
    public int[] spiralOrder(int[][] matrix) {
        int hang = matrix.length;
        if(hang == 0) return new int[0];
        int lie = matrix[0].length;
        boolean[][] isUsed = new boolean[hang][lie];
        int i = 0;
        int j = 0;
        int[] res = new int[hang*lie];
        int index = 0;
        if(hang == 1) {
            for(int k = 0; k < lie; k++) {
                res[k] = matrix[i][j];
                j++;
            }
            return res;
        }
        if(lie == 1) {
            for(int k = 0; k < hang; k++) {
                res[k] = matrix[i][j];
                i++;
            }
            return res;
        }
        while(!isUsed[i][j]) {
            while(j < lie && !isUsed[i][j]) {
                res[index] = matrix[i][j];
                isUsed[i][j] = true;
                index++;
                if(j >= lie-1 || isUsed[i][j+1]) {
                    i++;
                    break;
                }
                j = j+1;
            }

            while(i < hang && !isUsed[i][j]) {
                res[index] = matrix[i][j];
                isUsed[i][j] = true;
                index++;
                if(i >= hang-1 || isUsed[i+1][j]) {
                    j--;
                    break;
                }
                i = i+1;
            }

            while(j >= 0 && !isUsed[i][j]) {
                res[index] = matrix[i][j];
                isUsed[i][j] = true;
                index++;
                if(j <= 0 || isUsed[i][j-1]) {
                    i--;
                    break;
                };
                j = j-1;
            }
            while(i >= 0 && !isUsed[i][j]) {
                res[index] = matrix[i][j];
                isUsed[i][j] = true;
                index++;
                if(i <= 0 || isUsed[i-1][j]) {
                    j++;
                    break;
                }
                i = i-1;
            }
        }
        return res;
    }

}

---

当然，看了题解后有更好的办法，看下大佬的思路和方法：

1. 空值处理： 当 matrix 为空时，直接返回空列表 [] 即可。
2. 初始化： 矩阵 左、右、上、下 四个边界 l , r , t , b ，用于打印的结果列表 res 。
3. 循环打印： “从左向右、从上向下、从右向左、从下向上” 四个方向循环，每个方向打印中做以下三件事 （各方向的具体信息见下表） ；
   (1)根据边界打印，即将元素按顺序添加至列表 res 尾部；
   (2)边界向内收缩 11 （代表已被打印）；
   (3)判断是否打印完毕（边界是否相遇），若打印完毕则跳出。
4. 返回值： 返回 res 即可。

作者：jyd
链接：https://leetcode-cn.com/problems/shun-shi-zhen-da-yin-ju-zhen-lcof/solution/mian-shi-ti-29-shun-shi-zhen-da-yin-ju-zhen-she-di/
来源：力扣（LeetCode）

代码：

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;
    }
}