力扣 54. 螺旋矩阵

直接模拟顺时针螺旋遍历
主要要解决的问题就是转圈时，在什么情况下转弯
最直接的办法就是利用一个辅助矩阵记录已经遍历过的数字，但这种方法空间复杂度会比较差
我的优化想法是，记录四条边已经遍历过的宽度，例如，当由向右转向为向下时，上边被遍历宽度就加一；每当转向时都有一条边加一。总之达到一个不断缩小可遍历矩阵的效果。
官方题解是采用了按层模拟的想法，可以将矩阵看成若干层，首先输出最外层的元素，其次输出次外层的元素，直到输出最内层的元素。
[[1, 1, 1, 1, 1, 1, 1],
[1, 2, 2, 2, 2, 2, 1],
[1, 2, 3, 3, 3, 2, 1],
[1, 2, 2, 2, 2, 2, 1],
[1, 1, 1, 1, 1, 1, 1]]

自己的（0ms） 可以看到分为四个方向去讨论的代码太冗长了，虽然时间复杂度不受影响

class Solution {
    public List<Integer> spiralOrder(int[][] matrix) {
        List<Integer> ans = new ArrayList<Integer>();
        int to = 4, x = 0, y = 0;
        int r = 0,l = 0, u = 0, d = 0;
        ans.add(matrix[0][0]);
        int jud = 1;
        while(jud == 1){
            switch(to){
                case 1:
                    if(x - 1 == u - 1){
                        if(y + 1 == matrix[0].length - r){
                            jud = 0;
                            break;
                        }
                        to = 4;
                        l ++;
                        y ++;
                    }
                    else
                        x--;
                    ans.add(matrix[x][y]);
                    break;
                case 2:
                    if(x + 1 == matrix.length - d){
                        if(y - 1 == l - 1){
                            jud = 0;
                            break;
                        }
                        to = 3;
                        r ++;
                        y --;
                    }
                    else
                        x++;
                    ans.add(matrix[x][y]);
                    break;
                case 3:
                    if(y - 1 == l - 1){
                        if(x - 1 == u - 1){
                            jud = 0;
                            break;
                        }
                        to = 1;
                        d ++;
                        x --;
                    }
                    else
                        y--;
                    ans.add(matrix[x][y]);
                    break;
                case 4:
                    if(y + 1 == matrix[0].length - r){
                        if(x + 1 == matrix.length - d){
                            jud = 0;
                            break;
                        }
                        to = 2;
                        u ++;
                        x ++;
                    }
                    else
                        y++;
                    ans.add(matrix[x][y]);
                    break;
            }
        }
        return ans;
    }
}

题解（0ms）

class Solution {
    public List<Integer> spiralOrder(int[][] matrix) {
        List<Integer> order = new ArrayList<Integer>();
        if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
            return order;
        }
        int rows = matrix.length, columns = matrix[0].length;
        int left = 0, right = columns - 1, top = 0, bottom = rows - 1;
        while (left <= right && top <= bottom) {
            for (int column = left; column <= right; column++) {
                order.add(matrix[top][column]);
            }
            for (int row = top + 1; row <= bottom; row++) {
                order.add(matrix[row][right]);
            }
            if (left < right && top < bottom) {
                for (int column = right - 1; column > left; column--) {
                    order.add(matrix[bottom][column]);
                }
                for (int row = bottom; row > top; row--) {
                    order.add(matrix[row][left]);
                }
            }
            left++;
            right--;
            top++;
            bottom--;
        }
        return order;
    }
}