稀疏数组

稀疏数组

1.概念

当一个数组大部分元素为0，或者为同一值的数组时，可以使用稀疏数组表示；

稀疏数组处理方法：

1）记录数据有几行几列，有多少个不同的值；

2）把具有不同值的元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模；

2.稀疏数组的举例

3.原始数据转化为稀疏数组

方法： 1）稀疏数组总是3列，第一行总是固定的，由原数组的行列数以及原数组中的非0个数组成；

所以首先遍历得到原数组中的非0个数sum以及行列数，创建稀疏数组new int[sum+1][3]

​ 2) 遍历原数组将有效值存入稀疏数组中

4.稀疏数组还原原数组

方法： 1） 根据稀疏数组第一行的前两个数值创建出原数组；

​ 2）遍历稀疏数组将其他行的值存入原数组中；

public class SparseArray {

    public static void main(String[] args) {

        int startArray[][] = new int[11][11];
        startArray[1][2] = 3;
        startArray[2][4] = 6;
        // 原数组转稀疏数组
        int sparse[][] = startToSparse(startArray);
        for (int[] ints : sparse) {
            for (int anInt : ints) {
                System.out.print(anInt + " ");
            }
            System.out.println();
        }
        System.out.println("------------------------");
        // 稀疏数组转为原数组
        int[][] ints1 = SparseToStartArray(sparse);
        for (int[] ints : ints1) {
            for (int anInt : ints) {
                System.out.print(anInt + " ");
            }
            System.out.println();
        }
    }


    /**
     * 原数组转稀疏数组
     *     row  col  val
     *  0  11   11    2     // 有效数组第一列行代表的分别为：原数组行、列、有效数字个数
     *  1  1     2    3     // 每个有效数值在原数组中的位置以及值
     *  2  2     4    6
     */
    private static int[][] startToSparse(int[][] startArray) {
        // 得到原数组中的有效数值的个数
       int sum = getSum(startArray);
        // 创建稀疏数组
        int row = sum + 1; //行
        int col = 3;
        int sparse[][] = new int[row][col];
        sparse[0][0] = startArray.length;
        sparse[0][1] = startArray[0].length;
        sparse[0][2] = sum;
        // 遍历原数组将原数组中的有效值赋值到稀疏数组
        int count = 0;
        for (int i=0;i<startArray.length;i++) {
             for (int j=0; j<startArray[0].length; j++) {
                 if (startArray[i][j] !=0) {
                     count++;
                     sparse[count][0] = i;
                     sparse[count][1] = j;
                     sparse[count][2] = startArray[i][j];
                 }
             }
         }

        return sparse;
    }


    public static int getSum(int[][] startArray) {
        int sum =0;
        for (int i=0; i<startArray.length; i++) {
            for (int j = 0; j< startArray[0].length; j++) {
                if (startArray[i][j] != 0) {
                    sum++;
                }
            }
        }
        return sum;
    }


    /**
     * 稀疏数组转化原数组
     * 根据稀疏数组第一行的前两个数值创建原数组
     * 循环遍历稀疏数组后几行，赋值给原数组
     */

    public static int[][] SparseToStartArray(int[][] sparseArray) {
        // 创建原数组
        int row = sparseArray[0][0];
        int col = sparseArray[0][1];
        int[][] startArray = new int [row][col];

        // 遍历稀疏数组
        for (int i=1; i<sparseArray.length;i++) {
            for (int j=0; j<3; j++) {
                int startRow = sparseArray[i][0];
                int startCol = sparseArray[i][1];
                startArray[startRow][startCol] = sparseArray[i][2];
            }
        }
        return startArray;
    }
}