跟左神学算法4 基础数据结构(矩阵相关)

内容：

1、转圈打印矩阵问题

2、旋转正方形矩阵问题

3、之字形打印矩阵问题

4、在行和列都排序好的矩阵中找数

1、转圈打印矩阵问题

问题描述：

给定一个整形矩阵matrix,请按照转圈的方式打印它。
            
    例如：        
        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
    要求额外空间复杂度为O(1)

解决思路：

一圈一圈的打印，比如上面的1到16到1为1圈，6到11到6为1圈，主要就是要注意边界问题

代码：

public class RotateOutputMatrix {
    private int M;
    private int N;
    private int[][] arr;
    private final int startValue = 1;
        
        // 初始化矩阵
    public RotateOutputMatrix(int M, int N) {
        this.M = M;
        this.N = N;
        int value = startValue;
        arr = new int[M][N];
        for (int i = 0; i < M; i++) {
            for (int j = 0; j < N; j++) {
                this.arr[i][j] = value++;
            }
        }
    }

    public void printEdge(int a, int b, int c, int d) {
        // 输出一层
        // (a, b) -> 左上角 (c, d) -> 右下角
        if (b == d) {
            // 两个点在一列上
            for (int i = a; i <= c; i++) {
                System.out.print(arr[i][b] + " ");
            }
        } else if (a == c) {
            // 两个点在一行上
            for (int j = b; j <= d; j++) {
                System.out.print(arr[a][j] + " ");
            }
        } else {
            // 两个点不在一行也不在一列上 -> 两个点在对角线上
            int curA = a;
            int curB = b;
            while (curB < d) {
                System.out.print(arr[curA][curB] + " ");
                curB++;
            }
            while (curA < c) {
                System.out.print(arr[curA][curB] + " ");
                curA++;
            }
            while (curB > b) {
                System.out.print(arr[curA][curB] + " ");
                curB--;
            }
            while (curA > a) {
                System.out.print(arr[curA][curB] + " ");
                curA--;
            }
        }
    }

    public void printAllEdge() {
        // 输出所有的层
        int a = 0;
        int b = 0;
        int c = this.M - 1;
        int d = this.N - 1;
        while (a <= c && b <= d) {
            printEdge(a++, b++, c--, d--);
        }
    }
    
    // test
    public void printMartix(){
        for(int i=0; i<arr.length; i++){
            for(int j=0; j<arr[0].length; j++){
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }
    }

    public static void main(String[] args) {
        RotateOutputMatrix test = new RotateOutputMatrix(4, 4);
        test.printMartix();
        System.out.println("=================");
        test.printAllEdge();
    }
}

2、旋转正方形矩阵问题

问题描述：

给定一个整型正方形矩阵matrix,请把该矩阵调整成 顺时针旋转90度的样子

思路：

和上面那道题类似，一层一层的转，每一层中又可以分成若干旋转次数进行转(旋转次数=边上的元素个数-1)

比如:

1 2 3 

4 5 6

7 8 9

最外层是1 2 3 6 9 8 7 4 可以先转1 3 9 7 再转 2 6 8 4

代码：

public class RotateSquare90 {
    private int M;
    private int[][] arr;
    private final int startValue = 1;

    public RotateSquare90(int M) {
        this.M = M;
        int value = startValue;
        arr = new int[M][M];
        for (int i = 0; i < M; i++) {
            for (int j = 0; j < M; j++) {
                this.arr[i][j] = value++;
            }
        }
    }

    public void rotateEdge(int a, int b, int c, int d) {
        // 旋转一层
        int times = c - a;
        int tmp = 0;
        for (int i = 0; i < times; i++) {
            tmp = arr[a][b + i];
            arr[a][b + i] = arr[c - i][b];
            arr[c - i][b] = arr[c][d - i];
            arr[c][d - i] = arr[a + i][d];
            arr[a + i][d] = tmp;
        }
    }

    public void rotateAllEdge() {
        // 旋转所有层
        int i = 0;
        int j = 0;
        int m = this.M - 1;
        int n = this.M - 1;
        while(i<=m&&j<=n){
            rotateEdge(i++, j++, m--, n--);
        }
    }

    // for test
    public void printMatrix() {
        int[][] m = this.arr;
        for (int i = 0; i < m.length; i++) {
            for (int j = 0; j < m[0].length; j++) {
                System.out.print(m[i][j] + " ");
            }
            System.out.println();
        }
    }

    public static void main(String[] args) {
        RotateSquare90 test = new RotateSquare90(4);
        test.printMatrix();
        test.rotateAllEdge();
        test.printMatrix();
    }

}

3、之字形打印矩阵问题

问题描述：

给定一个矩阵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)

思路：

同样还是分层，左下到右上为1层，用一个布尔值表示是从上到下还是从下到上，然后最外层控制从开始到结束

代码：

public class ZigZagPrintMatrix {
    private int M;
    private int N;
    private int[][] arr;
    private final int startValue = 1;

    public ZigZagPrintMatrix(int M, int N) {
        this.M = M;
        this.N = N;
        int value = startValue;
        arr = new int[M][N];
        for (int i = 0; i < M; i++) {
            for (int j = 0; j < N; j++) {
                this.arr[i][j] = value++;
            }
        }
    }

    public void printLevel(int a, int b, int c, int d, boolean f) {
        // 打印一条斜线 f为true表示从右上到左下打印 
        if (f) {
            // (a, b) -> (c, d)
            while (a != c + 1) {
                System.out.print(arr[a++][b--] + " ");
            }
        } else {
            // (c, d) -> (a, b)
            while (d != b + 1) {
                System.out.print(arr[c--][d++] + " ");
            }
        }
    }

    public void printMatrixZigZag() {
        // 打印所有斜线
        int a = 0;
        int b = 0;
        int c = 0;
        int d = 0;
        int endR = M - 1;
        int endC = N - 1;
        boolean fromUp = false;
        while (a != endR + 1) {
            printLevel(a, b, c, d, fromUp);
            a = b == endC ? a + 1 : a;
            b = b == endC ? b : b + 1;
            d = c == endR ? d + 1 : d;
            c = c == endR ? c : c + 1;
            fromUp = !fromUp;
        }
        System.out.println();
    }

    // test
    public void printMartix() {
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[0].length; j++) {
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }
    }

    public static void main(String[] args) {
        ZigZagPrintMatrix test = new ZigZagPrintMatrix(3, 4);
        test.printMartix();
        test.printMatrixZigZag();
    }
}

4、在行和列都排序好的矩阵中找数

问题描述：

给定一个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)

思路：

思路: 从右上角开始对比 如果当前数比K大那么当前数往左走 如果当前数比K小那么当前数往下走
          直到找到数K或者数走到边界不能再走为止 时间复杂度为O(N+M)
        
        O(N+M)对应的最坏情况(找不到数或数就在左下角的位置):
            1 3 5 6
            2 5 7 9 
            4 6 8 10   
            k = 4    

代码：

private static boolean find(int[][] arr, int num) {
    int row = 0;
    int col = arr[0].length - 1;
    while (row != arr[0].length - 1 && col != 0) {
        if (arr[row][col] == num) {
            return true;
        } else if (arr[row][col] > num) {
            col--;
        } else {
            row++;
        }
    }

    return false;
}