Given a matrix of m x n elements (m rows, n columns), return all elements of the matrix in spiral order. For example,Given the following matrix: [ [ 1, 2, 3 ], [ 4, 5, 6 ], [ 7, 8, 9 ]] You should return [1,2,3,6,9,8,7,4,5]. Subscribe to see which companies asked this question. 给定一个包含 m x n 个要素的矩阵，（m 行, n 列），按照螺旋顺序，返回该矩阵中的所有要素。 样例 给定如下矩阵： [ [ 1, 2, 3 ], [ 4, 5, 6 ], [ 7, 8, 9 ] ] 应返回 [1,2,3,6,9,8,7,4,5]。

solution

方法一 traverse

利用遍历的方法和规则，设置遍历时，规则的变化，边界的改变，很直观，具体看代码

public class Solution {
    public List<Integer> spiralOrder(int[][] matrix) {
    	List<Integer> res = new ArrayList<Integer>();
        
        if ( matrix == null || matrix.length == 0) {
            return res;
        }
        
        int rowBegin = 0;
        int rowEnd = matrix.length - 1;
        int colBegin = 0;
        int colEnd = matrix[0].length - 1;
        
        while( rowBegin <= rowEnd && colBegin <= colEnd) {
        	//traverse right
        	for(int i=colBegin;i<=colEnd;i++)
        		res.add(matrix[rowBegin][i]);
        	rowBegin++;
        	
        	//traverse down
        	for(int i=rowBegin;i<=rowEnd;i++)
        		res.add(matrix[i][colEnd]);
        	colEnd--;
        	
        	//traverse left
        	if(rowBegin <= rowEnd) {
	        	for(int i=colEnd;i>=colBegin;i--)
	        		res.add(matrix[rowEnd][i]);
	        	rowEnd--;
        	}
        	
        	//traverse up
        	if(colBegin <= colEnd) {
        		for(int i=rowEnd;i>=rowBegin;i--)
        			res.add(matrix[i][colBegin]);
        		colBegin++;
        	}
        }
        
        return res;
    }
}

方法二 direction

新建一个direction类，用它来控制坐标的移动，有两个函数，一个move，一个是turn。

public class Solution {
   /**
    * @param matrix a matrix of m x n elements
    * @return an integer list
    */
   public List<Integer> spiralOrder(int[][] matrix) {
       // Write your code here
       List<Integer> order = new ArrayList<Integer>();
       
       // check corner case
       if (matrix == null || matrix.length == 0) {
           return order;
       }
       int n = matrix.length;
       
       if (matrix[0] == null || matrix[0].length == 0) {
           return order;
       }
       int m = matrix[0].length;
       
       int direction = Direction.RIGHT;
       int[] cursor = new int[]{0, 0};
       
       for (int i = 0; i < n * m; i++) {
           order.add(matrix[cursor[0]][cursor[1]]);
           // mark the visited position as -1
           matrix[cursor[0]][cursor[1]] = -1;
           int[] nextCursor = Direction.move(cursor, direction);
           // if outside of matrix or marked before, turn right
           if (nextCursor[0] < 0 || nextCursor[0] >= n ||
                 nextCursor[1] < 0 || nextCursor[1] >= m ||
                 matrix[nextCursor[0]][nextCursor[1]] == -1) {
               direction = Direction.turnRight(direction);
               nextCursor = Direction.move(cursor, direction);
           }
           cursor = nextCursor;
       }
       
       return order;
   }
   
   
}

class Direction {
   public static int DOWN = 0;
   public static int RIGHT = 1;
   public static int LEFT = 2;
   public static int UP = 3;
   
   private static int[] dx = new int[]{1, 0, 0, -1};
   private static int[] dy = new int[]{0, 1, -1, 0};

   public static int turnRight(int direction) {
       if (direction == DOWN) {
           return LEFT;
       } else if (direction == RIGHT) {
           return DOWN;
       } else if (direction == LEFT) {
           return UP;
       } else if (direction == UP) {
           return RIGHT;
       }
       return -1;
   }
   
   public static int[] move(int[] cursor, int direction) {
       int[] nextCursor = new int[2];
       nextCursor[0] = cursor[0] + dx[direction];
       nextCursor[1] = cursor[1] + dy[direction];
       return nextCursor;
   }
}