leetCode 54. Spiral Matrix

Given a matrix of m x n elements (m rows, n columns), return all elements of the matrix in spiral order.

Example 1:

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

Example 2:

Input:
[
  [1, 2, 3, 4],
  [5, 6, 7, 8],
  [9,10,11,12]
]
Output: [1,2,3,4,8,12,11,10,9,5,6,7]

思路很简单，整个输出过程用rowLowerBound,rowUpperBound,colLowerBound,colUpperBound来控制边界。输出时要控制边界缩小，并且输出的内容要在边界内。
几种特殊情况：

　　　　 {1,2,3,4},
        {5,6,7,8},
        {9,10,11,12}

        {1,2,3},
        {4,5,6},
        {7,8,9}

        {1 , 2, 3, 4, 5},
        {6,  7, 8 ,9,10},
        {11,12,13,14,15},
        {16,17,18,19,20},
        {21,22,23,24,25}

        { 1, 2, 3, 4, 5, 6},
        { 7, 8, 9,10,11,12},
        {13,14,15,16,17,18},
        {19,20,21,22,23,24}

        {6,9,7}

        {1},
        {2},
        {3}

        {1,2},
        {3,4},
        {5,6},
        {7,8}

class Solution {
    public List<Integer> spiralOrder(int[][] matrix) {
        int row, col;
        row = matrix.length;
        ArrayList<Integer> list = new ArrayList<>();
        if (row == 0)
            return list;
        col = matrix[0].length;

        /*
        只能在边界内循环
         */
        int rowLowerBound = 0, rowUpperBound = row-1;
        int colLowerBound = 0, colUpperBound = col-1;
        while (rowLowerBound <= rowUpperBound && colLowerBound <= colUpperBound){
            /*
            沿着行rowLowerBound从左至右输出
            沿着列colUpperBound从上到右输出
            沿着行rowUpperBound从右到左输出
            沿着列colLowerBound从下到上输出

            变更边界条件（转向内层矩阵，等于是将原来矩阵剥了一层皮）
            rowLowerBound+1, rowUpperBound-1, colLowerBound+1,colUpperBound-1
             */
            for (int i = colLowerBound, flag = 1; i < colUpperBound; i++) {//→
                list.add(matrix[rowLowerBound][i]);
                if (rowLowerBound == rowUpperBound){
                    ++colLowerBound;
                }else if(colLowerBound < colUpperBound && flag == 1 && rowUpperBound != row-1){
                    ++colLowerBound;
                    flag = 0;
                }
            }
            for (int i = rowLowerBound, flag = 1; i < ((rowUpperBound == 0) ? 1 : rowUpperBound); i++) {//↓
                list.add(matrix[i][colUpperBound]);

                if (colLowerBound == colUpperBound){
                    ++rowLowerBound;
                }else if(rowLowerBound < rowUpperBound && flag == 1) {
                    ++rowLowerBound;
                    flag = 0;
                }
            }
            for (int i = colUpperBound, flag = 1; i > colLowerBound; i--) {//←
                list.add(matrix[rowUpperBound][i]);
                if(rowLowerBound == rowUpperBound)
                    --colUpperBound;
                else if (colLowerBound < colUpperBound && flag == 1){
                    --colUpperBound;
                    flag = 0;
                }
            }
            for (int i = rowUpperBound, flag = 1; i > rowLowerBound; i--) {//↑
                list.add(matrix[i][colLowerBound]);
                if (colLowerBound == colUpperBound)
                    --rowUpperBound;
                else if (rowLowerBound < rowUpperBound && flag == 1){
                    --rowUpperBound;
                    flag = 0;
                }
            }
            if (rowLowerBound == rowUpperBound && colLowerBound == colUpperBound){
                list.add(matrix[rowLowerBound][colLowerBound]);
                break;
            }
        }
        return list;
    }
}