矩阵问题

写在前面： 大家好，我是ewen，一文，总是感觉自己的真实名字有点拗口，就自己给自己取了个简单的名字(捂脸）。我是某大学软件工程专业大三的学生，写这个专栏，是为了总结自己做过的一些算法题，温故而知新，同时分享给这条路上的朋友们。由于本人水平有限，博客中难免有些错误，欢迎朋友们来指正，也很乐意与各位朋友交流学习经验。虽然现在还很菜，但是，我相信只要不断的学习、积累，总会有成为大佬的那一天。前路漫漫，当克己，当慎独。

做矩阵类型的题之前，首先要知道怎样求矩阵的行数和列数，矩阵的行数为矩阵元素的个书（matrix.length），矩阵的列数就是，矩阵中第一行元素的个数（matrix[0].length)，另外，需要注意的是，行数和列数都是从0开始的。

1. 转圈打印矩阵

给定一个整型矩阵matrix，请按照转圈的方式打印它。

示例：

1 2 3 4
5 6 7 8
2 5 0 1
9 6 7 4
打印结果为：1 2 3 4 8 1 4 7 6 9 2 5 6 7 0 5

要求：额外空间复杂度为O(1)

解题思路：
这道题可以宏观考虑，题目要求转圈打印矩阵，可以取左上角（r1，c1）和右下角(r2，c2)的两个元素为边界开始打印，定义一个指针点（r，c），r从r1开始，c从c1开始，当c<c2的时候，c++，r不变，打印元素（1 2 3），c=c2，r < r2时，r++，c不变，打印元素（4 8 1），当r=r2，c > c1 时，c–，r不变，打印元素（4 7 6），当c=c1，r > r1时，r–，c不变，打印元素（9 2 5），这样，一圈元素都打印了，只需改变两个角的点，就可以打印下一圈元素。注意，当指针点移动到四个角时，停止，不打印，可以避免重复打印。

代码：

public class PrintMatrixSprialOrder {
    public static void SprialOrderPrint(int[][] matrix){
        int row1 = 0;
        int col1 = 0;
        int row2 = matrix.length - 1;
        int col2 = matrix[0].length - 1;
        //注意，这里必须是row1 <= row2 && col1 <= col2
        while(row1 <= row2 && col1 <= col2){
            printEdge(matrix, row1++, col1++, row2--, col2--);
        }
    }

    //打印,row1 col1 为左上角元素的坐标，row2 col2为右下角坐标
    private static void printEdge(int[][] matrix, int row1, int col1, int row2, int col2){
        if(row1 == row2){ //row1==row2,说明矩阵只有一列
            while(col1 <= col2){
                System.out.print(matrix[row1][col1++] +" ");
            }

        }else if(col1 == col2){ //col1==col2,说明矩阵只有一行
            while(row1 <= row2){
                System.out.print(matrix[row1][col1++]+ " ");
            }
        }else{
          //指针点
          int curR = row1;
          int curC = col1;
          while(curC < col2){ //打印上面横向的数
              System.out.print(matrix[row1][curC] + " ");
              curC++;
          }
          while(curR < row2){ //打印右边纵向的数
              System.out.print(matrix[curR][col2] + " ");
              curR++;
          }
          while(curC > col1){ //打印下面横向的数
              System.out.print(matrix[row2][curC] + " ");
              curC--;
          }
          while(curR > row1){ //打印左边纵向的数
              System.out.print(matrix[curR][col1] + " ");
              curR--;
          }
        }
     }

• 时间复杂度：O(N*M)
• 空间复杂度：O(1)

2 “之”字形打印矩阵

给定一个矩阵matrix，按照“之”字形的方式打印这个矩阵，

示例

1 2 3 4
5 6 7 8
9 10 11 12
“之”字形打印的结果为：1，2，5，9，6，3，4，7，10，11，8，12

【要求】 额外空间复杂度为O(1)。

解题思路
按之字形打印，可以在横向上设一个点，纵向上设一个点，横向点向右移动，纵向上的点向下移动，当横向点到末尾时，向下移动，纵向上的点到达末尾时，横向移动，这两个点同时移动，每次打印这两个点连成的对角线上的点即可，设置一个布尔类型值，来控制打印方向。

代码

public class PrintMatrixByZhi {
    public static void printByZhi(int[][] matrix){
        int row = matrix.length - 1;
        int col = matrix[0].length - 1;
        int row1 = 0;
        int col1 = 0;
        int row2 = 0;
        int col2 = 0;
        boolean flag = true;
        //结束条件是一个点的下表越界
        while(row1 != row + 1 ){
            printLevel(matrix, row1, col1, row2, col2, flag);
            //当col1=col时，说明点已经到右上角了，让这个点下移，row++
            row1 = col1 == col ? ++row1 : row1;
            col1 = col1 == col ? col: ++col1;
            //注意这里要先算col2,因为判断条件使用的是row,要不然会将左下角的点给跳过去
            col2 = row2 == row ? ++col2 : col2;
            row2 = row2 == row ? row : ++row2;
            flag = !flag;
        }
    }
    //打印两个点形成的对角线上的元素
    private static void printLevel(int[][] matrix, int row1, int col1, int row2, int col2, boolean flag){
        if(flag){
            while(row2 >= row1 ){
                //打印两个点形成的对角线上的点，从下往上打印
                System.out.print(matrix[row2--][col2++] + " ");
            }
        }else{
            //从上往下打印
            while(row1 <= row2 ){
                System.out.print(matrix[row1++][col1--] + " ");
            }
        }
    }

• 事件复杂度：O(N+M)
• 空间复杂度：O(1)

3. 在行列都排好序的矩阵中找数

给定一个有N*M的整型矩阵matrix和一个整数K，matrix的每一行和每一列都是排好序的。实现一个函数，判断K是否在matrix中。

示例

0 1 2 5
2 3 4 7
4 4 4 8
5 7 7 9
如果K为7，返回true；如果K为6，返回false。
【要求】 时间复杂度为O(N+M)，额外空间复杂度为O(1)。

解题思路
矩阵从左到右、从上到下都是按从小到大的顺序排列的，可以从右上角或左下角的数开始找，这样找的好处是，不管当前这个数是大于还是小于目标值，下一个要找的点确定，假如从右上角的数开始，target大于这个数，就向下找，小于这个数，就往左找。

代码

 public static boolean isContains(int[][] matrix, int target){
        int row = 0;
        int col = matrix[0].length - 1;

        while(row < matrix.length && col > 0){
            if(matrix[row][col] > target){
                col--;
            }else if(matrix[row][col] < target){
                row++;
            }else{
                return true;
            }
        }
        return false;
    }

• 时间复杂度：O(N+M)
• 空间复杂度：O(1)

参考
左神算法初级班