稀疏数组 sparse array

最新推荐文章于 2024-09-26 18:31:30 发布

Mr_Yyc

最新推荐文章于 2024-09-26 18:31:30 发布

阅读量222

点赞数

文章标签：数据结构 java

本文链接：https://blog.youkuaiyun.com/Mr_Yyc/article/details/125690149

版权

稀疏数组是一种用于优化大量无效值的二维数组空间利用的技术。它由三部分组成：行、列和值，占用内存空间等于3加上原始有效值的3倍，再加上额外的1个单位。通过稀疏数组，可以高效地获取原始二维数组的行数和列数，以及有效值的数量。文章将介绍如何实现和操作稀疏数组。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

稀疏数组：大量无效值的二维数组压缩空间使用。

列：3（行、列、值）
行：有效数值个数+1（原始二维数组）
占用内存空间数量:3 + 原始二维数组数有效值 * 3 + (原始二维数组数有效值 + 1)
获取原始数据中行数：1层数组的长度
获取原始数据中列数：任何一个2层数组的长度
有效值的数目:遍历原始数据中的每个值，挑选出有效值的数目

代码附上：

/**
 * 稀疏数组工具类
 * @author yyc
 * @date 2022/7/6
 */
public class SparseArrayUtil {
    /**
     * 获取原始二维数组的有效值
     * @param sourceArray
     * @param defaultValue
     * @return
     */
    private static int getEffValueCount(final int[][] sourceArray, final int defaultValue) {
        int effValueCount = 0;
        for (int[] ints : sourceArray) {
            for (int anInt : ints) {
                if (anInt != defaultValue) {
                    effValueCount++;
                }
            }
        }
        return effValueCount;
    }

    public static boolean shouldConvert(final int[][] sourceArray, final int defaultValue) {
        int num1 = sourceArray.length * sourceArray[0].length + sourceArray.length;
        int effValueCount = SparseArrayUtil.getEffValueCount(sourceArray, defaultValue);
        int numb2 = 3 + effValueCount * 3 + effValueCount + 1;
        return numb2 < num1;
    }

    /**
     * 原始二维数组转化为稀疏数组
     * @param sourceArray  原始数组
     * @param defaultValue 无效值
     * @return
     */
    public static int[][] convert(final int[][] sourceArray,final int defaultValue) {
        int rowCount = sourceArray.length;
        int colCount = sourceArray[0].length;
        int effValueCount = SparseArrayUtil.getEffValueCount(sourceArray, defaultValue);
        int[][] result = new int[effValueCount + 1][3];
        result[0][0] = rowCount;
        result[0][1] = colCount;
        result[0][2] = effValueCount;
        int row = 0;
        for (int i = 0; i < rowCount; i++) {
            for (int j = 0; j < colCount; j++) {
                if (sourceArray[i][j] != defaultValue) {
                    row++;
                    result[row][0] = i;
                    result[row][1] = j;
                    result[row][2] = sourceArray[i][j];
                }
            }
        }
        return result;
    }

    /**
     * 将稀疏数组转化为原始数组
     * @param sparseArray 稀疏数组
     * @param defaultValue 二维数组非有效值
     * @return 还原的二维数组
     */
    public static int[][] restoreArray(final int[][] sparseArray,final int defaultValue) {
        int rowCount = sparseArray[0][0];
        int colCount = sparseArray[0][1];
        int[][] sourceArray = new int[rowCount][colCount];
        if (defaultValue != 0) {
            for (int[] ints : sourceArray) {
                Arrays.fill(ints, defaultValue);
            }
        }
        for (int i = 1; i < sparseArray.length; i++) {
            sourceArray[sparseArray[i][0]][sourceArray[i][1]] = sparseArray[i][2];
        }
        return sourceArray;
    }
}