给定一个m x n大小的矩阵（m行，n列），按螺旋的顺序返回矩阵中的所有元素

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

返回值：
[1,2,3,6,9,8,7,4,5]

图示：

方法：边界模拟法（推荐使用）
思路：

这道题就是一个简单的模拟，我们想象有一个矩阵，从第一个元素开始，往右到底后再往下到底后再往左到底后再往上，结束这一圈，进入下一圈螺旋。

具体做法:

step 1：首先排除特殊情况，即矩阵为空的情况。
step 2：设置矩阵的四个边界值，开始准备螺旋遍历矩阵，遍历的截止点是左右边界或者上下边界重合。
step 3：首先对最上面一排从左到右进行遍历输出，到达最右边后第一排就输出完了，上边界相应就往下一行，要判断上下边界是否相遇相交。
step 4：然后输出到了右边，正好就对最右边一列从上到下输出，到底后最右边一列已经输出完了，右边界就相应往左一列，要判断左右边界是否相遇相交。
step 5：然后对最下面一排从右到左进行遍历输出，到达最左边后最下一排就输出完了，下边界相应就往上一行，要判断上下边界是否相遇相交。
step 6：然后输出到了左边，正好就对最左边一列从下到上输出，到顶后最左边一列已经输出完了，左边界就相应往右一列，要判断左右边界是否相遇相交。
step 7：重复上述3-6步骤直到循环结束。

package test3;

import java.util.ArrayList;

public class Arr5 {
    public static void main(String[] args) {
        Arr5 arr5 = new Arr5();
        int[][] test = new int[][]{
   
   {2},{3}};
        ArrayList<Integer> list = arr5.spiralOrder(test);
        System.out.println(list);
    }
    public ArrayList<Integer> spiralOrder(int[][] matrix) {
        //将需要的字符串用list串起来
        ArrayList<Integer> list = new ArrayList<>();
        if(matrix.length==0)
            return list;
        //设置四个循环的边界，上下左右边界
        int top=0,bottom=matrix.length-1;
        int left=0,right=matrix[0].length-1;
        //四个循环搞定一圈，外层再次循环用来循环所有, //直到边界重合
        while(left<=right && top<=bottom){//
            //上边界的从左到右
            for (int i = left; i <= right; i++) {
                list.add(matrix[top][i]);//行不变，即top上边界不变
            }
            //上边界相应就往下一行，要判断上下边界是否相遇相交。
            top++;
            if(top>bottom) break;
            //右边界的从上到下
            for (int i = top; i <= bottom; i++) {
                list.add(matrix[i][right]);//右边界不变
            }
            //上边界相应就往下一行，要判断上下边界是否相遇相交。
            right--;
            if(left>right)break;
            //下边界的从右到左
            for (int i =right ; i >=left ; i--) {
                list.add(matrix[bottom][i]);//底部不变
            }
            //下边界相应就往上一行，要判断上下边界是否相遇相交。
            bottom--;
            if(top>bottom)break;
            //左边界的从下到上
            for (int i = bottom; i >=top ; i--) {
                list.add(matrix[i][left]);//左边界不变
            }
            //左边界就相应往右一列，要判断左右边界是否相遇相交。
            left++;
            if(left>right)break;
        }
        return list;
    }
}

方法二：不推荐，有很多细节要考虑

public ArrayList<Integer> spiralOrder(int[][] matrix) {

        //将需要的字符串用list串起来
        ArrayList<Integer> list = new ArrayList<>();
        if(matrix.length==0)
            return list;
        //设置四个循环的边界，上下左右边界
        int top=0,bottom=matrix.length-1;
        int left=0,right=matrix[0].length-1;
        //四个循环搞定一圈，外层再次循环用来循环所有
        while(top<(matrix.length+1)/2 && left<(matrix[0].length+1)/2){
            //左到右
            for (int i = left; i <= right; i++) {
                list.add(matrix[top][i]);//行不变，即top上边界不变
            }
            //上到下
            for (int i = top+1; i <= bottom; i++) {
                list.add(matrix[i][right]);//右边界不变
            }
            //右到左,递减，先判断时候到边界
            for (int i =right-1 ; top!=bottom&&i >=left ; i--) {
                list.add(matrix[bottom][i]);//底部不变
            }
            //从下到上
            for (int i = bottom-1; right!=left&&i >top ; i--) {
                list.add(matrix[i][left]);//左边界不变
            }
            top++;left++;
            bottom--;right--;

        }
        return list;
    }