#54螺旋矩阵medium

#54medim
code1:
//注意up主right在初始化和进行下一圈更新时是不一样的哦
//int right = column - 1 - round * 2;
//因为第一圈第[0,0]元素提前插入（进入循环还未更新步就马上插入）
//right = column - round * 2;
//而后面每一圈第[0,0]元素都是在循环下一步才插入（本次循环是插入上一圈最后一个数）
class Solution {
    //使用4个int right，down，left，up来记录当前要向这四个方向前进的优先级和前进的步数
    public List<Integer> spiralOrder(int[][] matrix) {
        List<Integer> result = new ArrayList<>();
        int row = matrix.length;
        if (row == 0) {
            return result;
        }
        int column = matrix[0].length;

        int size = row * column;
        //当前已经前进的步数
        int currentPosition = 0;
        //当前走到的行index
        int currentRow = 0;
        //当前走到的列index
        int currentColumn = 0;
        //当前走的圈数，right，down，left，up同时为0说明一圈已经走完，round++
        int round = 0;

        int right = column - 1 - round * 2;
        int down = row - 1 - round * 2;
        int left = column - 1 - round * 2;
        int up = row - 2 - round * 2;

        while (currentPosition < size) {
            result.add(matrix[currentRow][currentColumn]);
            //向右前进步数未完，继续向右前进
            if (right > 0) {
                currentColumn++;
                right--;
            } else if (down > 0) {
                //向下前进步数未完，继续向下前进
                currentRow++;
                down--;
            } else if (left > 0) {
                //向左前进步数未完，继续向左前进
                currentColumn--;
                left--;
            } else if (up > 0) {
                //向上前进步数未完，继续向上前进
                currentRow--;
                up--;
                if (up == 0) {
                    //right，down，left，up同时为0,一圈已经走完，round++,并重置下一圈四个方向要走的步数
                    round++;
                    right = column - round * 2;
                    down = row - 1 - round * 2;
                    left = column - 1 - round * 2;
                    up = row - 2 - round * 2;
                }
            }
            currentPosition++;
        }
        return result;
    }
}

code2:
//重要的是要确定上下左右四条边的位置，
//那么初始化的时候，上边up就是0，下边down就是m-1，左边left是0，右边right是n-1。
//然后我们进行while循环，先遍历上边，将所有元素加入结果res，然后上边下移一位，
//如果此时上边大于下边，说明此时已经遍历完成了，直接break。
//同理对于下边，左边，右边，依次进行相对应的操作，
//这样就会使得坐标很有规律，并且不易出错
class Solution {
    public List<Integer> spiralOrder(int[][] matrix) {
        if(matrix.length==0 || matrix[0].length==0)
            return new ArrayList<Integer>();
        int row_num=matrix.length;
        int col_num=matrix[0].length;
        List<Integer> ans=new ArrayList<>();
        int up=0,down=row_num-1,left=0,right=col_num-1;
        while(true){
            for(int j=left;j<=right;j++)
                ans.add(matrix[up][j]);
            if(++up>down) break;
            for(int j=up;j<=down;j++)
                ans.add(matrix[j][right]);
            if(--right<left) break;
            for(int j=right;j>=left;j--)
                ans.add(matrix[down][j]);
            if(--down<up) break;
            for(int j=down;j>=up;j--)
                ans.add(matrix[j][left]);
            if(++left>right) break;
        }
        return ans;
    }
}