顺时针打印矩阵

顺时针打印矩阵

 最近一直在忙项目，都没有时间准备下个学期的校招，虽然已经有一些小公司主动招我去上班，但我还是想要去大公司里面看看，亲眼见识下那些业界牛人到底是怎样的。所以，也正计划开始做些面试题，打好基础。

     基础薄弱是我的弱点，我都是做啥学啥，没有专门研究一个东西，像是搞过蓝牙和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

       这道题目还是非常简单的，一两分钟内就能做出来，只要知道它的重点是在哪里就行。

 

 

 

标签: Java