使用Java对稀疏数组的压缩与还原

稀疏矩阵的压缩与还原

稀疏数组中元素个数很少或者有大量的重复值，如果直接保存保存，会浪费很多空间，这时，就可以考虑对数组进行压缩存储。
先定义一个稀疏数组

//创建一个二维数组 11 * 11
int[][] array1 = new int[11][11];
//给一些元素赋值
array1[1][2] = 1;
array1[2][3] = 2;
array1[4][4] = 1;
array1[8][5] = 2;

打印初始数组

//输出原始数组
System.out.println("输出原始数组");
for (int[] arr : array1) {
    System.out.println(Arrays.toString(arr));
}

压缩稀疏数组

在压缩数组时，我们可以用稀疏数组的第一行来存储元素数组的大小及原始数组的有效个数。下表为稀疏数组存储的内容，第一行为原始数组的行、列、元素个数。其余行为有效值信息，包括行坐标、列坐标以及有效值。

	0	1	2
0	原始数组行数	原始数组列数	有效值个数
1	行坐标	列坐标	有效值
2	行坐标	列坐标	有效值
…	行坐标	列坐标	有效值

通过原始数组获取有效值个数

//获取有效值个数
int sum = 0;
for (int i = 0; i < array1.length; i++) {
    for (int j = 0; j < array1[i].length; j++) {
        if (array1[i][j] != 0)
            sum++;
    }
}
System.out.println("有效个数为：" + sum);

根据有效值的个数创建稀疏数组，稀疏数组的行数为有效值个数加1，列数固定为3.

int[][] array2 = new int[sum + 1][3];
array2[0][0] = 11;//原始数组行数
array2[0][1] = 11;//原始数组列数
array2[0][2] = sum;//有效值个数

接下来就可以保存原始数组的有效值信息了。先利用一个计数器记录有效值个数。

//遍历二维数组，将非零的值，存放稀疏数组中
int count = 0;//计数作用
for (int i = 0; i < array1.length; i++) {
    for (int j = 0; j < array1[i].length; j++) {
        if (array1[i][j] != 0) {
            count++;//稀疏数组从第二行开始存有效值信息
            array2[count][0] = i;//有效值的行坐标
            array2[count][1] = j;//有效值的列坐标
            array2[count][2] = array1[i][j];//有效值
        }
    }
}

输出稀疏矩阵

for (int i = 0; i < array2.length; i++) {
    System.out.println(array2[i][0] + "\t" + array2[i][1] + "\t" + array2[i][2]);
}

通过稀疏数组还原原始数组

由于稀疏数组的第一行是保存的元素数组的大小，因此我们可以用其来创建一个元素数组的大小。

int[][] array3 = new int[array2[0][0]][array2[0][1]];//array2[0][0]存储的为原始数组的行数，array2[0][1]存储的为原始数组的列数

从稀疏数组下标为1开始遍历，因为1开始才是有效值的信息。如array2[1][0]就是第一个有效值的行坐标，array2[1][1]就是第一个有效值的列坐标，array2[1][2]就是第一个有效值。

for (int i = 1; i < array2.length; i++) {
    array3[array2[i][0]][array2[i][1]] = array2[i][2];
}

最后输出还原后的数组。

//输出还原数组
System.out.println("输出还原数组");
for (int[] arr : array3) {
    System.out.println(Arrays.toString(arr));
}

完整代码

package com.jiang.array;

import java.util.Arrays;

/**
 * @author HaiJaine
 **/
public class ArrayDemo08 {
    public static void main(String[] args) {
        //创建一个二维数组 11 * 11
        int[][] array1 = new int[11][11];
        //给一些元素赋值
        array1[1][2] = 1;
        array1[2][3] = 2;
        array1[4][4] = 1;
        array1[8][5] = 2;
        //输出原始数组
        System.out.println("输出原始数组");
        for (int[] arr : array1) {
            System.out.println(Arrays.toString(arr));
        }
        System.out.println("=================================");
        //转换为稀疏数组保存
        //获取有效值个数
        int sum = 0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[i].length; j++) {
                if (array1[i][j] != 0)
                    sum++;
            }
        }
        System.out.println("有效个数为：" + sum);

        //创建一个稀疏数组，第一个行为原始数组的行、列、有效值个数，其余行分别保存元素所在的行、列、元素值
        int[][] array2 = new int[sum + 1][3];
        array2[0][0] = 11;//原始数组行数
        array2[0][1] = 11;//原始数组列数
        array2[0][2] = sum;//有效值个数

        //遍历二维数组，将非零的值，存放稀疏数组中
        int count = 0;//计数作用
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[i].length; j++) {
                if (array1[i][j] != 0) {
                    count++;//稀疏数组从第二行开始存有效值信息
                    array2[count][0] = i;//有效值的行坐标
                    array2[count][1] = j;//有效值的列坐标
                    array2[count][2] = array1[i][j];//有效值
                }
            }
        }
        System.out.println("稀疏数组");
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i][0] + "\t" + array2[i][1] + "\t" + array2[i][2]);
        }
        System.out.println("=================================");
        System.out.println("稀疏矩阵还原");
        //1、读取稀疏数组
        int[][] array3 = new int[array2[0][0]][array2[0][1]];//array2[0][0]存储的为原始数组的行数，array2[0][1]存储的为原始数组的列数
        //2、给其中的元素还原它的值
        for (int i = 1; i < array2.length; i++) {
            array3[array2[i][0]][array2[i][1]] = array2[i][2];
        }
        //输出还原数组
        System.out.println("输出还原数组");
        for (int[] arr : array3) {
            System.out.println(Arrays.toString(arr));
        }
    }
}