问题描述

给出一个 m x n 的矩阵（m 行, n 列），请按照顺时针螺旋顺序返回元素。

例如，给出以下矩阵：

[
    [ 1, 2, 3 ],
    [ 4, 5, 6 ],
    [ 7, 8, 9 ]
]

应该返回 [1,2,3,6,9,8,7,4,5]。

算法实现

分四步，右，下，左，上，注意每一步的转向判断（转向条件：当前道路上的下一步已经遍历）。以下是算法实现：

    public static List<Integer> spiralOrder(int[][] matrix) {
        List<Integer> list = new ArrayList<>();
        if (matrix.length == 0) {
            return list;
        }
        int h = matrix.length;
        int w = matrix[0].length;
        boolean[][] flag = new boolean[h][w];

        int index = 0, i = 0, j = 0;
        while (index < h * w) {
            /** * 向右 */
            while (j < w) {
                if (!flag[i][j]) {
                    list.add(matrix[i][j]);
                    flag[i][j] = true;
                    index++;
                }
                /** * 预检，是否已经需要转向 */
                if (j < w - 1 && !flag[i][j + 1]) {
                    j++;
                } else {
                    break;
                }
            }
            /** * 向下 */
            while (i < h) {
                if (!flag[i][j]) {
                    list.add(matrix[i][j]);
                    flag[i][j] = true;
                    index++;
                }
                /** * 预检，是否已经需要转向 */
                if (i < h - 1 && !flag[i + 1][j]) {
                    i++;
                } else {
                    break;
                }
            }
            /** * 向左 */
            while (j >= 0) {
                if (!flag[i][j]) {
                    list.add(matrix[i][j]);
                    flag[i][j] = true;
                    index++;
                }
                /** * 预检，是否已经需要转向 */
                if (j > 0 && !flag[i][j - 1]) {
                    j--;
                } else {
                    break;
                }
            }
            /** * 向上 */
            while (i >= 0) {
                if (!flag[i][j]) {
                    list.add(matrix[i][j]);
                    flag[i][j] = true;
                    index++;
                }
                /** * 预检，是否已经需要转向 */
                if (i > 0 && !flag[i - 1][j]) {
                    i--;
                } else {
                    break;
                }
            }

        }
        return list;
    }