稀疏矩阵的处理

一、基本介绍

在矩阵中，若数值为0的元素数目远远多于非0元素的数目，并且非0元素分布没有规律时，则称该矩阵为稀疏矩阵；
与之相反，若非0元素数目占大多数时，则称该矩阵为稠密矩阵；
通常认为矩阵中非零元素的总数比上矩阵所有元素总数的值小于等于0.05时，则称该矩阵为稀疏矩阵。该比值称为这个矩阵的稠密度

二、相关方法

/**
 * 打印矩阵、压缩矩阵、还原矩阵
 * 压缩以及还原矩阵之前会判断该矩阵是否符合规定
 */
public class ArrayUtil {

	// 行数
	private static int ROW_NUM;
	// 列数
	private static int COLUMN_NUM;
	// 0的数量
	private static int ZERO_NUM;
	/**
	 * 打印矩阵
	 * 
	 * @param array 矩阵
	 */
	public static void printArray(int[][] matrix) {
		if(matrix == null) {
			System.out.printf("");
		}
		for (int[] array : matrix) {
			for (int data : array) {
				System.out.printf("%d\t", data);
			}
			System.out.println();
		}
	}
	
	/**
	 * 判断矩阵中0的数量
	 * 
	 * @param matrix 矩阵
	 * @return 0的数量
	 */
	private static int zeroNum(int[][] matrix) {
		int ZERO_NUM = 0;
		for (int[] array : matrix) {
			for (int data : array) {
				if (data == 0) {
					ZERO_NUM++;
				}
			}
		}
		return ZERO_NUM; 
	}
	
	/**
	 * 是否是稀疏矩阵
	 * 
	 * @param matrix 稀疏矩阵
	 * @return 是否是稀疏矩阵
	 */
	private static boolean isSparseArray(int[][] matrix) {
		if(matrix == null) {
			throw new RuntimeException("该矩阵为空，不能判断是否为稀疏矩阵");
		}
		ROW_NUM = matrix.length;
		COLUMN_NUM = matrix[0].length;
		ZERO_NUM = zeroNum(matrix);
		return ZERO_NUM / (COLUMN_NUM * ROW_NUM) <= 0.05;
	}

	/**
	 * 压缩稀疏矩阵
	 * 
	 * @return 压缩后的矩阵
	 */
	public static int[][] compressionMatrix(int[][] matrix) {
		if (!isSparseArray(matrix)) {
			throw new RuntimeException("该矩阵不是稀疏矩阵");
		}
		int notZeroNum = (COLUMN_NUM * ROW_NUM) - ZERO_NUM;
		int sparseMatrix[][] = new int[notZeroNum + 1][3];
		// 给稀疏数组赋值
		sparseMatrix[0][0] = ROW_NUM;
		sparseMatrix[0][1] = COLUMN_NUM;
		sparseMatrix[0][2] = notZeroNum;
		int count = 0; // count 用于记录是第几个非0数据
		for (int i = 0; i < 11; i++) {
			for (int j = 0; j < 11; j++) {
				if (matrix[i][j] != 0) {
					count++;
					sparseMatrix[count][0] = i;
					sparseMatrix[count][1] = j;
					sparseMatrix[count][2] = matrix[i][j];
				}
			}
		}
		return sparseMatrix;
	}
	
	/**
	 * 检查矩阵是否是压缩后的矩阵
	 * 
	 * @param matrix 矩阵
	 * @return 检查矩阵是否是压缩后的矩阵
	 */
	private static boolean checkcompressionMatrix(int[][] matrix) {
		if(matrix != null && matrix[0].length != 3) {
			return true;
		}
		int rowTotle = matrix[0][0];
		int columnTotle = matrix[0][1];
		for(int row = 1;row < matrix.length;row++) {
			int rowNum = matrix[row][0];
			int columnNum = matrix[row][1];
			if(rowNum > rowTotle || columnNum > columnTotle) {
				return true;
			}
		}
		return false;
	}
	
	/**
	 * 还原压缩的稀疏矩阵
	 * 
	 * @return 还原后的矩阵
	 */
	public static int[][] reductionMatrix(int[][] matrix) {
		if (checkcompressionMatrix(matrix)) {
			throw new RuntimeException("该矩阵不是压缩后的矩阵");
		}
		int[][] sparseMatrix = new int[matrix[0][0]][matrix[0][1]];
		for(int row = 1; row < matrix.length; row++) {
			sparseMatrix[matrix[row][0]][matrix[row][1]] = matrix[row][2];
		}
		return sparseMatrix;
	}
}

测试

public class SparseArray {

	public static void main(String[] args) {
		int chessArr1[][] = new int[11][13];
		chessArr1[1][2] = 1;
		chessArr1[2][3] = 2;
		chessArr1[4][5] = 2;
		
		System.out.println("原始的二维数组~~");
		ArrayUtil.printArray(chessArr1);
		
		System.out.println("压缩稀疏数组~~");
		int[][] sparseArr = ArrayUtil.compressionMatrix(chessArr1);
		ArrayUtil.printArray(sparseArr);
		
		System.out.println("还原稀疏数组~~");
		int[][] sparseArr2 = ArrayUtil.reductionMatrix(sparseArr);
		ArrayUtil.printArray(sparseArr2);
		
	}
}