稀疏数组

稀疏数组

介绍

当一个数组大部分元素为同一个值时，可以使用稀疏数组来压缩保存

处理方法

1. 记录数组有几行几列，有多少个不同的值
2. 把具有不同值的元素的行和列及值记录在一个小规模的数组中

应用实例

需求

1. 使用稀疏数组来保存二维数组
2. 将压缩后的稀疏数组还原为二维数组

代码实现

二维数组转稀疏数组

// 将二维数组转稀疏数组
public int[][] toSparesArray(int[][] array) {
    /*  将二维数组转稀疏数组的思路
     *   1. 先遍历拿到非0的个数
     *   2. 创建稀疏数组
     *   3. 赋值
     * */
    // 定义辅助变量
    int sum = 0;
    int length = array.length;
    int colLength = array[0].length;
    for (int i = 0; i < length; ++i) {
        for (int j = 0; j < colLength; ++j) {
            // 判断值是否为0
            if (array[i][j] != 0) {
                ++sum;
            }
        }
    }
    // 创建对应的稀疏数组
    int[][] sparesArray = new int[sum + 1][3];
    // 赋值第一行数据
    sparesArray[0][0] = array.length;
    sparesArray[0][1] = (array[0].length);
    sparesArray[0][2] = sum;

    // 赋值其他行
    // 定义辅助变量
    int count = 1; // 用于记录是第几个非0
    // 遍历二维数组
    for (int i = 0; i < length; ++i) {
        for (int j = 0; j < colLength; ++j) {
            if (array[i][j] != 0) {
                sparesArray[count][0] = i;
                sparesArray[count][1] = j;
                sparesArray[count][2] = array[i][j];
                ++count;
            }
        }
    }
    return sparesArray;
}

稀疏数组转二维数组

// 将稀疏数组恢复成二维数组
public int[][] returnArray(int[][] sparesArray) {
    /*
     * 思路：
     *  1. 拿到稀疏数组的第一行用来创建二维数组
     *  2. 知道了要插入几个值就循环赋值
     * */

    int[][] returnArray = new int[sparesArray[0][0]][sparesArray[0][1]];
    // 循环插入值，循环次数为sparesArray[0][2]
    int length = sparesArray[0][2];
    for (int i = 1; i <= length; ++i) {
        // 循环中赋值
        returnArray[sparesArray[i][0]][sparesArray[i][1]] = (sparesArray[i][2]);
    }

    return returnArray;
}

总代码：

package com.algorithm.demo1;

/*
 *   稀疏数组
 *
 * 1. 使用稀疏数组来保存二维数组
 * 2. 将压缩后的稀疏数组还原为二维数组
 * */

public class Demo {
    public static void main(String[] args) {
        // 定义一个二维数组
        /*
         *      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  1  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  1  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  1  0  0  0
         *
         * */
        int[][] array = new int[12][12];
        array[5][2] = 1;
        array[8][9] = 1;
        array[9][5] = 2;
        array[11][8] = 1;
        //  遍历输出原始的二维数组
//        for (int[] row : array) {
//            for (int i : row) {
//                System.out.print(i + "\t");
//            }
//            System.out.println();
//        }

        int[][] sparesArray = new Demo().toSparesArray(array);
        // 遍历稀疏数组
//        for (int[] row : sparesArray) {
//            for (int i : row) {
//                System.out.print(i + "\t");
//            }
//            System.out.println();
//        }

        int[][] returnArray = new Demo().returnArray(sparesArray);
        for (int[] row : returnArray) {
            for (int i : row) {
                System.out.print(i + "\t");
            }
            System.out.println();
        }
    }


    // 将二维数组转稀疏数组
    public int[][] toSparesArray(int[][] array) {
        /*  将二维数组转稀疏数组的思路
         *   1. 先遍历拿到非0的个数
         *   2. 创建稀疏数组
         *   3. 赋值
         * */
        // 定义辅助变量
        int sum = 0;
        int length = array.length;
        int colLength = array[0].length;
        for (int i = 0; i < length; ++i) {
            for (int j = 0; j < colLength; ++j) {
                // 判断值是否为0
                if (array[i][j] != 0) {
                    ++sum;
                }
            }
        }
        // 创建对应的稀疏数组
        int[][] sparesArray = new int[sum + 1][3];
        // 赋值第一行数据
        sparesArray[0][0] = array.length;
        sparesArray[0][1] = (array[0].length);
        sparesArray[0][2] = sum;

        // 赋值其他行
        // 定义辅助变量
        int count = 1; // 用于记录是第几个非0
        // 遍历二维数组
        for (int i = 0; i < length; ++i) {
            for (int j = 0; j < colLength; ++j) {
                if (array[i][j] != 0) {
                    sparesArray[count][0] = i;
                    sparesArray[count][1] = j;
                    sparesArray[count][2] = array[i][j];
                    ++count;
                }
            }
        }
        return sparesArray;
    }

    // 将稀疏数组恢复成二维数组
    public int[][] returnArray(int[][] sparesArray) {
        /*
         * 思路：
         *  1. 拿到稀疏数组的第一行用来创建二维数组
         *  2. 知道了要插入几个值就循环赋值
         * */

        int[][] returnArray = new int[sparesArray[0][0]][sparesArray[0][1]];
        // 循环插入值，循环次数为sparesArray[0][2]
        int length = sparesArray[0][2];
        for (int i = 1; i <= length; ++i) {
            // 循环中赋值
            returnArray[sparesArray[i][0]][sparesArray[i][1]] = (sparesArray[i][2]);
        }

        return returnArray;
    }

}