java顺时针螺旋遍历M*N的矩阵

示例1：

输入:
[
 [ 1, 2, 3 ],
 [ 4, 5, 6 ],
 [ 7, 8, 9 ]
]
输出: [1,2,3,6,9,8,7,4,5]

示例2：

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

思路：先找出MN和转的圈数的数学关系

int layers = (Math.min(rows, cols) - 1) / 2 + 1;

然后进行四个步骤的编码
往右 往下 往左 往上

往上的代码在特殊情况下会出现重复，所以每次往下或者往上走了哨兵值+1

Shunshizhen.java

import java.util.ArrayList;
import java.util.List;

/**
 * @author Scen
 * @date 2019-04-02 09:43
 */
public class Shunshizhen {
    public static void main(String[] args) {
        int[][] a = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};
        int[][] d = {{2, 3, 4}, {5, 6, 7}, {8, 9, 10}, {11, 12, 13}, {14, 15, 16}};
        int[][] b = {{2, 5}, {8, 4}, {0, -1}};
        int[][] c = {{7}, {9}, {6}};
        System.out.println(spiralOrder(c));
    }
    
    
    public static List<Integer> spiralOrder(int[][] matrix) {
        List<Integer> result = new ArrayList<>();
        if (matrix.length == 0 || matrix[0].length == 0) {
            return result;
        }

//        行数
        int rows = matrix.length;
//        列
        int cols = matrix[0].length;
        
        boolean shang = false;
        boolean xia = false;
        int shaobing = 0;

//        圈数
        int layers = (Math.min(rows, cols) - 1) / 2 + 1;
        
        
        for (int layer = 0; layer < layers; layer++) {
            
            
            //        往右走 当前行等于第layer圈 走到（最后一列-圈）
            for (int i = layer; i < cols - layer; i++) {
                result.add(matrix[layer][i]);
            }

//        往下走 当前列等于第layer圈+1   一直走到行减圈停止
            for (int i = layer + 1; i < rows - layer; i++) {
                result.add(matrix[i][(cols - 1) - layer]);
                xia = true;
            }
            if (xia) {
                shaobing++;
            }

//        往左走并且不在当前行 当前行等于第layer圈 一直走到下标为-1+layer+1的那一列
            for (int i = (cols - 1) - (layer + 1); i > (layer - 1) && (rows - 1 - layer) != layer; i--) {
                result.add(matrix[(rows - 1) - layer][i]);
            }

//        往上走并且列数不等于1并且哨兵值小于列数（如果大于或者等于说明数据已经往下走过一遍了）
            for (int i = (rows - 1) - (layer + 1); i > (layer) && cols != 1 && shaobing < cols; i--) {
                result.add(matrix[i][layer]);
                shang = true;
            }
            
            if (shang) {
                shaobing++;
            }
            
        }
        return result;
    }
}