Matriz dispersa de estructura de datos

Una matriz dispersa

1. Concepto

Al usar una matriz bidimensional para guardar datos, si el número de valores no predeterminados guardados (como el valor predeterminado del tipo int es 0) es menor que el tamaño de la matriz bidimensional completa , puede considerar usar una matriz dispersa para reducir el uso de memoria.

La primera dimensión es la matriz normal de matriz dispersa 一维长度 二维长度y 非默认元素个数; otro elemento de dimensión no predeterminado 一维下标 二维下标y元素值

2. Pasos de conversión

1) matriz normal a matriz dispersa

1. Obtenga las longitudes unidimensionales y bidimensionales de matrices ordinarias y la cantidad de elementos no predeterminados
2. Cree una nueva matriz dispersa (la longitud unidimensional es 1 + el número de elementos no predeterminados, la longitud bidimensional es 3)
3. Atraviesa matrices ordinarias y asigna valores a matrices dispersas

2) Matriz dispersa a matriz ordinaria

1. Obtenga la primera dimensión de la matriz dispersa, puede obtener la longitud unidimensional de la matriz ordinaria y el número de elementos no predeterminados con longitud bidimensional
2. Cree una nueva matriz ordinaria e inicialice el valor predeterminado
3. Atraviesa la matriz dispersa y asigna elementos no predeterminados

3) Ejemplo

class SpareArray {
    
    

    /**
     * 将普通的二维数组转换为稀疏数组
     */
    public static int[][] transform(int[][] array, int defaultValue) {
    
    
        if (null == array) {
    
    
            return null;
        }

        int len = array.length; // 一维长度
        if (0 == len) {
    
    
            return null;
        }
        int length = array[0].length; // 二维长度
        if (0 == length) {
    
    
            return null;
        }

        int count = 0;
        for (int i = 0; i < len; i++) {
    
    
            int[] arr = array[i];
            for (int j = 0; j < length; j++) {
    
    
                int ele = arr[j];
                if (defaultValue != ele) {
    
    
                    count++;
                }
            }
        }

        int[][] spareArray = new int[1 + count][3];
        spareArray[0][0] = len; // 一维长度
        spareArray[0][1] = length; // 二维长度
        spareArray[0][2] = count; // 非默认元素个数

        int index = 0;
        for (int a = 0; a < len; a++) {
    
    
            for (int b = 0; b < length; b++) {
    
    
                int ele = array[a][b];
                if (defaultValue != ele) {
    
    
                    index++;
                    spareArray[index][0] = a;
                    spareArray[index][1] = b;
                    spareArray[index][2] = ele;
                }
            }
        }

        return spareArray;
    }

    /**
     * 将稀疏数组恢复回普通的二维数组
     */
    public static int[][] recover(int[][] spareArray, int defaultValue) {
    
    
        if (null == spareArray) {
    
    
            return null;
        }

        int len = spareArray[0][0];
        int length = spareArray[0][1];
        int count = spareArray[0][2];

        int[][] array = new int[len][length];
        for (int i = 0; i < len; i++) {
    
    
            for (int j = 0; j < length; j++) {
    
    
                array[i][j] = defaultValue;
            }
        }

        for (int a = 1; a <= count; a++) {
    
     // 从稀疏数组的第二维开始遍历
            int x = spareArray[a][0];
            int y = spareArray[a][1];
            int ele = spareArray[a][2];
            array[x][y] = ele;
        }

        return array;
    }

}