稀疏数组及稀疏数组与二维数组的相互转换（Java实现）

最新推荐文章于 2021-08-02 11:11:43 发布

zzyu-

最新推荐文章于 2021-08-02 11:11:43 发布

阅读量203

点赞数 1

文章标签：算法 java 数据分析矩阵

本文链接：https://blog.csdn.net/qq_45017301/article/details/115449977

版权

一、稀疏数组

概念

稀疏数组可以理解为特定数组的压缩。在该特定数组中，有效数据量远大于无效数据量（大部分为0或者相同数值），因此可以选择以稀疏数组的方式来把有效数据保存下来。

转换方式

对于一个n行m列的二维数组，其中有效值的个数为x，那么与之对应的稀疏数组为一个x+1行3列的二位数组。3列代表的含义分别为行，列，值，第一行为原二位数组的行数，列数，有效值数（n，m，x），后面每一行为有效值的行，列，具体值

举例

下图为一个简单的例子，左侧为一个二维数组，右侧是其对应的稀疏数组。
在这里插入图片描述

二、稀疏数组与二维数组的相互转换

以下为稀疏数组与二维数组的相互转换的Java代码实现

二维数组到稀疏数组

	/**
     * 传入一个二维数组，转换为对应的稀疏数组并返回
     * @param preArray
     * @return
     */
    public int[][] toSparseArray(int[][] preArray){
        // 通过遍历得到原二维数组的行数rows，列数cols，有效值个数sum
        int sum=0, all=0;
        for (int[] row : preArray){
            for (int data : row) {
                if (data!=0)
                    sum++;
                all++;
            }
            System.out.println();
        }
        int rows = preArray.length;
        int cols = all/rows;

        // 生成对应的稀疏数组
        int[][] sparseArray = new int[sum+1][3];
        sparseArray[0][0] = rows;
        sparseArray[0][1] = cols;
        sparseArray[0][2] = sum;
        int flag=0;
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                if (preArray[i][j]!=0){
                    flag++;
                    sparseArray[flag][0] = i;
                    sparseArray[flag][1] = j;
                    sparseArray[flag][2] = preArray[i][j];
                }
            }
        }
        return sparseArray;
    }

稀疏数组到二维数组

	/**
     * 传入一个稀疏数组，转换为对应的二维数组并返回
     * @param sparseArray
     * @return
     */
    public int[][] toPreArray(int[][] sparseArray){

        int[][] preArr = new int[sparseArray[0][0]][sparseArray[0][1]];
        for (int i = 1; i < sparseArray.length; i++) {
            preArr[sparseArray[i][0]][sparseArray[i][1]] = sparseArray[i][2];
        }
        return preArr;
    }

测试

	@Test
    public void toSparseArrayTest() {
        int[][] preArr = new int[4][5];
        preArr[1][0] = 1;
        preArr[2][3] = 2;

        // 打印原二维数组
        System.out.println("=================原始的二维数组=================");
        for (int[] row : preArr){
            for (int data : row) {
                System.out.printf("%d  ",data);
            }
            System.out.println();
        }

        // 转换为稀疏数组并打印
        int[][] sparseArr = this.toSparseArray(preArr);
        System.out.println("=================对应的稀疏数组=================");
        for (int[] rows : sparseArr) {
            System.out.printf("%d\t%d\t%d\n", rows[0], rows[1], rows[2]);
        }

        // 转换为原始的二维数组并打印
        int[][] preArr2 = this.toPreArray(sparseArr);
        System.out.println("===============转换为原始的二维数组===============");
        for (int[] row : preArr2){
            for (int data : row) {
                System.out.printf("%d  ",data);
            }
            System.out.println();
        }
    }