Java中数组转换为稀疏数组，稀疏数组还原回原数组

稀疏数组介绍

在数组中若数值为0的元素数目远远多于非0元素的数目，并且非0元素的分布没有规律时，则称该数组为稀疏数组

首先我们创建一个二维数组

//创建一个6*6的二维数组，并赋给数组三个有效值
        int[][] array1 = new int[6][6];
        array1[1][2] = 1;
        array1[2][3] = 2;
        array1[3][4] = 2;
        System.out.println("输出原始的数组：");
        //使用增强for循环输出数组  for(数组的类型  变量  : 数组名)
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }

创建好的数组如下

获取该数组中有多少个有效值

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

创建一个稀疏数组并将原数组中非零的值存入,然后输出稀疏数组

//创建一个稀疏数组
        int[][] array2 = new int[sum + 1][3];
        //稀疏数组的标题：表示原数组是多少行多少列的数组，以及有多少个有效值
        array2[0][0] = 6;  //原数组是6行的
        array2[0][1] = 6;  //原数组是6列的
        array2[0][2] = sum; //原数组有"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、创建一个数组array3用来存放还原后的数组
            int[][] array3=new int[array2[0][0]][array2[0][1]]; //由上面的代码可知，array2[0][0]=array2[0][1]=6

            //2、让数组中非零的值还原回去
            for(int i=1;i<array2.length;i++){
                array3[array2[i][0]][array2[i][1]]=array2[i][2];
            }
            //3、将还原的数组输出
        System.out.println("输出还原的数组：");
        for (int[] ints : array3) {       //增强型for循环
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }

输出结果如下：

以下为完整的源代码

package array;

public class Demo7 {
    public static void main(String[] args) {
        //创建一个6*6的二维数组，并赋给数组三个有效值
        int[][] array1 = new int[6][6];
        array1[1][2] = 1;
        array1[2][3] = 2;
        array1[3][4] = 2;
        System.out.println("输出原始的数组：");
        //使用增强for循环输出数组  for(数组的类型  变量  : 数组名)
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }
        //转换为稀疏数组保存，获取有效值的个数
        int sum = 0;
        for (int i = 0; i < 6; i++) {
            for (int j = 0; j < 6; j++) {
                if (array1[i][j] != 0) {
                    sum++;  //获取有效值的个数
                }
            }
        }
        System.out.println("有效的个数：" + sum);
        //创建一个稀疏数组
        int[][] array2 = new int[sum + 1][3];
        //稀疏数组的标题：表示原数组是多少行多少列的数组，以及有多少个有效值
        array2[0][0] = 6;  //原数组是6行的
        array2[0][1] = 6;  //原数组是6列的
        array2[0][2] = sum; //原数组有"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、创建一个数组array3用来存放还原后的数组
            int[][] array3=new int[array2[0][0]][array2[0][1]]; //由上面的代码可知，array2[0][0]=array2[0][1]=6

            //2、让数组中非零的值还原回去
            for(int i=1;i<array2.length;i++){
                array3[array2[i][0]][array2[i][1]]=array2[i][2];
            }
            //3、将还原的数组输出
        System.out.println("输出还原的数组：");
        for (int[] ints : array3) {       //增强型for循环
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }
        }
    }

通过上述代码我们实现了数组转换为稀疏数组以及稀疏数组的还原，关于代码如有任何疑问欢迎在评论区留言。