Conversión de estructura de datos entre matriz bidimensional y matriz dispersa

¿Por qué convertir una matriz bidimensional en una matriz dispersa?

Al usar arrays en realidad, la mayoría de los arrays no llenan todo el espacio, lo que dará lugar a la posibilidad de atravesar todas las posiciones al consultar datos válidos. Obviamente no hay un consumo necesario, por lo que este A veces, debe ser escaso para realizar la conversión.

Se puede ver en la figura que la matriz bidimensional original de la izquierda es 6 * 7 = 42, y la matriz dispersa de la derecha es 9 * 3 = 27. Obviamente, se necesita mucho menos tiempo para atravesar 27 que para atravesar 42. En este momento Se muestra el papel de las matrices dispersas

¿Qué es una matriz dispersa?

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 de matriz dispersa es: la
primera fila de la matriz de registros tiene un total de varias filas y varias columnas, cuántos
valores diferentes hay y registra las filas, columnas y valores de elementos con diferentes valores en una matriz pequeña, reduciendo así el tamaño del programa

¿Cómo conectar una matriz bidimensional y una matriz dispersa entre sí?

Matriz bidimensional -> matriz dispersa

1. Recorra la matriz bidimensional original para obtener el número de datos válidos Suma
2. Cree una matriz dispersa basada en Sum sparseArr = int [sum + 1] [3]
3. Almacene los datos válidos de la matriz bidimensional original en la matriz dispersa

Matriz dispersa -> matriz bidimensional

1. Lea la primera fila de la matriz dispersa y cree una matriz bidimensional basada en los datos de la primera fila.
2. Asigne los datos de la segunda fila y las siguientes de la matriz dispersa a la matriz bidimensional

Bueno, no hay muchos chismes, ¡solo ve al código!

package com.xiaozhao.datastructure;

import jdk.management.resource.internal.inst.SocketOutputStreamRMHooks;

/**
 * @author : Carson-Zhao
 * @date : 2020/7/15 21:49
 */
public class SparseArray {
    public static void main(String[] args) {
        /**
         * 创建一个原始的二维数组 11*11
         * 0:表示没有棋子
         * 1:表示黑子
         * 2:表示白子
         *
         */
        int[][] chessArray = new int[11][11];
        chessArray[1][2] = 1;
        chessArray[2][3] = 2;
        chessArray[5][8] = 9;
        for(int[] c : chessArray){
            for (int data : c){
                System.out.printf("%d\t",data);
            }
            System.out.println();
        }

        /**
         * 将二维数组转换为稀疏数组
         * 1.遍历原始二位数数组,得到非零数据的个数
         * 2.创建稀疏数组
         * 3.将原始数组的有效数据赋值给稀疏数组
         */
        int sum = 0;
        for(int i = 0;i < chessArray.length;i++){
            for (int j = 0; j < chessArray.length; j++) {
                if(chessArray[i][j] != 0){
                    sum++;
                }
            }
        }
        int[][] sparseArray = new int[sum+1][3];
        //给稀疏数组赋值
        sparseArray[0][0] = 11;
        sparseArray[0][1] = 11;
        sparseArray[0][2] = sum;
        //遍历二维数组,拿到有效数据
        int count = 0;//用于记录第几个非零数据
        for(int i = 0;i < chessArray.length;i++){
            for (int j = 0; j < chessArray.length; j++) {
                if(chessArray[i][j] != 0){
                    count++;
                    sparseArray[count][0] = i;
                    sparseArray[count][1] = j;
                    sparseArray[count][2] = chessArray[i][j];
                }
            }
        }
        System.out.println();
        //输出转换后的稀疏数组
        System.out.println("输出转换后的稀疏数组");
        System.out.println();
        for (int i = 0; i < sparseArray.length; i++) {
            System.out.printf(
                    "%d\t%d\t%d\t",
                    sparseArray[i][0],
                    sparseArray[i][1],
                    sparseArray[i][2]
            );
            System.out.println();
        }

        System.out.println();
        System.out.println("将稀疏数组恢复成二维数组");
        System.out.println();
        //将稀疏数组恢复成二维数组
        int N = sparseArray[0][0];
        int M = sparseArray[0][1];


        int[][] array = new int[N][M];

        for (int i = 1; i < sparseArray.length; i++) {

                array[sparseArray[i][0]][sparseArray[i][1]] = sparseArray[i][2];

        }
        for(int[] c : array){
            for (int data : c){
                System.out.printf("%d\t",data);
            }
            System.out.println();
        }


    }
}

El efecto de implementación es el siguiente:

D:\Environment\Java\jdk1.8.0_251\bin\java.exe "

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	9	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	

输出转换后的稀疏数组

11	11	3	
1	2	1	
2	3	2	
5	8	9	

将稀疏数组恢复成二维数组

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	9	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	

Process finished with exit code 0

La implementación específica se ha anotado en el código, por lo que no entraré en detalles al final. . . . .

Aprendo por la comida, soy Xiao Zhao, ¡espero animarnos mutuamente!

Supongo que te gusta

Origin blog.csdn.net/weixin_43562937/article/details/107372529
Recomendado
Clasificación