Java稀疏数组

Java稀疏数组尝试

今天复习Java数组的时候，接触到一种数据结构----稀疏数组。

对于稀疏数组的作用与定义，用我的话来理解是这样的：

作用：

1. 对于一个二维数组，有效值（非0值）相对无效值（0值）比较少时，可以用稀疏数组，进行压缩以减少内存占用。
2. 可以通过稀疏数组，还原原数组。

定义：

1. 稀疏数组是一个n*3大小的二维数组，其中n大于1。
2. 数组第一行，记录原数组的长、宽、有效值个数。
3. 其他行记录各有效值在原数组中的二维下标和值。

下面是代码实现：

import java.util.Arrays;

public class SparseArray {
    public static void main(String[] args) {
        //定义数组规模
        int[][] array1= new int[5][5];
        //赋予有效值
        array1[0][1]=1;
        array1[1][2]=2;
        //打印数组
        printArray(array1);
        System.out.println("========我是分割线========");
        int[][] array2 = sparseArray(array1);
        printArray(array2);
        System.out.println("========我是分割线========");
        int[][] array3 = recombination(array2);
        printArray(array3);
    }
    //打印矩阵
    static public void printArray(int[][] array){
        if (array!=null){
            for (int[] ints : array) {
                for (int anInt : ints) {
                    System.out.print(anInt+"\t");
                }
                System.out.println();
            }
        }
    }
    //创建稀疏数组
    static public int[][] sparseArray(int[][] a){
        int sum=0;//记录有效数据的个数
        int row=a.length;//记录数组矩阵的行数
        int col=a[1].length;//记录数组矩阵的列数
        for (int[] ints : a) {
            for (int anInt : ints) {
                if (anInt!=0){
                    sum++;
                }
            }
        }
        int[][] result=new int[sum+1][3];//初始化数组大小
        //给稀疏数组第一行赋值
        result[0][0]=row;
        result[0][1]=col;
        result[0][2]=sum;
        //将原数组有效值记录到稀疏数组中
        int count=0;//记录存了多少个有效值
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col; j++) {
                if (a[i][j]!=0){
                    result[count+1][0]=i;
                    result[count+1][1]=j;
                    result[count+1][2]=a[i][j];
                    count++;
                }
            }
        }
        return result;
    }
    //通过稀疏数组还原原数组
    static public int[][] recombination(int[][] a){
        if (a[1].length!=3){
            System.out.println("您输入的不是稀疏数组");
            return null;
        }else {
            int[][] result=new int[a[0][0]][a[0][1]];//初始化重组数组的规模；
            for (int i = 1; i <= a[0][2]; i++) {
                result[a[i][0]][a[i][1]]=a[i][2];
            }
            return result;
        }
    }
}


输出结果：
0	1	0	0	0	
0	0	2	0	0	
0	0	0	0	0	
0	0	0	0	0	
0	0	0	0	0	
========我是分割线========
5	5	2	
0	1	1	
1	2	2	
========我是分割线========
0	1	0	0	0	
0	0	2	0	0	
0	0	0	0	0	
0	0	0	0	0	
0	0	0	0	0	

仅仅只是以自己的理解做的简单实现，有些实现可能还不是很优，如果有更好的放法欢迎大家讨论。