算法之矩阵_算法矩阵123456-优快云博客

本文链接：https://blog.youkuaiyun.com/dhrtyuhrthfgdhtgfh/article/details/90316062

博客围绕矩阵问题展开，涵盖转圈打印、旋转正方形、之字形打印矩阵，以及在行列有序矩阵中找数等问题，还涉及岛问题。针对各问题给出题目、要求、整体思路并附上代码，额外空间复杂度多要求为O(1)，部分有时间复杂度要求。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

# 矩阵问题

转圈打印矩阵

【题目】给定一个整型矩阵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)。
整体思想：从外圈向内圈逐层打印

代码

package day03;

public class SpiralPrintMatrix {

    public static void spiralPrintMatrix(int [] [] arr){
        int tR=0;
        int tC=0;
        int dR=arr.length-1;
        int dC=arr[0].length-1;
        while (tR <= dR && tC <= dC) {
            printEdge(arr,tR++, tC++, dR--, dC--);
        }
    }

    private static void printEdge(int [] [] arr,int tR, int tC, int dR, int dC) {
        if (tR == dR) {
            for (int i = tC; i <= dC; i++) {
                System.out.print(arr[tR][i]+" ");
            }
        }
        if (tC == dC) {
            for (int i = tR; i <= dR; i++) {
                System.out.print(arr[i][tC] + " ");
            }
        }

        if (tR != dR && tC != dC) {
            int curC=tC;
            int curR=tR;
            while (curC < dC) {
                System.out.print(arr[tR][curC++]+" ");
            }
            while (curR < dR) {
                System.out.print(arr[curR++][dC]+" ");
            }
            while (tC < dC) {
                System.out.print(arr[dR][dC--]+" ");
            }
            while (tR < dR) {
                System.out.print(arr[dR--][tC]+" ");
            }
        }
    }


    public static void main(String[] args) {
        int[][] matrix = { { 1, 2, 3, 4 }, { 5, 6, 7, 8 }, { 9, 10, 11, 12 },
                { 13, 14, 15, 16 } };
        spiralPrintMatrix(matrix);

    }
}

旋转正方形矩阵

【题目】给定一个整型正方形矩阵matrix，请把该矩阵调整成
顺时针旋转90度的样子。
【要求】额外空间复杂度为O(1)。
整体思路：从外圈向内圈逐层旋转

代码

package day03;

public class RotateMatrix {
    public static void romateMatrix(int[][] matrix) {
        int tR=0;
        int tC=0;
        int dR=matrix.length-1;
        int dC=matrix[0].length-1;
        while (tR <= dR && tC <= dC) {
            romateEdge(matrix, tR++, tC++, dR--, dC--);
        }
    }

    private static void romateEdge(int[][] matrix, int tR, int tC, int dR, int dC) {
        int times=dC-tC;
        for (int i = 0; i < times; i++) {
            int temp = matrix[tR][tC + i];
            matrix[tR][tC + i] = matrix[dR-i][tC];
            matrix[dR-i][tC]=matrix[dR][dC-i];
            matrix[dR][dC - i] = matrix[tR + i][dC];
            matrix[tR + i][dC] = temp;
        }
    }

    public static void printMatrix(int[][] matrix) {
        for (int i = 0; i != matrix.length; i++) {
            for (int j = 0; j != matrix[0].length; j++) {
                System.out.print(matrix[i][j] + " ");
            }
            System.out.println();
        }
    }

    public static void main(String[] args) {
        int[][] matrix = { { 1, 2, 3, 4 }, { 5, 6, 7, 8 }, { 9, 10, 11, 12 },
                { 13, 14, 15, 16 } };
        printMatrix(matrix);
        romateMatrix(matrix);
        System.out.println("=========");
        printMatrix(matrix);

    }
}

之字形打印矩阵

“之”字形打印矩阵
【题目】给定一个矩阵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)。
整体思想：一开始准备两个点，两个点的起始位置都是数组的matrix[0][0]开始，第一个点从左往右走，走到最右边了就往下走，第二个点从上往下走，走到最下边了往右走。在准备一个boolean类型的变量，记录应该从右往左打印还是从左往右打印。

代码

package day03;

public class ZigPrintMatrix {

    public static void zigPrintMatrix(int [] [] matrix) {
        int aR=0;
        int aC=0;
        int bR=0;
        int bC=0;
        int endR=matrix.length-1;
        int endC=matrix[0].length-1;
        boolean formUp=false;
        while (aR != endR+1) {
            printLevel(matrix, aR, aC, bR, bC,formUp);
            aR = aC == endC ? aR+1 : aR;
            aC = aC == endC ? aC : aC+1;
            bC = bR == endR ? bC+1 : bC;
            bR = bR == endR ? bR : bR+1;
            formUp = !formUp;
        }
    }

    private static void printLevel(int[][] matrix, int aR, int aC, int bR, int bC,boolean formUp) {
        if (formUp) {
            while (aC >= bC ) {
                System.out.print(matrix[aR++][aC--]+" ");
            }
        } else {
            while (bC<=aC) {
                System.out.print(matrix[bR--][bC++]+" ");
            }
        }
    }


    public static void main(String[] args) {
        int[][] martix = {{1, 2, 3, 4}, {2,3,4,5}, {4,5,6,7}, {8,9,10,11}};
        zigPrintMatrix(martix);
    }
}

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

【题目】给定一个有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。那么将参考点往下一行移，只要找到比K小的数，再将参考点往左移。

代码

package day03;

public class FindNumInMatrix {

    public static boolean findNumInMatrix(int num, int[][] matrix) {
        int endR = matrix.length - 1;
        int endC = matrix[0].length-1;
        int tR = 0;
        int tC = endC;
        boolean isContain = false;
        while (tR <= endR && tC > -1) {
            if (matrix[tR][tC] < num) {
                tR++;
            } else if (matrix[tR][tC] > num) {
                tC--;
            } else {
                isContain = true;
                break;
            }

        }
        return isContain;
    }


    public static void main(String[] args) {
        int[][] martix = {{1, 2, 3, 4}, {2,3,4,5}, {4,5,6,7}, {8,9,10,11}};
        System.out.println(findNumInMatrix(1,martix));
    }
}

##岛问题(还可以用并查集结构解决)

一个矩阵中只有0和1两种值，每个位置都可以和自己的上、下、左、右四个位置相连，如果有一片1连在一起，这个部分叫做一个岛，求一个矩阵中有多少个岛？
举例：
0 0 1 0 1 0
1 1 1 0 1 0
1 0 0 1 0 0
0 0 0 0 0 0
这个矩阵中有三个岛。
思路：遍历矩阵，每次遍历遇到1就把1变成2，而且把这个1相邻的位置也变成2。

代码

package day05;

public class Islands {

    public static int countIslands(int [][] matrix) {
        if (matrix == null || matrix[0] == null) {
            return 0;
        }
        int M=matrix.length;
        int N=matrix[0].length;
        int res=0;
        for (int i = 0; i < M; i++) {
            for (int j = 0; j < N; j++) {
                if (matrix[i][j] == 1) {
                    res++;
                    infect(matrix, M, N, i, j);
                }
            }
        }
        return res;
    }

    private static void infect(int[][] matrix, int M, int N, int i, int j) {
        if (i>=M || j>=N || i<0 || j<0 || matrix[i][j] != 1) {
            return;
        }
        matrix[i][j]=2;
        infect(matrix,M,N,i-1,j);
        infect(matrix,M,N,i+1,j);
        infect(matrix,M,N,i,j-1);
        infect(matrix,M,N,i,j+1);
    }


    public static void main(String[] args) {
        int[][] m1 = {  { 0, 0, 0, 0, 0, 0, 0, 0, 0 },
                { 0, 1, 1, 1, 0, 1, 1, 1, 0 },
                { 0, 1, 1, 1, 0, 0, 0, 1, 0 },
                { 0, 1, 1, 0, 0, 0, 0, 0, 0 },
                { 0, 0, 0, 0, 0, 1, 1, 0, 0 },
                { 0, 0, 0, 0, 1, 1, 1, 0, 0 },
                { 0, 0, 0, 0, 0, 0, 0, 0, 0 }, };
        System.out.println(countIslands(m1));

        int[][] m2 = {  { 0, 0, 0, 0, 0, 0, 0, 0, 0 },
                { 0, 1, 1, 1, 1, 1, 1, 1, 0 },
                { 0, 1, 1, 1, 0, 0, 0, 1, 0 },
                { 0, 1, 1, 0, 0, 0, 1, 1, 0 },
                { 0, 0, 0, 0, 0, 1, 1, 0, 0 },
                { 0, 0, 0, 0, 1, 1, 1, 0, 0 },
                { 0, 0, 0, 0, 0, 0, 0, 0, 0 }, };
        System.out.println(countIslands(m2));

    }
}