Prefacio
Este artículo explica principalmente las matrices de dispersión dispersa
Estructura de datos y lista de artículos sobre algoritmos
Estructura de datos y lista de artículos sobre algoritmos: haga clic aquí para saltar a la vista
Tabla de contenido
(1) Demanda
En el programa Gobang escrito, hay funciones de guardar, salir y reproducir.
Debido a que muchos valores de la matriz bidimensional son el valor predeterminado de 0, se registra una gran cantidad de datos sin sentido, por lo que se usa una matriz dispersa para resolver este problema.
(2) Introducción básica
Cuando la mayoría de los elementos de una matriz son 0 o una matriz del mismo valor, puede usar una matriz dispersa para guardar la matriz.
El método de procesamiento para matrices dispersas es:
(1) Cuántas filas y columnas hay en la matriz de registros y cuántos valores diferentes hay (las matrices dispersas tienen un total de 3 columnas)
(2) Registre las filas, columnas y valores de elementos con diferentes valores en un tamaño pequeño El tamaño de la matriz, reduciendo así el tamaño del programa
(3) Ejemplos de aplicación
(1) Use matrices dispersas para retener las matrices bidimensionales similares a las anteriores (tableros de ajedrez, mapas, etc.)
(2) Guarde las matrices dispersas y restaure los números de matriz bidimensionales originales
(3) La siguiente es la análisis general
La idea de convertir una matriz bidimensional en una matriz dispersa :
- Atraviesa la matriz bidimensional original para obtener el número de suma de datos válidos
- De acuerdo con la suma se puede crear una matriz dispersa sparseArr int [suma + 1] [3]
- Almacene los datos válidos de la matriz bidimensional en la matriz dispersa
La idea de convertir una matriz dispersa en una matriz bidimensional original :
- Primero lea la primera fila de la matriz dispersa y cree la matriz bidimensional original basada en los datos de la primera fila, como chessArr2 = int anterior [11] [11]
- Simplemente lea las últimas filas de la matriz dispersa y asígnela a la matriz bidimensional original.
(4) Implementación del código
package com.lzacking.sparsearray;
public class SparseArray {
public static void main(String[] args) {
// 创建一个原始的二维数组 11 * 11
// 0: 表示没有棋子， 1 表示黑子 2表示白子
int chessArr1[][] = new int[11][11];
chessArr1[1][2] = 1;
chessArr1[2][3] = 2;
chessArr1[4][5] = 2;
// 输出原始的二维数组
System.out.println("原始的二维数组~~");
for (int[] row : chessArr1) {
for (int data : row) {
System.out.printf("%d\t", data);
}
System.out.println();
}
// 将二维数组转稀疏数组的思路
// 1. 先遍历二维数组 得到非0数据的个数
int sum = 0;
for (int i = 0; i < 11; i++) {
for (int j = 0; j < 11; j++) {
if (chessArr1[i][j] != 0) {
sum++;
}
}
}
// 2. 创建对应的稀疏数组
int sparseArr[][] = new int[sum + 1][3];
// 给稀疏数组赋值
sparseArr[0][0] = 11;
sparseArr[0][1] = 11;
sparseArr[0][2] = sum;
// 遍历二维数组，将非0的值存放到 sparseArr中
int count = 0; // count 用于记录是第几个非0数据
for (int i = 0; i < 11; i++) {
for (int j = 0; j < 11; j++) {
if (chessArr1[i][j] != 0) {
count++;
sparseArr[count][0] = i;
sparseArr[count][1] = j;
sparseArr[count][2] = chessArr1[i][j];
}
}
}
// 输出稀疏数组的形式
System.out.println();
System.out.println("得到稀疏数组为~~~~");
for (int i = 0; i < sparseArr.length; i++) {
System.out.printf("%d\t%d\t%d\t\n", sparseArr[i][0], sparseArr[i][1], sparseArr[i][2]);
}
System.out.println();
//将稀疏数组 --》 恢复成 原始的二维数组
/*
* 1. 先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组，比如上面的 chessArr2 = int [11][11]
2. 在读取稀疏数组后几行的数据，并赋给 原始的二维数组 即可.
*/
//1. 先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组
int chessArr2[][] = new int[sparseArr[0][0]][sparseArr[0][1]];
//2. 在读取稀疏数组后几行的数据(从第二行开始)，并赋给 原始的二维数组 即可
for(int i = 1; i < sparseArr.length; i++) {
chessArr2[sparseArr[i][0]][sparseArr[i][1]] = sparseArr[i][2];
}
// 输出恢复后的二维数组
System.out.println();
System.out.println("恢复后的二维数组");
for (int[] row : chessArr2) {
for (int data : row) {
System.out.printf("%d\t", data);
}
System.out.println();
}
}
}
Resultado :
