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

package com.qing

/**
 * 首先说明一下 稀疏数组(sparseArr)的使用场景：数据大部分一样  需要压缩一下
 * 原数组
 * 0   1  0  0  0
 * 0   0  0  0  0
 * 0   0  3  0  0
 * 0   0  0  4  0
 * 0   0  0  0  0
 *
 * 稀疏数组
 * row col  val
 *  5   5    3   第一行  5 5 是原数组的行列大小  val 是原数组中非零的值的总数 不难看出 这个值就是稀疏数组的行数-1
 *  0   1    1 第二行 存的是 val=1 时 原数组的位置 是 0 1 也就是第一行 第二列 （数组有下标的 需要做-1处理）
 *  2   2    3 第三行 。。同上
 *  3   3    4
 *
 *
 * 想法如下：
 * 首先将普通数组转为稀疏数组
 * 1.首先需要遍历原数组  得到非零数的总数  通过这个数定义稀疏数组的行数大小 列数就是3  固定的
 * 2.创建稀疏数组 初始化一下第一行 也就是5 5  总数
 * 3.然后需要得到value对应的行数值 这里应该遍历原数组哦 遍历的时候 遍历一次
 * 如果是非0  这里判断 进一次if就是1 也就是第1行咯 所以定义一个count=0 进一次if 自增一次 这个count 就是稀疏数组的行数哦~
 * 这样 oldArr[i][j] 中的i 就是稀疏的sparseArr[1][0]=i  sparseArr[i][1]=j sparseArr[i][2]=oldArr[i][j]
 *
 * 其次是稀疏数组转为普通二维数组
 * 1.我们可以知道稀疏数组中第一行其实是原数组的大小 以及不同的值 所以可以进行读取 创建一个新的二维数组 5*5
 * 2.创建出来新的数组之后 没有完成 因为都是0  所以需要进行赋值
 * 要知道 稀疏数组中的 第一行开始 就应该是新数组的下标  例如这里的 0 1 1  代表的是 第一行 第二列 值是1
 * 3.开始赋值 这里的新数组记为newArr[][]
 * newArr[稀疏数组第一行第一个元素][稀疏数组第一行第二个元素]=sparse[i][2](值)
 * 这里的i应该从1开始遍历 因为你的稀疏数组里面  第一行才开始是有效的数据
 * newArr[ sparseArr[i][0] ][ sparseArr[i][1] ] = sparseArr[i][2]
 */


public class sparseArrTest {
    public static void main(String[] args) {
        int[][] oldArr = new int[5][5];
        oldArr[0][1] = 1;
        oldArr[2][2] = 3;
        oldArr[3][3] = 4;
        int count = -1;
        //遍历原始二维数组
        for (int[] row : oldArr) {
            for (int data : row) {
                count++;
                if (count % 5 == 0 && count != 0) {
                    System.out.println();
                }
                System.out.print(data + "\t");
            }
        }
        int sum = 0;
        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 5; j++) {
                if (oldArr[i][j] != 0) {
                    sum++;
                }
            }
        }
        System.out.println("非零数据总数sum=" + sum);

        //定义初始化稀疏数组  遍历原始二维数组 赋值
        int[][] sparseArr = new int[sum + 1][3];
        sparseArr[0][0] = 5;
        sparseArr[0][1] = 5;
        sparseArr[0][2] = sum;
        int count1 = 0;
        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 5; j++) {
                if (oldArr[i][j] != 0) {
                    count1++;
                    sparseArr[count1][0] = i;
                    sparseArr[count1][1] = j;
                    sparseArr[count1][2] = oldArr[i][j];
                }
            }
        }

        //输出sparseArr
        int count3 = -1;
        for (int[] row : sparseArr) {
            for (int data : row) {
                count3++;
                if (count3 % 3 == 0) {
                    System.out.println();
                }
                System.out.print(data + "\t");
            }
        }


        int[][] newArr = new int[sparseArr[0][0]][sparseArr[0][1]];
        //遍历sparseArr
        for (int i = 1; i < sparseArr.length; i++) {
                newArr[sparseArr[i][0]][sparseArr[i][1]]= sparseArr[i][2];
        }
        int count4 = -1;
        //遍历新的二维数组 实现sparseArr--->newArr
        for (int[] row : newArr) {
            for (int data : row) {
                count4++;
                if (count4 % 5 == 0 && count4 != 0) {
                    System.out.println();
                }
                System.out.print(data + "\t");
            }
        }


    }
}