稀疏数组与原始数组的相互转换

稀疏数组与原始数组的相互转换

0	0	0	0	0	3	0	0	
0	0	0	0	0	0	23	0	
0	0	0	0	0	58	0	0	
0	0	0	0	86	0	0	0	
0	0	0	0	0	48	0	0	
0	0	0	0	0	0	0	0	
5	0	0	0	0	0	0	0	

对于以上数据，如果选择使用数组的方式进行存储会造成内存的浪费，因为0元素太多；而稀疏数组可以解决以上问题，因此稀疏数组与原始数组之间的相互转换给工程带来了很大的便利。

稀疏数组

假设原始数组中有n行、m列、num个不为0的数

那么稀疏数组会是如下的形式

n		m		num
row 	column	value

稀疏数组共三列

• 第一行第一列存放原始数组的行数（n）
• 第一行第二列存放原始数组的列数（m）
• 第一行第三列存放原始数组中不为0的个数（num）

从第二行开始

• 第二行的第一列存放 原始数组中不为0的数的行值
• 第二行的第二列存放 原始数组中不为0的数的列值
• 第二行的第三列存放 原始数组中不为0的数的值
• …

代码实现

以下通过java程序来实现稀疏数组与原始数组的相互转换

新建一个SparseArry类

public class SparseArray {
}

定义原始数组->稀疏数组的方法

public int[][] arrayToSparse(int[][] arr) {
        int sum = 0; //非0元素个数,初始化为0
        //输出原始的数组，并记录初始数组有sum个非0元素
        System.out.println("初始数组为:");
    	//通过双循环遍历数组
        for (int[] row : arr) {
            for (int data : row) {
                System.out.print(data + "\t");
                if (data != 0) {
                    sum++;
                }
            }
            System.out.println();
        }
        //创建稀疏二维数组，int[sum+1][3]sparseArray
        int[][] sparseArray = new int[sum + 1][3];
    	//存放稀疏数组第一行的元素（原始数组的行、列、非0个数）
        sparseArray[0][0] = arr.length;//行数
        sparseArray[0][1] = arr[0].length;//列数
        sparseArray[0][2] = sum;//非0个数
        int curColumn = 1;
    //遍历原始数组中的所有元素，并把非0值赋给稀疏数组
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[0].length; j++) {
                if (arr[i][j] != 0) {
                    sparseArray[curColumn][0] = i;
                    sparseArray[curColumn][1] = j;
                    sparseArray[curColumn][2] = arr[i][j];
                    curColumn++;
                }
            }
        }
        //输出稀疏数组
        System.out.println("对应的稀疏数组为:");
        System.out.println("row\t" + "column\t" + "value");
    //遍历稀疏数组
        for (int[] row : sparseArray) {
            for (int data : row) {
                System.out.print(data + "\t");
            }
            System.out.println();
        }
        return sparseArray;
    }

定义稀疏数组->原始数组的方法

public int[][] SparseToArray(int[][] sparseArr) {
        //输出稀疏数组
        System.out.println("原稀疏数组为");
        System.out.println("row\t" + "column\t" + "value");
        for (int[] row : sparseArr) {
            for (int data : row) {
                System.out.print(data + "\t");
            }
            System.out.println();
        }
        //展开稀疏数组为数组
        //1.创建数组
        int[][] arr = new int[sparseArr[0][0]][sparseArr[0][1]];
        //2.展开数组,其他默认为0
        for (int i = 1; i < sparseArr[0][0]; i++) {
            arr[sparseArr[i][0]][sparseArr[i][1]] = sparseArr[i][2];
        }
        System.out.println("展开后的数组为：");
        for (int[] row : arr) {
            for (int data : row) {
                System.out.print(data + "\t");
            }
            System.out.println();
        }
        return arr;
    }

定义测试方法

public class SparseArrayTest {
    public static void main(String[] args) {
        //自己定义一个二维数组，并赋值
        int[][] initArray = new int[10][10];
        initArray[0][2] = 3;
        initArray[1][3] = 23;
        initArray[2][4] = 58;
        initArray[3][5] = 86;
        //新建一个稀疏数组类对象并调用转化方法；
        SparseArray s = new SparseArray();
        //将原始数组转化到稀疏数组
        int[][] sparseArray = s.arrayToSparse(initArray);
        //将稀疏数组转化到原始数组
        int[][] arr = s.SparseToArray(sparseArray);
    }
}