在数学中，矩阵（Matrix）是一个按照长方阵列排列的复数或实数集合 [1] ，最早来自于方程组的系数及常数所构成的方阵。这一概念由19世纪英国数学家凯利首先提出。
矩阵是高等代数学中的常见工具，也常见于统计分析等应用数学学科中。 [2] 在物理学中，矩阵于电路学、力学、光学和量子物理中都有应用；计算机科学中，三维动画制作也需要用到矩阵。 矩阵的运算是数值分析领域的重要问题。将矩阵分解为简单矩阵的组合可以在理论和实际应用上简化矩阵的运算。对一些应用广泛而形式特殊的矩阵，例如稀疏矩阵和准对角矩阵，有特定的快速运算算法。关于矩阵相关理论的发展和应用，请参考《矩阵理论》。在天体物理、量子力学等领域，也会出现无穷维的矩阵，是矩阵的一种推广。
数值分析的主要分支致力于开发矩阵计算的有效算法，这是一个已持续几个世纪以来的课题，是一个不断扩大的研究领域。 矩阵分解方法简化了理论和实际的计算。 针对特定矩阵结构（如稀疏矩阵和近角矩阵）定制的算法在有限元方法和其他计算中加快了计算。 无限矩阵发生在行星理论和原子理论中。 无限矩阵的一个简单例子是代表一个函数的泰勒级数的导数算子的矩阵 [3]
二维数组的打印。
package 案例回顾47;
import java.util.Scanner;
/**
*
* @author MZFAITHDREAM
*
*/
public class 二维数组的打印 {
int [] []arrays=null;
private void init() {
Scanner scanner=new Scanner(System.in);
int n=scanner.nextInt();
scanner.close();
arrays=new int [n][n];
int num=0;
for (int i = 0; i < arrays.length; i++) {
for (int j = 0; j < arrays.length; j++) {
arrays[i][j]=++num;
System.out.print(arrays[i][j]+"\t");
}
System.out.println();
}
}
public static void main(String[] args) {
new 二维数组的打印().init();
}
}
矩阵顺时针針打印。
package 第四章矩阵知识讲解;
import java.util.Scanner;
/**
* 1.随机给定一个二维数组，要求按照顺时针打印数字
* @author lenovo-1
*
* 顺时针針打印
*
*/
public class Demo1 {
int[][] nums=null;
private void init() {
System.out.println("输入二维数组的阶数:");
Scanner scanner=new Scanner(System.in);
int n=scanner.nextInt();
scanner.close();
nums=new int[n][n];
int num=0;
for (int i = 0; i < nums.length; i++) {
for (int j = 0; j < nums[i].length; j++) {
nums[i][j]=++num;
System.out.print(nums[i][j]+"\t");
}
System.out.println();
}
print();
}
private void print() {
System.out.println("结果为:");
//确定好当前二维数组的范围
int x1=0,y1=0,x2=nums.length-1,y2=nums[0].length-1;
//控制移动的圈数
while (x1<=x2&&y1<=y2) {
//定义一个移动点坐标
int x=x1,y=y1;
//向右移动，x不动，y在增加，但不能超出y2的边界
while (y<=y2) {
System.out.print(nums[x][y++]+"\t");
}
//将移动点的纵坐标赋值为y2
y=y2;
//x=x+1;
x++;
//向下移动
while (x<=x2) {
System.out.print(nums[x++][y]+"\t");
}
x=x2;
y--;
//向左移动
while (y>=y1) {
System.out.print(nums[x][y--]+"\t");
}
y=y1;
x--;
//向上移动
while (x>x1) {
System.out.print(nums[x--][y]+"\t");
}
//让范围缩小
x1++;y1++;x2--;y2--;
}
}
public static void main(String[] args) {
new Demo1().init();
}
}
矩阵逆時針打印
package 第四章矩阵知识讲解;
import java.util.Scanner;
/**
* 逆時針
* @author lenovo
*
*/
public class Demo2 {
int[][] nums=null;
private void init() {
// TODO Auto-generated method stub
System.out.println("输入二维数组的阶数:");
Scanner scanner=new Scanner(System.in);
int n=scanner.nextInt();
scanner.close();
nums=new int[n][n];
int num=0;
for (int i = 0; i < nums.length; i++) {
for (int j = 0; j < nums[i].length; j++) {
nums[i][j]=++num;
System.out.print(nums[i][j]+"\t");
}
System.out.println();
}
print();
}
private void print() {
System.out.println("结果:");
//確定二維數組的范围
int x1=0,y1=0,x2=nums.length-1,y2=nums[0].length-1;
while (x1<=x2&&y1<=y2) {
//定义一个移动点坐标
int x=x1,y=y1;
//向下移动，在同一列移动，x在增加，y不变
while (x<=x2) {
System.out.print(nums[x++][y]+"\t");
}
x=x2;
y++;
//向右走，同一行，x不变，y在增加
while (y<=y2) {
System.out.print(nums[x][y++]+"\t");
}
y=y2;
x--;
//向上走，同一列，y不变，x在递减
while (x>=x1) {
System.out.print(nums[x--][y]+"\t");
}
x=x1;
y--;
//向左走，同一行，x不变，y在递减
while (y>y1) {
System.out.print(nums[x][y--]+"\t");
}
x1++;y1++;x2--;y2--;
}
}
public static void main(String[] args) {
// TODO Auto-generated method stub
new Demo2().init();
}
}
矩阵中一个为0XY全部为0.
package 第四章矩阵知识讲解;
import java.util.Random;
import java.util.Scanner;
public class Demo3 {
int[][] nums=null;
private void init() {
System.out.println("输入数组的阶数:");
Scanner scanner=new Scanner(System.in);
int n=scanner.nextInt();
scanner.close();
nums=new int[n][n];
for (int i = 0; i < nums.length; i++) {
for (int j = 0; j < nums[i].length; j++) {
//随机性产生0
nums[i][j]=Math.random()>0.1?new Random().nextInt(9)+1:0;
System.out.print(nums[i][j]+"\t");
}
System.out.println();
}
print();
}
private void print() {
System.out.println("结果:");
//创建两个一维数组，分别用于记录为0的横纵坐标
int[] row=new int[nums.length];
int[] col=new int[nums[0].length];
//循环遍历所有的点
for (int i = 0; i < nums.length; i++) {
for (int j = 0; j < nums[i].length; j++) {
if (nums[i][j]==0) {
row[i]=1;
col[j]=1;
}
}
}
//判断两个一维数组中记录的下标的位置所在的整行和整列清零
for (int i = 0; i < nums.length; i++) {
for (int j = 0; j < nums[i].length; j++) {
if (row[i]==1||col[j]==1) {
nums[i][j]=0;
}
System.out.print(nums[i][j]+"\t");
}
System.out.println();
}
}
public static void main(String[] args) {
new Demo3().init();
}
}
算法第四章矩阵你真的了解吗？二维数组的打印。矩阵顺时针針打印。矩阵逆時針打印矩阵中一个为0XY全部为0.矩阵中一个为0XY全部为0.中进行数值累加。 給定一个二维数组，Z型打印。给定一个二维数组，由1和0组成，从二维数组中找出以连续的1为边框的最大子二维数组的阶数 随机产生一维数组，可能包含正数和负数，求连续的最大累加和。 转方阵； 矩阵中一个为0XY全部为0.中进行数值累加。
package 第四章矩阵知识讲解;
import java.util.Random;
import java.util.Scanner;
/**
*
* 生成包含0的二维数组，找出0所在的行列，
* 反找行和列中没有0 的坐标，该坐标为中心，将行和列的值做累加
*
*/
public class Demo4 {
int nums[][]=null;
//创建一个和原数组一模一样的临时的二维数组
int[][] temp=null;
private void init() {
System.out.println("输入二维数组的阶数:");
Scanner scanner=new Scanner(System.in);
int n=scanner.nextInt();
scanner.close();
//初始化数组
nums=new int[n][n];
temp=new int[n][n];
for (int i = 0; i < nums.length; i++) {
for (int j = 0; j < nums[i].length; j++) {
nums[i][j]=Math.random()>0.2?new Random().nextInt(5)+1:0;
System.out.print(nums[i][j]+"\t");
}
System.out.println();
}
print();
}
private void print() {
System.out.println("结果:");
int[] row=new int[nums.length];
int[] col=new int[nums[0].length];
//循环遍历二维数组的每一个值，找出等于的横纵坐标
for (int i = 0; i < nums.length; i++) {
for (int j = 0; j < nums[i].length; j++) {
//判断是否为0
if (nums[i][j]==0) {
//将横坐标，纵坐标在一维数组中的位置标记为1
row[i]=1;
col[j]=1;
}
}
}
for (int i = 0; i < nums.length; i++) {
for (int j = 0; j < nums[i].length; j++) {
//如果两个一维数组中，横坐标即没有被标记，纵坐标也没有被标记
if (row[i]!=1&&col[j]!=1) {
//说明该数字所在的行和列中都没有出现0
//定义一个变量，作为累加和
int sum=0;
//累加行
for (int k = 0; k < nums.length; k++) {
sum+=nums[i][k];
}
//累加列
for (int k = 0; k < nums.length; k++) {
sum+=nums[k][j];
}
//因为行和列的累加，该值本身参与累加两次
//减掉一次
sum-=nums[i][j];
temp[i][j]=sum;
}
}
}
//输出改变后的二维数组
for (int i = 0; i < nums.length; i++) {
for (int j = 0; j < nums[i].length; j++) {
if (temp[i][j]>0) {
nums[i][j]=temp[i][j];
}
System.out.print(nums[i][j]+"\t");
}
System.out.println();
}
}
public static void main(String[] args) {
new Demo4().init();
}
}
給定一个二维数组，Z型打印。
package 第四章矩阵知识讲解;
import java.util.Scanner;
/**
* 給定一个二维数组，Z型打印
*
*
*/
public class Demo6 {
int[][] nums=null;
private void init() {
System.out.println("输入二维数组的阶数:");
Scanner scanner=new Scanner(System.in);
int n=scanner.nextInt();
scanner.close();
nums=new int[n][n];
int m=1;
for (int i = 0; i < nums.length; i++) {
for (int j = 0; j < nums[i].length; j++) {
nums[i][j]=m++;
System.out.print(nums[i][j]+"\t");
}
System.out.println();
}
print();
}
private void print() {
//设置起点坐标和终点坐标
int x1=0,y1=0;
int x2=nums.length-1,y2=nums[0].length-1;
boolean l2r=true;//从左往右
while (x1<=x2&&y1<=y2) {
//从左往右
if (l2r) {
System.out.println(nums[x1][y1]+"\t");
if (x1==0&&y1<y2) {
//在第一行，没有到最后一列，平移然后变向
y1++;
l2r=!l2r;
}else if (y1==y2) {
//到最后一列
x1++;
l2r=!l2r;
}else {
//上坡
x1--;
y1++;
}
}else {
System.out.print(nums[x1][y1]+"\t");
//从右往左
if (y1==0&&x1<x2) {
x1++;
l2r=!l2r;
}else if (x1==x2) {
//到最后一行
y1++;
l2r=!l2r;
}else {
//下坡
x1++;
y1--;
}
}
}
}
public static void main(String[] args) {
new Demo6().init();
}
}
算法第四章矩阵你真的了解吗？二维数组的打印。矩阵顺时针針打印。矩阵逆時針打印矩阵中一个为0XY全部为0.矩阵中一个为0XY全部为0.中进行数值累加。 給定一个二维数组，Z型打印。给定一个二维数组，由1和0组成，从二维数组中找出以连续的1为边框的最大子二维数组的阶数 随机产生一维数组，可能包含正数和负数，求连续的最大累加和。 转方阵； 给定一个二维数组，由1和0组成，从二维数组中找出以连续的1为边框的最大子二维数组的阶数
package 第四章矩阵知识讲解;
import java.util.Scanner;
/**
*
* 给定一个二维数组，由1和0组成，从二维数组中找出以连续的1为边框的最大子二维数组的阶数
*
*/
public class Demo7 {
int[][] nums=null;
private void init() {
System.out.println("输入二维数组的阶数:");
Scanner scanner=new Scanner(System.in);
int z=scanner.nextInt();
scanner.close();
nums=new int[z][z];
//20%的概率产生0
for (int i = 0; i < nums.length; i++) {
for (int j = 0; j < nums[i].length; j++) {
nums[i][j]=Math.random()>0.2?1:0;
System.out.print(nums[i][j]+"\t");
}
System.out.println();
}
int m=print();
System.out.println("找到的最大阶数为:"+m);
}
private int print() {
//设置该二维数组的最大阶数范围
int N=nums.length;
//定义一个变量，用于控制当前查找的阶数
int n=N;
//循环扫描每一层的阶数
while (n>0) {
for (int i = 0; i < nums.length; i++) {
if (i+n>N) break;
abc:for (int j = 0; j < nums.length; j++) {
if (j+n>N) break;
//设定移动点
int x=i,y=j;
//第一行向右移动
while (y<j+n) {
if (nums[x][y++]==0) continue abc;
}
y--;
//最后一列往下移动
while (x<i+n) {
if (nums[x++][y]==0) continue abc;
}
x--;
//最后一行向左走
while (y>=j) {
if (nums[x][y--]==0) continue abc;
}
y++;
//第一列往上走
while (x>i) {
if (nums[x--][y]==0) continue abc;
}
//如果四条边都没有发现0
return n;
}
}
n--;
}
return 0;
}
public static void main(String[] args) {
new Demo7().init();
}
}
随机产生一维数组，可能包含正数和负数，求连续的最大累加和。
package 第四章矩阵知识讲解;
import java.util.Arrays;
import java.util.Random;
import java.util.Scanner;
/**
*
* 随机产生一维数组，可能包含正数和负数，求连续的最大累加和
*
*/
public class Demo8 {
int[] nums=null;
private void init() {
System.out.println("输入一维数组的长度:");
Scanner scanner=new Scanner(System.in);
int n=scanner.nextInt();
scanner.close();
nums=new int[n];
for (int i = 0; i < nums.length; i++) {
int x=Math.random()>0.5?-1:1;
nums[i]=new Random().nextInt(10)*x;
}
System.out.println(Arrays.toString(nums));
print();
}
private void print() {
//定义一个变量，用于保存最后的结果
int result=nums[0];
for (int i = 0; i < nums.length; i++) {
//定义一个变量，用于存储每一轮最后的结果
int r_sum=nums[i];
//定义一个变量，用于存储每一轮中的每一次累加和
int sum=nums[i];
for (int j = i+1; j < nums.length; j++) {
sum+=nums[j];
if (sum>r_sum) {
r_sum=sum;
}
}
//内层循环结束后，r_sum得到的结果就是第一轮中的最大累加和
if (r_sum>result) {
result=r_sum;
}
}
System.out.println("最大累加和为:"+result);
}
public static void main(String[] args) {
new Demo8().init();
}
}
package 第四章矩阵知识讲解;
import java.util.Arrays;
import java.util.Random;
import java.util.Scanner;
public class T9 {
int[] nums=null;
private void init() {
System.out.println("输入一维数组的长度:");
Scanner scanner=new Scanner(System.in);
int n=scanner.nextInt();
scanner.close();
nums=new int[n];
for (int i = 0; i < nums.length; i++) {
int x=Math.random()>0.5?-1:1;
nums[i]=new Random().nextInt(10)*x;
}
System.out.println(Arrays.toString(nums));
print();
}
private void print() {
//定义最后的累加和的结果
int result=nums[0];
//定义临时的累加和的变量
int sum=nums[0];
//定义左右下标
int left=0,right=0;
for (int i = 1; i < nums.length; i++) {
//每一次循环，都判断一下这个临时的变量的值是否小于0
if (sum>=0) {
//说明加的这个值是正数，是需要的
sum+=nums[i];
}else {
//如果是负数，说明刚加的这个数不能要
sum=nums[i];
left=i;
}
//当sum加完一个数值之后，是否比最终的值要大，说明刚刚加的那个数值是有用
if (sum>=result) {
result=sum;
right=i;
}
}
System.out.println("起点下标为:"+left+"--终点的下标为:"+right+"---最大累加和:"+result);
}
public static void main(String[] args) {
// TODO Auto-generated method stub
new T9().init();
}
}
转方阵；
package 第四次蓝桥杯测试;
import java.util.Arrays;
import java.util.Scanner;
/**
* 转方阵
* @author MZFAITHDREAM
*对一个方阵转置，就是把原来的行号变列号，原来的列号变行号
例如，如下的方阵：
1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 16
转置后变为：
1 5 9 13
2 6 10 14
3 7 11 15
4 8 12 16
但，如果是对该方阵顺时针旋转（不是转置），却是如下结果：
13 9 5 1
14 10 6 2
15 11 7 3
16 12 8 4
你要实现的功能就是要把一个方阵顺时针旋转。
*/
public class DemoTest10 {
int[][]nums=null;
private void init() {
System.out.println("输入二位数组的阶数");
Scanner scanner=new Scanner(System.in);
int n=scanner.nextInt();
scanner.close();
nums=new int[n][n];
int num=0;
for (int i = 0; i < nums.length; i++) {
for (int j = 0; j < nums[i].length; j++) {
nums[i][j]=++num;
System.out.print(nums[i][j]+"\t");
}
System.out.println();
}
}
public static void main(String[] args) {
new DemoTest10().init();
}
/**
* 生成二维数组的方式
*/
}
