精华内容
下载资源
问答
  • Java数组:二维矩阵旋转90度
    2022-02-15 03:26:12
    package way;
    
    public class 矩阵旋转 {
    
    	public static void main(String[] args) {
    		//给你一幅由 N × N 矩阵表示的图像,其中每个像素的大小为 4 字节。
            //	请你设计一种算法,将图像旋转 90 度。
    		int[][] matrix= {
    				{1,2,3},
    				{4,5,6},
    				{7,8,9}};
    		//初始二维数组-读取数组
    		for (int i = 0; i < matrix.length; i++) {
    			for (int j = 0; j < matrix.length; j++) {
    				  System.out.print(matrix[i][j]+" ");
    			}
    			System.out.println(" ");
    		}
            //根据要求执行
    		//1.根据二维数组的行列元素得到相应的规律(可以先用2*2的矩阵推导,如果2*2的矩阵能够适用这个 
             公式,可能说明这个公式适用于绝大多数的矩阵)
            //1.1很明显,这个数组旋转90度时 
            /*[0,0]-->[0,1]
              [0,1]-->[1,1]
              [1,0]-->[0,0]
              [1,1]-->[1,0]
              原先的[i,j]位数据-->[j,len-i]
            */
            //2.创建一个新的二维数组,将旋转后的数组元素添加
    		int len = matrix.length;
    		int l = len-1;
    		int [][]newmatrix=new int[len][len];
    		
    		for (int i = 0; i < len; i++) {
    			for (int j = 0; j < len; j++) {
    				newmatrix[j][l-i]=matrix[i][j];		
    			}
    		}
    		for (int i = 0; i < matrix.length; i++) {
    			for (int j = 0; j < matrix.length; j++) {
    				matrix[i][j]=newmatrix[i][j];
    				System.out.print(matrix[i][j]+" ");
    			}
    			System.out.println(" ");
    		}
    	}
    	}
    

     可以先用2*2的矩阵推导,如果2*2的矩阵能够适用这个 公式,可能说明这个公式适用于绝大多数的矩阵

    更多相关内容
  • 二维矩阵转一维矩阵 * 以列为主,loc=column+row*行数 * 以行为主,loc=row+column*列数 * 三维矩阵转一维矩阵,i(u1个数),j(u2个数),k(u3个数)分别表示三维矩阵 * 以列为主,loc=i*u2*u3+j*u3+k; * 以行为主,...
  • java 二维数组矩阵乘法的实现方法,需要的朋友可以参考一下
  • import java.util.Random; class MatrixTower { public static void main(String[] args) { //声明一个矩阵空间 int[][] matrix = new int[][]{ {-1,12,4,0,7,-5,6,7,7,4,0,0,-5,2,-4}, {-1,65,4,0,7,-5,6...

    在这里插入图片描述

    
    import java.util.Random;
    
    
    class MatrixTower {
    
    
        public static void main(String[] args) {
    
            //声明一个矩阵空间
            int[][] matrix = new int[][]{
                    {-1,12,4,0,7,-5,6,7,7,4,0,0,-5,2,-4},
                    {-1,65,4,0,7,-5,6,1,7,4,0,0,-15,1,-4},
                    {-1,10,4,0,8,-5,2,5,17,4,0,0,-5,6,-4},
                    {-1,2,4,0,14,-5,6,3,7,4,0,0,-34,2,-4},
                    {-1,47,4,0,26,-5,6,9,7,4,0,0,-9,4,-4},
                    {-1,0,14,0,7,-5,6,8,10,4,0,0,4,11,201},
            };
    
    
            //矩阵行长度
            int tmp=matrix[0].length;
            int u = matrix.length-1;
            int v = matrix[u][tmp/2]-1;
    
            // 需求: 最下行 中心列 为中心点 => 起始点
            int startPoint = matrix[u][v];
    
    
            //起始点的行
    
    
            //起始点的列
            int startPointColumn = 0;
    
            //得到起始点的列
            for (int i = 0; i <tmp; i++) {
                if (matrix[u][i] == startPoint) {
                    startPointColumn = i;
                }
            }
    
    
            //随机数类
            Random random = new Random();
    
            //随即矩阵行
            int randomRow = random.nextInt(matrix.length - 1);
            //随机矩阵列
            int randomColumn = random.nextInt(tmp/2-1);
    
    
            maxNumberSum(startPoint, u, startPointColumn, randomColumn, matrix);
    
        }
    
    
        //求移动路径sum
        private static void maxNumberSum(int startPoint, int startPointRow, int startPointColumn,  int randomColumn, int[][] matrix) {
    
    
            System.out.println("当前 起始点:" + startPoint);
    
    
            //左移动 matrix[length - 1][length / 2 - -] startPointColumn--
            // 右移动 matrix[length - 1][length / 2 ++] startPointColumn++
            // 上移动 matrix[(length - 1)--][length / 2 ] startPointRow--
    
            //这里默认为 上移动: matrix[(length - 1)--][length / 2] startPointRow--
    
            System.out.println("矩阵起始行:" + startPointRow);
            System.out.println("矩阵起始列:" + startPointColumn);
            System.out.println("随机列:" + randomColumn);
    
            System.out.println("移动方式 右移动:");
    
            //路径和
            int sum = 0;
    
            do {
    
                int num = matrix[startPointRow][++startPointColumn];
    
                System.out.println("向右移动"+randomColumn + "次 经过 元素:" + num);
                sum += num;
    
            } while (--randomColumn != 0);
    
            startPoint += sum;
    
            System.out.println("路径求合:" + startPoint);
        }
    
    }
    
    
    展开全文
  • 前言 本篇文章主要总结了矩阵的常见运算,以及Java中利用二维数组进行运算的实现 1.矩阵运算 1.矩阵加法 运算前提:多个矩阵的行数和列数相同,我们称它们为同型矩阵,只有是同型矩阵才能进行加减运算。 运算规则:...

    0.前言

    本篇文章主要总结了矩阵的常见运算,以及Java中利用二维数组进行运算的实现

    1.矩阵运算

    1.矩阵加法

    1. 运算前提:多个矩阵的行数和列数相同,我们称它们为同型矩阵,只有是同型矩阵才能进行加减运算。
    2. 运算规则:两个矩阵相同位置的元素进行相加。

    [ 1 2 3 4 5 6 ] + [ 1 2 3 4 5 6 ] = [ 2 4 6 8 10 12 ] \left[ \begin{matrix} 1 & 2 & 3 \\ 4 & 5 & 6 \\ \end{matrix} \right] + \left[ \begin{matrix} 1 & 2 & 3 \\ 4 & 5 & 6 \\ \end{matrix} \right] = \left[ \begin{matrix} 2 & 4 & 6 \\ 8 & 10 & 12 \\ \end{matrix} \right] [142536]+[142536]=[28410612]

    2.矩阵减法

    1. 运算规则:同矩阵加法,对应元素相减即可。

    3.矩阵乘法

    1. 运算前提:两个矩阵的乘法仅当第一个矩阵的列数和另一个矩阵的行数相等。
    2. 运算规则:两个矩阵,第一个矩阵的行和第二个矩阵的列对应元素相乘再相加,m 行 n 列的矩阵 * n 行 k 列的矩阵,得到一个 m 行 k 列的矩阵。
      [ 1 2 3 4 5 6 ] ∗ [ 1 2 3 4 5 6 ] = [ 1 ∗ 1 + 2 ∗ 3 + 3 ∗ 5 = 22 1 ∗ 2 + 2 ∗ 4 + 3 ∗ 6 = 28 4 ∗ 1 + 3 ∗ 5 + 6 ∗ 5 = 49 4 ∗ 2 + 5 ∗ 4 + 6 ∗ 6 = 64 ] = [ 22 28 49 64 ] \left[ \begin{matrix} 1 & 2 & 3 \\ 4 & 5 & 6 \\ \end{matrix} \right] * \left[ \begin{matrix} 1 & 2 \\ 3 & 4 \\ 5 & 6 \\ \end{matrix} \right] = \left[ \begin{matrix} 1*1 + 2*3+3*5 =22& 1* 2 + 2* 4 + 3* 6=28\\ 4 * 1 + 3 * 5 + 6* 5 = 49 & 4*2+5*4+6*6= 64\\ \end{matrix} \right] = \left[ \begin{matrix} 22 & 28 \\ 49 & 64 \\ \end{matrix} \right] [142536]135246=[11+23+35=2241+35+65=4912+24+36=2842+54+66=64]=[22492864]

    4.矩阵转置

    1. 运算规则:将矩阵的第 i 行 第 j 列 转换为 第 j 行 第 i 列
      [ 1 2 3 4 5 6 ] T = [ 1 4 2 5 3 6 ] \left[ \begin{matrix} 1 & 2 & 3 \\ 4 & 5 & 6 \\ \end{matrix} \right] ^T = \left[ \begin{matrix} 1 & 4 \\ 2 & 5 \\ 3 & 6 \\ \end{matrix} \right] [142536]T=123456

    2.Java实现

    public class Matrix {
        public static void main(String[] args) {
            int[][] a = {{1, 2, 3}, {4, 5, 6}};
            int[][] b = {{1, 2}, {3, 4}, {5, 6}};
    
            System.out.println(Arrays.deepToString(randomMatrix(3, 2)));
        }
    
        /**
         * 生成随机矩阵 m行n列
         * @return
         */
        public static int[][] randomMatrix(int m, int n){
            int[][] ans = new int[m][n];
            // 生成随机矩阵
            Random rand = new Random();
            for (int i = 0; i < m; i++)
                for (int j = 0; j < n; j++) {
                    ans[i][j] = rand.nextInt(10);
                }
            return ans;
        }
    
    
        /**
         * 矩阵加减法
         */
        public static int[][] addOrSub(int[][] a, int[][] b, boolean isPlus) {
            // 不满足加减法条件
            if (a.length != b.length || a[0].length != b[0].length) return new int[0][0];
    
            for (int i = 0; i < a.length; i++)
                for (int j = 0; j < a[0].length; j++) {
                    if (isPlus)
                        a[i][j] += b[i][j];
                    else
                        a[i][j] -= b[i][j];
                }
            return a;
        }
    
        /**
         * 矩阵乘法
         */
        public static int[][] multiply(int[][] a, int[][] b) {
            int m = a.length;
            int n = a[0].length;
            int n1 = b.length;
            int k = b[0].length;
            // 不满足乘法条件
            if (n != n1) return new int[0][0];
    
            // 构建一个 m 行 k 列的矩阵
            int[][] ans = new int[m][k];
            for (int i = 0; i < m; i++) {
                for (int j = 0; j < k; j++) {
                    int temp = 0;
                    for (int l = 0; l < n; l++) {
                        temp += a[i][l] * b[l][j];
                    }
                    ans[i][j] = temp;
                }
            }
            return ans;
        }
    
        /**
         * 转置
         */
        public static int[][] zhi(int[][] a) {
            int m = a.length;
            int n = a[0].length;
            int[][] ans = new int[n][m];
            for (int i = 0; i < n; i++)
                for (int j = 0; j < m; j++)
                    ans[i][j] = a[j][i];
            return ans;
        }
    }
    
    
    展开全文
  • 使用二维数组随机生成迷宫,里面总共有三份代码,都是迷宫生成的,相信有一份是适合你的。直接运行main方法就可运行,简单方便。
  • 主要介绍了Java二维数组简单定义与使用方法,结合实例形式简单分析了java二维数组的定义、使用方法及相关注意事项,需要的朋友可以参考下
  • type 数组名[][] type[][] 数组名 如 int array[][]=new int[3][]; 生成3个一维数组array array[0]=new int[2]; 生成第0维的1维数组array[0],含2个int...生成array第一维的一维数组和第二维的一维数组,初始化为0...

    type 数组名[][]
    type[][] 数组名

    int array[][]=new int[3][];
    

    与C/C++不同的,C/C++必须一次指明每一维的长度
    生成3个一维数组array

    array[0]=new int[2];
    

    生成第0维的1维数组array[0],含2个int值,初始化为0;

    array[1]=new int[4];
    array[2]=new int[2];
    

    生成array第一维的一维数组和第二维的一维数组,初始化为0
    也可以声明直接初始化

    int array[][]={{1,2},{3,4,5,6},{7,8}}
    

    两矩阵相加

    public class welcome{
    	public static void main(String[] args){
    		int i,j;
    		int a[][]=new int[3][4];
    		int b[][]= {{1,5,2,8},{5,9,10,-3},{2,7,-5,-18}};
    		int c[][]=new int [3][4];
    		for(i=0;i<3;i++) 
    			for(j=0;j<4;j++) 
    				a[i][j]=(i+1)*(j+2);
    		for(i=0;i<3;i++)
    			for(j=0;j<4;j++)
    				c[i][j]=a[i][j]+b[i][j];
    		for(i=0;i<c.length;i++) {
    			for(j=0;j<c[i].length;j++)
    				System.out.print(c[i][j]+" ");
    			System.out.println();
    		}
    	}
    }
    
    展开全文
  • 如果您想获取行,您需要从每个数组中获取值,然后从这些值中创建一个新数组。你可以手动指定值,或使用一个for循环,像这样......int[][] MyMat = {{0,1,2,3,4}, {9,8,7,6,5}};// get your columns......
  • 主要使用到的技术:java基础语法java面向对象思想java数组,二维数组java异常处理主要步骤和思路:1,制作一个棋盘类。棋盘类里面有行属性,列属性,二维数组属性。有一个打印棋盘的方法。做一个测试类,先打印出...
  • public class testClockwiseOutput {public static void main(String[] args) {//1、构建矩阵数据int[][] arr = getMatrix...}/*** 构建矩阵二维数组* @return*/public static int[][] getMatrix(){//1、创建一个...
  • 由于本人也是java初学者,在代码中已有详细的注释(防止自己将来读不懂自己曾写的代码),所以不在文字方面过多赘述。 补充说明:使用的jdk版本为1.8 package hello; import java.io.BufferedReader; import java.io...
  • Java 二维数组/集合生成排列组合矩阵写在前面代码测试代码打印结果 写在前面 Question:给出任意一个二维数组,要求输出数组元素的所有排列组合 例如: String[][] array = {{"a", "b", "c"}, {"d", "e", "f", "g"},...
  • 若A为NxM阶矩阵 B为MxP阶矩阵,二者相乘之后的矩阵则为NXP阶矩阵 运算过程: 思路 计算并显示出来这个结果 我们则需要 一个计算方法 和 一个显示方法 因此主函数可以写的相当之简单 , 键入想要求解的矩阵的数值 ...
  • 主要介绍了Java编程一维数组转换成二维数组,分享了相关代码示例,小编觉得还是挺不错的,具有一定借鉴价值,需要的朋友可以参考下
  • 主要介绍了java实现二维数组转置的方法,结合实例形式详细分析了java二维数组转置的原理、实现步骤与相关操作技巧,需要的朋友可以参考下
  • 主要介绍了Java编程中二维数组的初始化和基本操作实例,是Java入门学习中的基础知识,需要的朋友可以参考下
  • 展开全部最不严谨的写法(但是可62616964757a686964616fe59b9ee7ad9431333335326163用)下列方法可以不需知道二维数组的宽度和长度,但是不能直接保存,而是输入完成之后才能保存,如果需要更完善的方法,则先输入宽度...
  • 主要介绍了利用Java如何实现顺时针输出螺旋二维数组的方法示例,文中给出了详细的示例代码和注释,相信对大家具有一定的参考价值,有需要的朋友们下面来一起看看吧。
  • /**来 自 时 代 Java - nowjava.com**///package com.nowjava;public class Main {public static void main(String[] argv) throws Exception {double[] arr = new double[] { 34.45, 35.45, 36.67, 37.78, 37.0000....
  • java 二维数组的length

    2022-01-30 23:17:18
    int[i][j] a=new int[i][j] length求得的二维数组长度为行数,及int[i][j]中i为此二位数组的长度, 求列数则为 a[0] .length
  • 任意矩阵二维数组输入,以矩阵形式输出 运行示例 输入: [[3,7,8],[9,11,13],[15,16,17],[23,27,28]] 输出: 3 7 8 9 11 13 15 16 17 23 27 28 思路 用字符串参数对输入进行接受并处理,处理步骤如下: ...
  • NULL 博文链接:https://liangjian103.iteye.com/blog/1101210
  • Java二维数组的三种初始化方式

    千次阅读 2020-05-30 18:19:04
    文章目录方式一 、(动态初始化 1) :方式二、 (动态初始化 2) :方式三、(静态初始化) :二维数组的内存解析 方式一 、(动态初始化 1) : int[][] arr = new int[3][2]; 说明: 定义了名称为arr的二维数组 二维...
  • package practice; public class _2dArrayVerticalSum { public static void main(String[] args) { int targetArr[][] = { { 4, 3, 2, 1 }, { 8, 7, 6, 5 }, { 9, 8, 7, 6 } }; for (int i = 0;...
  • Java 二维数组的四种拷贝方法

    千次阅读 2019-08-29 12:38:28
    Java 二维数组的四种拷贝方法 for 循环 System.arrayCopy() clone() 方法 Arrays.copyOf() Java 二维数组(多维数组)的理解 参考页面 geeksforgeeks Multidimensional Arrays can be defined in simple words as ...
  • Java编程题】将矩阵二维数组上下翻转 输入:[ [ 1, 2, 3 ], [ 4, 5, 6 ], [ 7, 8, 9 ] ] 输出:[ [ 7, 8, 9 ], [ 4, 5, 6 ], [ 1, 2, 3 ] ] Java代码如下: import java.lang.reflect.Array; import java.util.*; ...
  • java 二维数组行列互换

    千次阅读 2020-12-30 17:38:58
    代码需求:对等行等列的二维数组进行 行列 的互换分析过程主对角线是保持不变行列互换即角标互换:[0][1] => [1][0]循环次数:外层循环行,内层循环每一行的列示意图代码实现public class ArrayReverse {public ...
  • 之前给大家讲过java二维数组获取单个元素方面的知识,下面的话就来给大家讲一下java二维数组获取整行元素方面的知识。除去获取单个元素和全部元素之外,还可以单独获取二维数组的某一行中所有元素的值,或者是二维...
  • packagearrayList;/*** 矩阵的集中运算法则:求和,求积,求逆矩阵,转置矩阵......*@...*@parama 矩阵(二维数组)*@paramb 矩阵(二维数组)*@return返回一个矩阵(二维数组)*/public static int[][] add(int [][] a,i...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 32,810
精华内容 13,124
关键字:

java 二维矩阵

java 订阅