面試常備題(三)----順時針打印矩陣

     最近一直在忙項目，都沒有時間准備下個學期的校招，雖然已經有一些小公司主動招我去上班，但我還是想要去大公司里面看看，親眼見識下那些業界牛人到底是怎樣的。所以，也正計划開始做些面試題，打好基礎。

     基礎薄弱是我的弱點，我都是做啥學啥，沒有專門研究一個東西，像是搞過藍牙和USB通信這些需要與硬件打交道的東西，也搞過數據庫的設計，搞過微信公共賬號，搞過網站，搞過android應用開發...等等，但都沒一樣是特別厲害的，相反，我總覺得自己好弱啊！！

     面試是需要准備的，哪怕我們自認自己很牛逼，但一些平時沒有用到的東西，像是計算機組成原理，計算機網絡的基礎知識，就會把我們弄懵了。

     這些只要背就行了，但一些筆試和面試題目就需要訓練了，畢竟算法或者數值類的題目我們平時根本就不會用到！

     今天這道題是跟矩陣有關的:輸入一個矩陣，按照從外向里以順時針的順序依次打印出每一個數字，如：

     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

      實現的要點非常簡單，就是在遍歷元素的時候改變方向而已，一共需要四次：從左到右，從上到下，從右到左，從下到上。當然，方向的改變次數會隨着數據的多少而發生變化，但這些都不是問題，只要設置好遍歷的上下限就可以。

       首先是要得到一個矩陣：

public static int[][] getMatrix(int dimension) {
        int[][] matrix = new int[dimension][dimension];
        int offset = 1;
        System.out.println("矩陣:");
        for (int i = 0; i < dimension; i++) {
            for (int j = 0; j < dimension; j++) {
                matrix[i][j] = j + offset;
                if (matrix[i][j] % dimension == 0) {
                    System.out.println(matrix[i][j] + " ");
                } else {
                    System.out.print(matrix[i][j] + " ");
                }
            }
            offset += dimension;
        }
        return matrix;
    }

        對於矩陣而言，如果是從1開始，那么每行末尾的元素都是維度的倍數。
        這是5維矩陣的輸出結果：

矩陣:
1 2 3 4 5
6 7 8 9 10
11 12 13 14 15
16 17 18 19 20
21 22 23 24 25

        接着我們就是順時針打印該矩陣了：

public static void handleValue(int num, int len) {
        for (int i = num; i < len; i++) {
            if (list.indexOf(matrix[row][i]) == -1) {
                list.add(matrix[row][i]);
                conlum++;
            }
        }

        for (int i = num + 1; i < conlum; i++) {
            if (list.indexOf(matrix[i][conlum - 1]) == -1) {
                list.add(matrix[i][conlum - 1]);
                row++;
            }
        }

        for (int i = len - num - 1; i > 0; i--) {
            if (list.indexOf(matrix[row][i - 1]) == -1) {
                list.add(matrix[row][i - 1]);
                conlum--;
            }
        }

        for (int i = len - num - 2; i > 0; i--) {
            if (list.indexOf(matrix[i][conlum - 1]) == -1) {
                list.add(matrix[i][conlum - 1]);
                row--;
            }
        }
    }

    public static void handleMatrix(int[][] matrix) {
        int len = matrix.length;
        for (int i = 0; i < Math.round(len / 2 + 1); i++) {
            handleValue(i, len);
        }
    }

      實現的基本原理就是這樣：假設四次不同方向改變為一圈，那么需要找出一個矩陣大概的圈數，然后一圈一圈的處理該矩陣。每次方向改變的時候，只要記住是行還是列發生改變就行。為了防止添加重復的元素，我們增加了一個檢查，當然可以實現不添加重復的元素。

       打印的結果如：

 結果:
1 2 3 4 5 10 15 20 25 24 23 22 21 16 11 6 7 8 9 14 19 18 17 12 13    

       我們可以繼續測試：

matrix = getMatrix(10);

       看看10維的矩陣結果如何：
矩陣:
1 2 3 4 5 6 7 8 9 10
11 12 13 14 15 16 17 18 19 20
21 22 23 24 25 26 27 28 29 30
31 32 33 34 35 36 37 38 39 40
41 42 43 44 45 46 47 48 49 50
51 52 53 54 55 56 57 58 59 60
61 62 63 64 65 66 67 68 69 70
71 72 73 74 75 76 77 78 79 80
81 82 83 84 85 86 87 88 89 90
91 92 93 94 95 96 97 98 99 100
結果:
1 2 3 4 5 6 7 8 9 10 20 30 40 50 60 70 80 90 100 99 98 97 96 95 94 93 92 91 81 71 61 51 41 31 21 11 12 13 14 15 16 17 18 19 29 39 49 59 69 79 89 88 87 86 85 84 83 82 72 62 52 42 32 22 23 24 25 26 27 28 38 48 58 68 78 77 76 75 74 73 63 53 43 33 34 35 36 37 47 57 67 66 65 64 54 44 45 46 56 55

       這道題目還是非常簡單的，一兩分鍾內就能做出來，只要知道它的重點是在哪里就行。