稀疏数组

当一个数组中大部分元素为０，或者为同一个值的数组时，记录了很多没有意义的数据，可以使用稀疏数组来保存该数组。

稀疏数组的处理方法是:

1. 记录数组一共有几行几列，有多少个不同的值
2. 把具有不同值的元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;

/**
 * 稀疏数组
 *
 * @date 2021/02/23
 */
public class SparseArr {
    public static void main(String[] args) {
        // 原始数组
        int[][] oldArr = new int[20][20];
        // 生成随机数据
        oldArr[(int) (Math.random() * 20)][(int) (Math.random() * 20)] = (int) (Math.random() * 100);
        oldArr[(int) (Math.random() * 20)][(int) (Math.random() * 20)] = (int) (Math.random() * 100);
        oldArr[(int) (Math.random() * 20)][(int) (Math.random() * 20)] = (int) (Math.random() * 100);
        oldArr[(int) (Math.random() * 20)][(int) (Math.random() * 20)] = (int) (Math.random() * 100);
        oldArr[(int) (Math.random() * 20)][(int) (Math.random() * 20)] = (int) (Math.random() * 100);
        // 统计有效数据个数
        int sum = getSum(oldArr);

        System.out.println("-------------------");
        // 稀疏数组
        int[][] sparseArr = new int[sum + 1][3];
        compression(sparseArr, oldArr, sum);
        // 将原始数组和稀疏数组写入文件
        writeArr(oldArr, "e:\\oldArr.txt");
        writeArr(sparseArr, "e:\\sparseArr.txt");
        System.out.println("-------------------");
        //遍历稀疏数组
        System.out.println("row\tcol\tvalue");
        for (int[] ints : sparseArr) {
            System.out.println(ints[0] + "\t" + ints[1] + "\t" + ints[2]);
        }
        // 原始数组恢复之后的数组
        int[][] newArr = new int[sparseArr[0][0]][sparseArr[0][1]];
        reduction(newArr, sparseArr);


        System.out.println("-------------------");
        System.out.println("遍历还原数组");
        for (int i = 0; i < 20; i++) {
            for (int j = 0; j < 20; j++) {
                System.out.print(newArr[i][j] + " ");
            }
            System.out.println();
        }

    }

    public static void compression(int[][] sparseArr, int[][] oldArr, int sum) {
        // 下标
        int index = 1;
        // 生成稀疏数组,第一行记录行号，列号，有效数据个数，这里默认数组长度不为0，不会出现空指针
        sparseArr[0][0] = oldArr.length;
        sparseArr[0][1] = oldArr[0].length;
        sparseArr[0][2] = sum;
        bk:
        for (int i = 0; i < 20; i++) {
            for (int j = 0; j < 20; j++) {
                if (oldArr[i][j] != 0) {
                    sparseArr[index][0] = i;
                    sparseArr[index][1] = j;
                    sparseArr[index][2] = oldArr[i][j];
                    index++;
                    if (index == oldArr.length) {
                        break bk;
                    }
                }
            }
        }
    }

    public static int getSum(int[][] oldArr) {
        int sum = 0;
        // 遍历，计算有效数据个数，若是提前知道有效数据个数，可免去这步
        System.out.println("原始数组");
        for (int i = 0; i < 20; i++) {
            for (int j = 0; j < 20; j++) {
                System.out.print(oldArr[i][j] + " ");
                if (oldArr[i][j] != 0) {
                    sum++;
                }
            }
            System.out.println();
        }
        return sum;
    }

    public static void reduction(int[][] newArr, int[][] sparseArr) {
        for (int i = 1; i < sparseArr.length; i++) {
            newArr[sparseArr[i][0]][sparseArr[i][1]] = sparseArr[i][2];
        }
    }

    public static void writeArr(int[][] arr, String fileName) {
        File file = new File(fileName);  //存放数组数据的文件

        FileWriter out = null;  //文件写入流
        try {
            out = new FileWriter(file);
            for (int[] ints : arr) {
                for (int anInt : ints) {
                    out.write(anInt + "\t");
                }
                out.write("\r\n");
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (null != out) {
                try {
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

• 原始数组大小：845字节
  
• 稀疏数组大小：62字节
  

学习自尚硅谷