1. Definición
Las matrices dispersas pueden considerarse como la compresión de las matrices ordinarias de dos dígitos, pero las matrices ordinarias mencionadas aquí son matrices cuyo valor de datos no válidos es mucho mayor que los datos efectivos. Hay cinco fichas, mapas, etc. de niños sobre el uso de matrices dispersas .
* Cuando la mayoría de los elementos en una matriz son 0, o una matriz del mismo valor , puede usar una matriz dispersa para guardar la matriz como se muestra
2. Beneficios
* Hay muchos datos no válidos en la matriz original , que ocupan mucho espacio de almacenamiento, pero hay muy pocos datos realmente útiles.
* Registre los rangos y valores de elementos con diferentes valores en una matriz a pequeña escala, reduciendo así el tamaño del programa
* El almacenamiento comprimido puede ahorrar espacio de almacenamiento para evitar el desperdicio innecesario de recursos. El almacenamiento comprimido puede mejorar la eficiencia de E / S cuando los datos se serializan en el disco
3. Estructura de matriz dispersa
* La matriz de registros tiene varias filas y columnas, cuántos valores diferentes
* La primera fila almacena el número total de filas de datos originales, el número total de columnas, el número total de datos distintos de cero
* La siguiente fila almacena la fila, la columna y el valor específico del número distinto de cero (como se muestra a continuación)
Tanto las filas como las columnas son 11 matrices binarias.
Convierta la matriz bidimensional anterior en una matriz dispersa
Observaciones: debido a que los subíndices de la matriz comienzan desde 0, sus etiquetas también comienzan desde 0 (importante)
4. La idea de convertir una matriz bidimensional en una matriz dispersa
* Atraviese la matriz bidimensional original para obtener la cantidad de datos válidos sumados
* Según la suma, puede crear una matriz dispersa sparseArr int [sum + 1] [3]
* Guarde los datos efectivos de la matriz bidimensional en la matriz dispersa
5. La idea de convertir una matriz dispersa en una matriz bidimensional original
* Lea primero la primera fila de la matriz dispersa y cree la matriz bidimensional original basada en los datos de la primera fila.
Por ejemplo, el anterior chessArr2 = int [11] [11]
* Después de leer los datos de las últimas líneas de la matriz dispersa y asignarla a la matriz bidimensional original.
6. Implementación del código
1 clase pública Sparsearray { 2 3 public static void main (String [] args) { 4 System.out.println ("=========== conversión de matriz bidimensional matriz dispersa ======= ===== " ); 5 int [] [] array = new int [11] [11 ]; 6 array [1] [2] = 1 ; 7 array [2] [3] = 2 ; 8 Sistema. out.println ("============ Matriz bidimensional antes de la conversión ============" ); 9 forToarray (array); 10 System.out.println ("============ matriz bidimensional convertida ============" ); 11 int [] [] sparsearry = arrayToSparsearry (array); 12 forToarray (sparsearry); 13 System.out.println ("=========== Convertir matriz dispersa en matriz original ======= ===== " ); 14 matriz = sparsearryToArray (sparsearry); 15 forToarray (matriz); 16 17 } 18 / ** 19 * Conversión de matriz bidimensional matriz dispersa 20 * @param matriz 21 * / 22 private static int [ ] [] arrayToSparsearry ( int [] [] array) { 23 int sum = 1 ; 24 para( int i = 0; i <array.length; i ++ ) { 25 int [] datas = array [i]; 26 para ( int j = 0; j <datas.length; j ++ ) { 27 if (array [i] [j]! = 0 ) { 28 sum ++ ; 29 } 30 } 31 } 32 33 int [] [] sparse = new int [sum] [3 ]; 34 int s = 0 ; 35 disperso [s] [0] = array.length; 36 disperso [s] [1] = matriz [0 ] .length; 37 disperso [s] [2] = suma-1 ; 38 para ( int i = 0; i <array.length; i ++ ) { 39 int [] datas = array [i]; 40 para ( int j = 0; j <datas.length; j ++ ) { 41 int a = array [i] [j]; 42 if (a! = 0 ) { 43 s ++ ; 44 disperso [s] [0] = i; 45 disperso [s] [1] = j; 46 disperso [s] [2] = a; 47 } 48 } 49 } 50 51 retorno escaso; 52 } 53 / ** 54 * 遍历 数组 55 * @param array 56 * / 57 vacío estático privado para Toarray ( int [] [] array) { 58 para ( int i = 0; i <array.length; i ++ ) { 59 int [] ints = matriz [i]; 60 para ( int j = 0; j <ints.length; j ++ ) { 61 System.out.print ("" + array [i] [j]); 62 } 63 System.out.println ("" ); 64 } 65 } 66 / * 67 * Convertir matriz dispersa a matriz original 68 * @param matriz 69 * / 70 private static int [] [] sparsearryToArray ( int [] [] array) { 71 int [] [] arrays = new int [array [ 0] [0]] [matriz [0] [1 ]]; 72 para (int i = 1; i <array.length; i ++ ) { 73 int [] js = matriz [i]; 74 para ( int j = 0; j <js.length; j ++ ) { 75 matrices [matriz [i] [0]] [matriz [i] [1]] = matriz [i] [2 ]; 76 } 77 78 } 79 matrices de retorno ; 80 } 81 }
* Los resultados después de la ejecución son los siguientes
=========== Conversión de matriz bidimensional matriz dispersa ============ ============ Matriz bidimensional antes de la conversión ============ 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ============ Matriz bidimensional convertida ============ 11 11 2 1 2 1 2 3 2 =========== Convertir matriz dispersa a matriz original ============ 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0