矩阵的转置

输入一个方阵(0<N<10),输出此方阵顺时针旋转M(0<=M<1000)次后的方阵,要求:

(1)输入第一行一个正整数(0<N<10)

(2)接下来N行每行N个整数用空格分开,为方阵的数据

(3)接下来一行一个正整数M(0<=M<=10000)

示例:
-- 输入

1 2 3

4 5 6

7 8 9

-- 输出

9 8 7 

6 5 4

3 2 1

说明:不用考虑输入,所有输入都是正常的,严格遵从取值范围。

代码思想:
每一行转为最后一列,依次指向,直至覆盖整个矩阵

 针对于3阶矩阵:

                if (i == 0) { //数组第一行
                    for (int j = 0; j < array.length; j++) {
                        array[j][2] = arrayOri[0][j];
                    }
                }
                if (i == 1) { //数组第二行
                    for (int j = 0; j < array.length; j++) {
                        array[j][1] = arrayOri[1][j];
                    }
                }
                if (i == 2) { //数组第三行
                    for (int j = 0; j < array.length; j++) {
                        array[j][0] = arrayOri[2][j];
                    }
                }

对于n阶矩阵:

  for (int q = 0; q < n; q++) {
                    if(i == q){
                        for (int j = 0; j < array.length; j++) {
                            array[j][array.length-1-q] = arrayOri[q][j];
                        }
                    }
                }

完整代码如下: 

public class Test {
    public static void main(String[] args) {
        //先创建一个2维数组
        Scanner sc = new Scanner(System.in); //输入流
        System.out.println("请输入方阵的阶数;");
        int n = sc.nextInt(); //输入阶数
        int[] arrayOri[] = new int[n][n]; //原始输入数组
        int[] array[] = new int[n][n]; //转换之后的数组
        System.out.println("-- 输入");
        for (int i = 0; i < arrayOri.length; i++) {
            for (int j = 0; j < arrayOri.length; j++) {
                arrayOri[i][j] = sc.nextInt();
                array[i][j] = arrayOri[i][j];
            }
        }
        System.out.println("请输入该方阵顺时针旋转的次数:");
        int m = sc.nextInt();
        for (int p = 1; p <= m; p++) {
            for (int i = 0; i < array.length; i++) {
                for (int q = 0; q < n; q++) {
                    if(i == q){
                        for (int j = 0; j < array.length; j++) {
                            array[j][array.length-1-q] = arrayOri[q][j];
                        }
                    }
                }
            }
        }

        System.out.println("-- 输出");
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array.length; j++) {
                System.out.print(array[i][j] + " ");
            }
            System.out.println();
        }
    }
}

测试结果:

 

相关推荐

  1. 矩阵

    2023-12-22 10:00:03       29 阅读
  2. BC107 矩阵

    2023-12-22 10:00:03       30 阅读
  3. 4.7 矩阵运算(C语言实现)

    2023-12-22 10:00:03       39 阅读
  4. 矩阵运算:加减乘除与#matlab

    2023-12-22 10:00:03       6 阅读

最近更新

  1. TCP协议是安全的吗?

    2023-12-22 10:00:03       18 阅读
  2. 阿里云服务器执行yum,一直下载docker-ce-stable失败

    2023-12-22 10:00:03       19 阅读
  3. 【Python教程】压缩PDF文件大小

    2023-12-22 10:00:03       18 阅读
  4. 通过文章id递归查询所有评论(xml)

    2023-12-22 10:00:03       20 阅读

热门阅读

  1. 2866. 美丽塔 II(单调栈)

    2023-12-22 10:00:03       48 阅读
  2. 技术面试的斗智斗勇III

    2023-12-22 10:00:03       42 阅读
  3. Lua脚本在Redis中的高效应用

    2023-12-22 10:00:03       51 阅读
  4. LeetCode day29

    2023-12-22 10:00:03       55 阅读
  5. 基于OpenCV的视频流处理方法

    2023-12-22 10:00:03       41 阅读
  6. vue和react diff的详解和不同

    2023-12-22 10:00:03       50 阅读
  7. 前端八股文(vue篇)

    2023-12-22 10:00:03       42 阅读
  8. HTML中的6种空格标记

    2023-12-22 10:00:03       43 阅读
  9. WPF DataGrid行渲染

    2023-12-22 10:00:03       47 阅读