19.顺时针打印矩阵 Java

本文介绍了一种按顺时针方向打印矩阵元素的算法,首先获取矩阵的行和列数,然后通过旋转的方式逐个打印元素,特别处理了单行和单列的情况。提供了完整的Java实现代码。

题目描述

输入一个矩阵,按照从外向里以顺时针的顺序依次打印出每一个数字,例如,如果输入如下4 X 4矩阵: 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.

 

解题思路

先得到矩阵的行和列数,然后依次旋转打印数据,一次旋转打印结束后,往对角分别前进和后退一个单位。
要注意单行和单列的情况。

参考代码
import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> printMatrix(int [][] matrix) {
        int row = matrix.length;
        int col = matrix[0].length;
        ArrayList<Integer> res = new ArrayList<>();

        if(row == 0 && col == 0)
            return res;
        int left = 0, right = col - 1, top = 0, bottom = row - 1;
        while(left <= right && top <= bottom){
            //上:从左到右
            for(int i=left; i<=right; i++)
                res.add(matrix[top][i]);
            //右:从上到下
            for(int i=top+1; i<=bottom; i++)
                res.add(matrix[i][right]);
            //下:从右到左
            if(top != bottom){
                //防止单行情况
                for(int i=right-1; i>=left; i--)
                    res.add(matrix[bottom][i]);
            }
            //左:从下到上
            if(left != right){
                //防止单列情况
                for(int i=bottom-1; i>top; i--)
                    res.add(matrix[i][left]);
            }
            left++; right--; top++; bottom--;
        }
        return res;
    }
}

转载于:https://www.cnblogs.com/feicheninfo/p/10563749.html

### 矩阵操作与算法在Java中的实现 矩阵操作在Java中是一个常见的任务,特别是在科学计算、图像处理机器学习等领域。Java提供了多种方式来实现矩阵操作,包括基本的矩阵乘法、矩阵转置、矩阵旋转等。以下将详细介绍几种常见的矩阵操作及其在Java中的实现方式。 #### 1. 矩阵乘法 矩阵乘法是矩阵操作中最基本的操作之一。给定两个矩阵 $ A $ $ B $,它们的乘积 $ C $ 是一个新矩阵,其中每个元素 $ C[i][j] $ 是 $ A $ 的第 $ i $ 行与 $ B $ 的第 $ j $ 列的点积。 ```java public class MatrixMultiplication { public static int[][] multiply(int[][] A, int[][] B) { int rowsA = A.length; int colsA = A[0].length; int colsB = B[0].length; int[][] result = new int[rowsA][colsB]; for (int i = 0; i < rowsA; i++) { for (int j = 0; j < colsB; j++) { for (int k = 0; k < colsA; k++) { result[i][j] += A[i][k] * B[k][j]; } } } return result; } public static void main(String[] args) { int[][] A = { {1, 2}, {3, 4} }; int[][] B = { {5, 6}, {7, 8} }; int[][] C = multiply(A, B); // 输出结果矩阵 C for (int i = 0; i < C.length; i++) { for (int j = 0; j < C[i].length; j++) { System.out.print(C[i][j] + " "); } System.out.println(); } } } ``` #### 2. 矩阵转置 矩阵转置是指将矩阵的行列互换,即原来的 $ A[i][j] $ 变为 $ A^T[j][i] $。 ```java public class MatrixTranspose { public static int[][] transpose(int[][] matrix) { int rows = matrix.length; int cols = matrix[0].length; int[][] result = new int[cols][rows]; for (int i = 0; i < rows; i++) { for (int j = 0; j < cols; j++) { result[j][i] = matrix[i][j]; } } return result; } public static void main(String[] args) { int[][] matrix = { {1, 2, 3}, {4, 5, 6} }; int[][] transposed = transpose(matrix); // 输出转置后的矩阵 for (int i = 0; i < transposed.length; i++) { for (int j = 0; j < transposed[i].length; j++) { System.out.print(transposed[i][j] + " "); } System.out.println(); } } } ``` #### 3. 矩阵旋转 矩阵旋转是指将矩阵中的元素按照某个方向(通常是顺时针或逆时针)进行旋转。例如,顺时针旋转90度可以通过先转置矩阵,然后每行反转来实现。 ```java public class MatrixRotation { public static void rotate(int[][] matrix) { int n = matrix.length; // 转置矩阵 for (int i = 0; i < n; i++) { for (int j = i; j < n; j++) { int temp = matrix[i][j]; matrix[i][j] = matrix[j][i]; matrix[j][i] = temp; } } // 反转每一行 for (int i = 0; i < n; i++) { for (int j = 0; j < n / 2; j++) { int temp = matrix[i][j]; matrix[i][j] = matrix[i][n - 1 - j]; matrix[i][n - 1 - j] = temp; } } } public static void main(String[] args) { int[][] matrix = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} }; rotate(matrix); // 输出旋转后的矩阵 for (int i = 0; i < matrix.length; i++) { for (int j = 0; j < matrix[i].length; j++) { System.out.print(matrix[i][j] + " "); } System.out.println(); } } } ``` #### 4. 分块矩阵乘法 分块矩阵乘法是一种优化技术,通过将大矩阵划分为较小的子矩阵(块),然后对这些子矩阵进行独立的乘法运算,从而提高计算效率。这种方法可以利用缓存局部性,减少内存访问的开销。 ```java public class BlockMatrixMultiplication { public static int[][] multiply(int[][] A, int[][] B, int blockSize) { int n = A.length; int[][] result = new int[n][n]; for (int i = 0; i < n; i += blockSize) { for (int j = 0; j < n; j += blockSize) { for (int k = 0; k < n; k += blockSize) { // 对每个块进行乘法运算 multiplyBlock(A, B, result, i, j, k, blockSize); } } } return result; } private static void multiplyBlock(int[][] A, int[][] B, int[][] C, int i, int j, int k, int blockSize) { for (int x = i; x < Math.min(i + blockSize, A.length); x++) { for (int y = j; y < Math.min(j + blockSize, B[0].length); y++) { for (int z = k; z < Math.min(k + blockSize, A[0].length); z++) { C[x][y] += A[x][z] * B[z][y]; } } } } public static void main(String[] args) { int[][] A = { {1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}, {13, 14, 15, 16} }; int[][] B = { {17, 18, 19, 20}, {21, 22, 23, 24}, {25, 26, 27, 28}, {29, 30, 31, 32} }; int blockSize = 2; int[][] result = multiply(A, B, blockSize); // 输出结果矩阵 for (int i = 0; i < result.length; i++) { for (int j = 0; j < result[i].length; j++) { System.out.print(result[i][j] + " "); } System.out.println(); } } } ``` #### 5. 并行矩阵乘法 为了进一步提高矩阵乘法的性能,可以使用多线程并行计算。Java的`ForkJoinPool`框架非常适合用于并行化矩阵乘法。 ```java import java.util.concurrent.RecursiveAction; import java.util.concurrent.ForkJoinPool; public class ParallelMatrixMultiplication extends RecursiveAction { private static final int THRESHOLD = 64; private int[][] A; private int[][] B; private int[][] C; private int row; public ParallelMatrixMultiplication(int[][] A, int[][] B, int[][] C, int row) { this.A = A; this.B = B; this.C = C; this.row = row; } @Override protected void compute() { if (A.length <= THRESHOLD) { multiplyRow(); } else { int mid = row + (A.length - row) / 2; ParallelMatrixMultiplication left = new ParallelMatrixMultiplication(A, B, C, row); ParallelMatrixMultiplication right = new ParallelMatrixMultiplication(A, B, C, mid); left.fork(); right.compute(); left.join(); } } private void multiplyRow() { int n = A.length; for (int i = row; i < Math.min(row + THRESHOLD, n); i++) { for (int j = 0; j < n; j++) { for (int k = 0; k < n; k++) { C[i][j] += A[i][k] * B[k][j]; } } } } public static void main(String[] args) { int n = 1024; int[][] A = new int[n][n]; int[][] B = new int[n][n]; int[][] C = new int[n][n]; // 初始化矩阵 A B for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { A[i][j] = i + j; B[i][j] = i - j; } } ForkJoinPool pool = new ForkJoinPool(); ParallelMatrixMultiplication task = new ParallelMatrixMultiplication(A, B, C, 0); pool.invoke(task); // 输出结果矩阵的部分内容 for (int i = 0; i < 10; i++) { for (int j = 0; j < 10; j++) { System.out.print(C[i][j] + " "); } System.out.println(); } } } ``` ### 总结 矩阵操作在Java中是非常重要的,尤其是在处理大规模数据时。通过基本的矩阵乘法、转置、旋转,以及更高级的分块矩阵乘法并行计算,可以显著提高程序的性能。上述代码示例展示了如何在Java中实现这些常见的矩阵操作,并且可以根据具体需求进行扩展优化。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值