(十四)矩阵类与对称矩阵的压缩算法

矩阵类

矩阵是工程设计中经常使用的数学工具。

矩阵的运算主要有矩阵加、矩阵减、矩阵乘、矩阵转置、矩阵求逆等。

矩阵用两维数组处理最为方便。

二维数组存储结构。  

设计矩阵类

import java.util.Random;


public class MyMatrix {
   
	int[][] matrix ;//矩阵数组
	Random random =new Random() ;//随机数对象
	
	//默认的构造方法，生成3*3的矩阵
	public MyMatrix()
	{
		matrix = new int[3][3];
		//初始矩阵
		for(int i=0;i<matrix.length;i++)
		{
			for(int j=0;j<matrix[i].length;j++)
			{
				matrix[i][j]=random.nextInt(100);
			}
		}
	}
	
	//生成方阵的构造方法
	public MyMatrix(int n)
	{
	    matrix = new int[n][n];
	    //初始矩阵
		for(int i=0;i<matrix.length;i++)
		{
			for(int j=0;j<matrix[i].length;j++)
			{
				matrix[i][j]=random.nextInt(100);
			}
		}
	}
	
	//生成一个m*n的矩阵。
	public MyMatrix(int m,int n)
	{
		matrix = new int[m][n];
		//初始矩阵
		for(int i=0;i<matrix.length;i++)
		{
			for(int j=0;j<matrix[i].length;j++)
			{
				matrix[i][j]=random.nextInt(100);
			}
		}
	}
	
	//根据已知二维数组，生成矩阵
	public MyMatrix(int[][] matrix)
	{
		this.matrix = matrix;
	}
	
	//返回矩阵数组
	public int[][] getMatrix()
	{
		return this.matrix;
	}
	
	//打印矩阵
	public void print()
	{
		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();
		} 	
	}
	
	//转置矩阵
	public MyMatrix transport()
	{
	    //行变列
		int m = matrix[0].length;
		//列变行
		int n = matrix.length;
		
		MyMatrix transMatrix = new MyMatrix(m,n);
		//初始化
		for(int i=0;i<transMatrix.matrix.length;i++)
		{
			for(int j=0;j<transMatrix.matrix[i].length;j++)
			{
				transMatrix.matrix[i][j] = matrix[j][i];
			}
		}
		return transMatrix;
	}
	
	//判断矩阵是否是上三角矩阵
	public boolean isUpTriangle()
	{
	   for(int i=1;i<matrix.length;i++)
	   {
		   for(int j=0;j<i;j++)
		   {
			   if(matrix[i][j]!=0)
			   {
				   return false;
			   }
		   }
	   }
	   return true;
	}
	
	//判断是否是下三角矩阵
    public boolean isDownTriangle()
    {
    	for(int i=0;i<matrix.length;i++)
    	{
    		for(int j=matrix[i].length-1;j>i;j--)
    		{
    		   if(matrix[i][j]!=0)
  			   {
  				   return false;
  			   }
    		}
    	}
    	return true;
    }
    
    //判断是否是对称矩阵
    public boolean isSynmetry()
    {
       for(int i=1;i<matrix.length;i++)
  	   {
  		  for(int j=0;j<matrix[i].length;j++)
  		  {
  			  if(matrix[i][j]!=matrix[j][i])
  			  {
  				  return false;
  			  }
  		  }
  	   }
  	   return true;
    }
    
    //矩阵求和
    public void add(MyMatrix b)
    {
       int m = b.matrix.length;
       int n = b.matrix[0].length;
       if(m!=matrix.length||n!=matrix[0].length)
       {
    	   System.out.println("矩阵类型不相同，无法相加！");
       }
       else
       {
    	   for(int i=0;i<matrix.length;i++)
   		   {
   			 for(int j=0;j<matrix[i].length;j++)
   			 {
   				matrix[i][j]+=b.matrix[i][j];
   			 }
   			 
   		   } 	 
       }
    }
}

public class TestMyMatrix {

	public static void main(String[] args) {
		
		MyMatrix m1 = new MyMatrix();
		MyMatrix m2 = new MyMatrix(4);
		System.out.println("m1矩阵：");
		m1.print();
		System.out.println("m2矩阵：");
		m2.print();
		
		MyMatrix m3 = m2.transport();
		System.out.println("m2转置后：");
		m3.print();
		
		System.out.println(m3.isDownTriangle());
		MyMatrix m4 = new MyMatrix(
		   new int[][]{
			   {1,0,0,0},
			   {2,3,0,0},
			   {4,5,6,0},
			   {7,8,9,10}
		   }		
		);
		System.out.println(m4.isDownTriangle());
		
		MyMatrix m5 = new MyMatrix(
				   new int[][]{
					   {1,2,4,7},
					   {2,3,5,8},
					   {4,5,6,9},
					   {7,8,9,10}
				   }		
				);
		
		System.out.println(m5.isSynmetry());
		m4.add(m5);
		m4.print();
	}

}

特殊矩阵

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

特殊矩阵的压缩存储

只存储相同矩阵元素的一个副本。此种压缩存储方法是：找出特殊矩阵数据元素的分布规律，只存储相同矩阵元素的一个副本。

n阶对称矩阵的压缩存储对应关系

  aij=aji   1<=i<=n,1<=j<=n

 元素个数m = n*(n+1)/2

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

         i*(i-1)/2+j-1  当i>=j

 k=

         j*(j-1)/2+i-1  当i<j

采用不等长的二维数组

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

不等长的二维数组结构

//对称矩阵类
public class SynmeMatrix {
  
	double [] a;//矩阵元素
	int n; //矩阵的阶数;
	int m; //一维数组的个数
	
	public SynmeMatrix(int n)
	{
		//需要保持的元素个数是m=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)	
	  		   {
	  		      //System.out.println("a["+k+"]="+b[i][j]);
	  			  a[k++]=b[i][j]; //只保存下三角元素
	  		   }
	  		}
	  	}
		
	}
	
	//通过一个一维数组来初始化，那么这个一维数组就是对称矩阵元素的副本
	public void evaluate(double[] b)
	{
		for(int k=0;k<m;k++)
		{
			a[k]= b[k];
		}
	}
	
	//对称矩阵相加
	public SynmeMatrix add(SynmeMatrix b)
	{
	   SynmeMatrix t = new SynmeMatrix(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;
			   }
			   t.a[k] = a[k]+b.a[k];
		   }
	   }
	   return t;
	}
	
	//打印对称矩阵
	public void print()
	{
		   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 TestSynmeMatrix {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
        
		SynmeMatrix m1 = new SynmeMatrix(3);
		SynmeMatrix m2 = new SynmeMatrix(3);
		SynmeMatrix m3;
		
		double[][] a ={{1,0,0},{2,3,0},{4,5,6}};
		double[] b = {1,2,3,4,5,6};
		
		m1.evaluate(a);
		m2.evaluate(b);
		
		System.out.println("m1对称矩阵：");
		m1.print();
		System.out.println("m2对称矩阵：");
		m2.print();
		
		m3=m1.add(m2);
		System.out.println("m3对称矩阵：");
	    m3.print();
	    
	}

}