順時針打印矩陣

一，問題描述

給定一個N x N 的矩陣（方陣），按照從外向里的以順時針方向依次打印矩陣中的每個元素。

比如：一個 3X3的矩陣如下：打印順序為：1 2 3 6 9 8 7 4

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

打印方向如下：

 

二，算法思路

可以采用遞歸的方式來打印整個矩陣中的元素。

首先按順時針方向打印最外層的元素，然后再遞歸地打印更里層的元素。

對於N維方陣而言：每打印一圈之后，維數降低2。當N為奇數時，最終遞歸到 1x1矩陣。當N為偶數時，最終遞歸到N=0

因此，遞歸的基准條件：當N==0 時，直接返回。 N==1時，打印矩陣中唯一的那個元素，然后返回。

具體代碼如下：

    private static void printArray(int[][] arr, int row, int column, int n){
        //base condition
        if(n == 0)
            return;
        if(n == 1){
            print(arr[row][column]);
            return;
        }
        
        printElementClockWise(arr, row, column);//clockwise print element
        printArray(arr, row + 1, column - 1, n - 2);//recursively call
    }

①第3行和第5行的if表示的是遞歸的基准條件

②第10行，是順時針打印矩陣中的元素。注意：它在遞歸調用之前執行，這說明：打印順序是從外到內的。(對遞歸的理解)說白了，就是先打印了外層的元素，再遞歸調用打印內層元素。

③第10行執行遞歸調用。因為打印的是更里層的元素，故待打印的元素的位置：行數增加1，列數減少1

每打印一圈之后，數組的維數降低2

 

三，完整代碼實現

public class PrintArray {
    
    public static void printArray(int[][] arr){
        if(arr == null || arr.length == 0)
            return;
        printArray(arr, 0, arr.length - 1, arr.length);
    }
    
    private static void printArray(int[][] arr, int row, int column, int n){
        //base condition
        if(n == 0)
            return;
        if(n == 1){
            print(arr[row][column]);
            return;
        }
        
        printElementClockWise(arr, row, column);//clockwise print element
        printArray(arr, row + 1, column - 1, n - 2);//recursively call
    }
    
    /**
     * 順時針由外到內打印數組
     * @param arr
     * @param row
     * @param column
     */
    private static void printElementClockWise(int[][] arr, int row, int column){
        for(int i = row; i <= column; i++)
            print(arr[row][i]);
        for(int i = row + 1; i <= column; i++)
            print(arr[i][column]);
        for(int i = column - 1; i >= row; i--)
            print(arr[column][i]);
        for(int i = column - 1; i > row; i--)
            print(arr[i][row]);
    }
    
    private static void print(int i){
        System.out.print(i + " ");
    }
    
    //for test purpose
    public static void main(String[] args) {
        int[][] arr = {
                {1,2,3},
                {4,5,6},
                {7,8,9}
        };
        System.out.println("arr.length:" + arr.length);
        printArray(arr);
        System.out.println();
        int[][] arr2 = {
                {1,2,3,10},
                {4,5,6,11},
                {7,8,9,12},
                {13,14,15,16}
        };
        printArray(arr2);
        
        int[][] arr3 = {};
        System.out.println(arr3.length);
        printArray(arr3);
        printArray(null);
    }
}

 

擴展：根據上面的思路，我們也可以構造一個蛇形矩陣。

    private void print(int[][] arr, int row, int col){
        for(int i = row; i <= col; i++)
            arr[row][i] = count++;
//            System.out.print(arr[row][i]);
        for(int i = row+1; i <= col; i++)
            arr[i][col] = count++;
//            System.out.print(arr[i][col]);
        for(int i = col-1; i >= row; i--)
            arr[col][i] = count++;
//            System.out.print(arr[col][i]);
        for(int i = col-1; i > row; i--)
            arr[i][row] = count++;
//        System.out.print(arr[i][row]);
    }

count是個靜態全局變量，初始值為1