数据结构与算法（Java描述）-14、矩阵类以及对称矩阵的压缩算法

一、矩阵类

矩阵是工程设计中经常使用的数学工具。 
矩阵的运算主要有矩阵加、矩阵减、矩阵乘、矩阵转置、矩阵求逆等。
矩阵用两维数组处理最为方便。 
二维数组存储结构。 

实现：

import java.util.Random;

//自定义矩阵类
public class MyMartrix {

	//矩阵数组
	int martrix[][];
	//随机对象
	Random random=new Random();
	
	//初始化矩阵内容
	public void init() {
		for (int i = 0; i < martrix.length; i++) {
			for (int j = 0; j < martrix[i].length; j++) {
				martrix[i][j]=random.nextInt(100);
			}
		}
	}
	
	//默认构造方法，3*3
	public MyMartrix() {
		martrix=new int[3][3];
		init();
	}
	
	//构造n*n 矩阵
	public MyMartrix(int n) {
		martrix=new int[n][n];
		init();
	}
	
	//构造m*n 矩阵
	public MyMartrix(int m,int n) {
		martrix=new int[m][n];
		init();
	}
	
	//根据已知的二维数组生成矩阵
	public MyMartrix(int [][] anotherMartrix) {
		this.martrix=anotherMartrix;
	}
	
	//得到矩阵数组
	public int[][] getMartrix() {
		return this.martrix;
	}
	
	//打印矩阵
	public void printMartrix() {
		for (int i = 0; i < martrix.length; i++) {
			for (int j = 0; j < martrix[i].length; j++) {
				System.out.print(martrix[i][j]+" ");
			}
			System.out.println();
		}
		
	}
	
	//矩阵转置
	public MyMartrix transport() {
		int m=martrix[0].length;
		int n=martrix.length;
		MyMartrix newMartrix=new MyMartrix(m,n);
		for (int i = 0; i < newMartrix.martrix.length; i++) {
			for (int j = 0; j < newMartrix.martrix[i].length; j++) {
				newMartrix.martrix[i][j]=martrix[j][i];
			}
		}
		return newMartrix;
	}
	
	//判断是否是上三角矩阵
	public boolean isUpMartrix() {
		for (int i = 1; i < martrix.length; i++) {
			for (int j = 0; j < i; j++) {
				if(martrix[i][j]!=0)
					return false;
			}
		}
		return true;
	}
	
	//判断是否是下三角矩阵
	public boolean isDownMartrix() {
		for (int i = 0; i < martrix.length; i++) {
			for (int j = martrix[i].length-1; j >i; j--) {
				if(martrix[i][j]!=0)
					return false;
			}
		}
		return true;
	}
	
	//判断是否是对称矩阵
	public boolean isSymmetry() {
		for (int i = 1; i < martrix.length; i++) {
			for (int j = 0; j < martrix[i].length; j++) {
				if(martrix[i][j]!=martrix[j][i])
					return false;
			}
		}
		return true;
	}
	
	//两矩阵相加
	public void add(MyMartrix anotherMartrix) {
		int m=anotherMartrix.martrix.length;
		int n=anotherMartrix.martrix[0].length;
		if(m!=martrix.length||n!=martrix[0].length)
			System.out.println("两个矩阵类型不相同，不能相加！");
		else {
			for (int i = 0; i < martrix.length; i++) {
				for (int j = 0; j < martrix[i].length; j++) {
					martrix[i][j]+=anotherMartrix.martrix[i][j];
				}
			}
		}
	}
}

二、特殊矩阵

特殊矩阵是指这样一类矩阵，其中有许多值相同的元素或有许多零元素，且值相同的元素或零元素的分布有一定规律。一般采用二维数组来存储矩阵元素。但是，对于特殊矩阵，可以通过找出矩阵中所有值相同元素的数学映射公式，只存储相同元素的一个副本，从而达到压缩存储数据量的目的。

三、 特殊矩阵的压缩存储 

只存储相同矩阵元素的一个副本。此种压缩存储方法是：找出特殊矩阵数据元素的分布规律，只存储相同矩阵元素的一个副本。
n阶对称矩阵的压缩存储对应关系 
  aij=aji   1<=i<=n,1<=j<=n
 元素个数m = n*(n+1)/2

打印对称矩阵第i行,第j列的元素，与一维数组的下标关系为：

采用不等长的二维数组
Java语言支持不等长的二维数组，对于n阶对称矩阵，也可以通过只申请存储下三角（或上三角）矩阵元素所需的二维数组，来达到压缩存储的目的。 
不等长的二维数组结构

四、实现对称矩阵的压缩算法

public class SymmetryMartrix {

	//矩阵元素
	double a [];
	//矩阵的阶数
	int n;
	//一维数组的个数
	int m;
	
	public SymmetryMartrix(int n) {
		//需要保持的元素个数是 n*(n+1)/2
		m=n*(n+1)/2;
		a=new double[m];
		this.n=n;
	}
	
	//通过一个二维数组来初始化
	public void evaluate(double b[][]) {
		int k=0;
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < n; j++) {
				if(i>=j) {
					//只保存下三角元素
					a[k++]=b[i][j];
				}
			}
		}
	}
	
	
	//通过一个一维数组来初始化,那么这个一维数组就是这个对称矩阵的副本
	public void evaluate(double b[]) {
		for (int k = 0; k <m; k++) {
			a[k]=b[k];
		}
	}
	
	//对称矩阵相加
	public SymmetryMartrix add(SymmetryMartrix b) {
		SymmetryMartrix newMatrix=new SymmetryMartrix(n);
		int k;
		for (int i = 1; i <= n; i++) {
			for (int j = 1; j <= n; j++) {
				if(i>=j) {
					k=i*(i-1)/2+j-1;
				}else {
					k=j*(j-1)/2+i-1;
				}
				newMatrix.a[k]=a[k]+b.a[k];
			}
		}
		return newMatrix;
	}
	
	//打印对称矩阵
	public void printMartrix() {
		int k;
		for (int i = 1; i <= n; i++) {
			for (int j = 1; j <= n; j++) {
				if(i>=j) {
					k=i*(i-1)/2+j-1;
				}else {
					k=j*(j-1)/2+i-1;
				}
				System.out.print("  "+a[k]);
			}
			System.out.println();
		}
	}
}

测试：

public class Main {

	public static void main(String[] args) {
		MyMartrix mar1=new MyMartrix();
		System.out.println("3*3矩阵...........");
		mar1.printMartrix();
		
		System.out.println("4*4矩阵...........");
		MyMartrix mar2=new MyMartrix(4,4);
		mar2.printMartrix();
		System.out.println("转置后的矩阵..........");
		MyMartrix mar3=mar2.transport();
		mar3.printMartrix();
		
		MyMartrix mar4=new MyMartrix(new int[][] {
			{1,0,0,0},
			{2,3,0,0},
			{4,5,6,0},
			{7,8,9,10}
		});
		System.out.println(mar2.isDownMartrix());//false
		System.out.println(mar4.isDownMartrix());//true
		
		MyMartrix mar5=new MyMartrix(new int[][] {
			{1,2,3,4},
			{0,5,6,7},
			{0,0,9,9},
			{0,0,0,10}
		});
		
		System.out.println(mar2.isUpMartrix());//false
		System.out.println(mar5.isUpMartrix());//true
		
		MyMartrix mar6=new MyMartrix(new int[][] {
			{1,2,3,4},
			{2,3,4,5},
			{3,4,5,6},
			{4,5,6,7}
		});
		
		System.out.println(mar6.isSymmetry());//true
		
		mar4.add(mar5);
		mar4.printMartrix();
	}
}

public class SymmetryMain {

	public static void main(String[] args) {
		SymmetryMartrix m1=new SymmetryMartrix(3);
		SymmetryMartrix m2=new SymmetryMartrix(3);
		SymmetryMartrix m3;
		double d[][]= {{1,0,0},{2,3,0},{4,5,6}};
		double dou[]= {1,2,3,4,5,6};
		
		m1.evaluate(d);
		m1.printMartrix();
		System.out.println();
		m2.evaluate(dou);
		m2.printMartrix();
		System.out.println();
		m3=m1.add(m2);
		m3.printMartrix();
	}
}