JAVA数据结构与算法——稀疏数组

稀疏数组

当一个数据中大部分元素都是0，或者为同一个值的数组时，可以使用稀疏数组来保存该数组。

稀疏数组的处理方法是：

1. 记录数组一共有几行几列和一共有多少个值
2. 把具有不同过值的元素的行列及值记录在一个小规模的数组中，从而起到缩小数据大小的规模的作用。

比如：棋盘位置问题

0000000000
0012000000
0001200000
0000120000
0000000000
0000000000
0000000000
0000000000
0000000000
0000000000

### 以上是一个 10*10 的二维数组 数据，其中只有6个有效数据，其他都是0
### 可以改装为
行  列  值
10  10  6
1   2   1
1   3   2
2   3   1
2   4   2
......

### 第一行数据用来记录整个二维数组一共几行几列，第三个值记录一共有几个值
### 其他记录在二维数组中的位置及其值

二维数组转稀疏数组思路

1. 遍历原始的二维数组，得到有效数据的个数sum
2. 根据sum就可以创建稀疏数组sparseArr int[sum+1][3]
3. 将二维数组有效数据写入稀疏数组

稀疏数组转原始二维数组思路

1. 读取稀疏数组的第一行，根据第一行数据创建原始二维数组，默认值全是0
2. 读取稀疏数组后几行，并赋给原始二维数组即可

代码例子

/**
 * 稀疏数组
 * 用稀疏数组保存数据，可以压缩数据的大小
 */
public class SpareArray {

    /**
     * 构建初始数据
     * @return
     */
    private static int[][] createInitData() {
        int[][] dataArr = new int[10][10];
        dataArr[2][3] = 1;
        dataArr[3][4] = 2;
        dataArr[4][5] = 1;
        dataArr[9][9] = 2;
        return dataArr;
    }

    /**
     * 打印二维数组
     * @param dataArr
     */
    private static void printTwoDimensionalArray(int[][] dataArr) {
        for (int[] row : dataArr) {
            for (int item : row) {
                System.out.print(String.format("%d\t",item));
            }
            System.out.println();
        }
    }

    /**
     * 寻找不为0的数据的数量
     * @param dataArr
     * @return
     */
    private static int getInvalidDataCount(int[][] dataArr) {
        int count = 0;
        for (int[] row : dataArr) {
            for (int item : row) {
                if(item != 0){
                    count++;
                }
            }
        }
        return count;
    }

    /**
     * 创建稀疏数组
     * 第一行统计二维数组行列数量及有几个有效数字
     * 之后的行记录有效数字的位置及值
     * @param dataArr 原始数组
     * @param count 有效数据个数
     * @return
     */
    private static int[][] generateSpareArray(int[][] dataArr, int count) {
        int[][] spareArr = new int[count+1][3];
        // 疏松数组第一行赋值
        spareArr[0][0] = dataArr.length;
        spareArr[0][1] = dataArr[0].length;
        spareArr[0][2] = count;

        int index = 1;
        for (int row = 0; row < dataArr.length; row++) {
            for (int column = 0; column < dataArr[row].length; column++) {
                if (dataArr[row][column] != 0) {
                    spareArr[index][0] = row;
                    spareArr[index][1] = column;
                    spareArr[index][2] = dataArr[row][column];
                    index++;
                }
            }
        }
        return spareArr;
    }


    public static void main(String[] args) {
        int[][] dataArr = createInitData();
        System.out.println(" ===== 遍历原始数据 =====");
        printTwoDimensionalArray(dataArr);

        // 统计有几个有效数据
        int count = getInvalidDataCount(dataArr);
        int[][] spareArr = generateSpareArray(dataArr, count);

        System.out.println(" ===== 遍历稀疏数组 =====");
        printTwoDimensionalArray(spareArr);

        System.out.println(" ===== 遍历还原后的数据 =====");
        int[][] restoreData = new int[spareArr[0][0]][spareArr[0][1]];
        for (int i = 1; i < spareArr.length; i++) {
            restoreData[spareArr[i][0]][spareArr[i][1]] = spareArr[i][2];
        }
        printTwoDimensionalArray(restoreData);
    }
}

代码路径