顺时针打印路径的两种方法

题意

输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下4 X 4矩阵： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 则依次打印出数字1,2,3,4,8,12,16,15,14,13,9,5,6,7,11,10.

方法一

方法一也是最容易想到的，采用传统的路径标记法，将走过的路径通过一个二维数组visited来维护，遍历过了便为true。

因此整体的思路便为首先判断坐标是否越界，并且所选择的坐标是否被访问过，若没有则按一个方向始终前行，当无法再走了，便跳出换一个方向继续遍历，这里的方向控制为

int []dirx = {0,1,0,-1};
int []diry = {1,0,-1,0};

每次改变方向通过取4的余数。

import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> printMatrix(int [][] matrix) {
        ArrayList<Integer> road = new ArrayList<Integer>();
        int len = matrix.length;
        int wid = matrix[0].length;
        int x = 0;
        int y = 0;
        int []dirx = {0,1,0,-1};
        int []diry = {1,0,-1,0};
        boolean [][]visited = new boolean[len][wid];
        int dir = 0;
        while(x >= 0 && x <len && y>=0 && y < wid &&!visited[x][y]){
            visited[x][y]=true;
            road.add(matrix[x][y]);
            while(x+dirx[dir] >= 0 && x +dirx[dir]<len && y+diry[dir]>=0 && y+diry[dir] < wid &&!visited[x+dirx[dir]][y+diry[dir]]){
                x+=dirx[dir];
                y+=diry[dir];
                road.add(matrix[x][y]);
                visited[x][y]=true;
            }
            dir = (dir+1)%4;
            x+=dirx[dir];
            y+=diry[dir];
        }
            return road;
    }
}

(有时可以用while(true)，然后用break跳出)。

方法二

矩阵转置的方法，首先读取矩阵的第一行，删除第一行，然后逆时针转置矩阵，再读取第一行，删除第一行再逆时针转置，一直到最后一行被读取完后没有行了则输出。

注意点

矩阵的转置
1） 逆时针转置

public int[][] reverse(int[][] matrix){
        int [][]output = new int[matrix[0].length][matrix.length];
        for(int i = 0 ; i < matrix.length; i++){
            for(int j = 0 ; j < matrix[0].length ; j++){
                output[matrix[0].length-j-1][i] = matrix[i][j];
            }
        }
        return output;
    }

2） 顺时针转置

public int[][] reverse(int[][] matrix){
        int [][]output = new int[matrix[0].length][matrix.length];
        for(int i = 0 ; i < matrix.length; i++){
            for(int j = 0 ; j < matrix[0].length ; j++){
                output[j][matrix.length-i-1] = matrix[i][j];
            }
        }
        return output;
    }

3） 对称

public int[][] reverse(int[][] matrix){
        int [][]output = new int[matrix[0].length][matrix.length];
        for(int i = 0 ; i < matrix.length; i++){
            for(int j = 0 ; j < matrix[0].length ; j++){
                output[matrix[0].length-j-1][matrix.length-i-1] = matrix[i][j];
            }
        }
        return output;
    }

完整代码

import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> printMatrix(int [][] matrix) {
        ArrayList<Integer> result = new ArrayList<Integer>();
        while(matrix.length!=0){
            for(int i = 0; i < matrix[0].length; i++){
                result.add(matrix[0][i]);
            }
            if(matrix.length>1){
                int [][]matrix2 = new int[matrix.length-1][matrix[0].length];
                for(int i = 1; i < matrix.length; i++){
                    for(int j = 0; j < matrix[0].length; j++){
                        matrix2[i-1][j] = matrix[i][j];
                    }
                }
                matrix = reverse(matrix2);
            }else{
                matrix = new int[0][];
            }
        }
        return result;
    }

    public int[][] reverse(int[][] matrix){
        int [][]output = new int[matrix[0].length][matrix.length];
        for(int i = 0 ; i < matrix.length; i++){
            for(int j = 0 ; j < matrix[0].length ; j++){
                output[matrix[0].length-j-1][i] = matrix[i][j];
            }
        }
        return output;
    }
}