稀疏数组

基本介绍

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

稀疏数组的处理方法是:

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

应用实例

使用稀疏数组，来保留类似前面的二维数组(棋盘、地图等等)，把稀疏数组存盘，并且可以从新恢复原来的二维数组数。
整体思路分析

扩展：在前面的基础上，将稀疏数组保存到磁盘上，比如 map.data。恢复原来的数组时，读取map.data 进行恢复

代码实现

package sparseArray;

import java.io.FileInputStream;
import java.io.RandomAccessFile;
import java.util.Arrays;

/**
 * @Data 2020/3/1 0001
 */
public class SparseArray {
    public static void main(String[] args) {
        int[][] array = new int[11][11];
        array[1][2] = 1; //1代表黑子
        array[2][3] = 2; //2代表白子
        //打印数组
        System.out.println("**********原数组***********");
        for (int[] row :
                array) {
            for (int data :
                    row) {
                System.out.printf("%d\t", data);
            }
            System.out.println();
        }
        //遍历非零个数
        int sum = 0;
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array.length; j++) {
                if (array[i][j] != 0) {
                    sum++;
                }
            }
        }
        /*
        创建对应的稀疏数组并赋值
         */
        int[][] sparseArray = new int[sum + 1][3];
        sparseArray[0][0] = 11;
        sparseArray[0][1] = 11;
        sparseArray[0][2] = sum;
        /*
        遍历二维数组，将非零的值存放到sparseArray中
         */
        int count = 0; //记录第几个非零数
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array.length; j++) {
                if (array[i][j] != 0) {
                    count++;
                    sparseArray[count][0] = i;
                    sparseArray[count][1] = j;
                    sparseArray[count][2] = array[i][j];
                }
            }
        }
        /*
		 *  1. 先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组，比如上面的  chessArr2 = int [11][11]
			2. 在读取稀疏数组后几行的数据，并赋给 原始的二维数组 即可.
		 */
        //将稀疏数组转换成初始数组
        int[][] array1 = new int[sparseArray[0][0]][sparseArray[0][1]];
        for (int i = 1; i < sparseArray.length; i++) {
            array1[sparseArray[i][0]][sparseArray[i][1]] = sparseArray[i][2];
        }
        System.out.println("***********恢复后的数组*************");
        for (int[] row :
                array1) {
            for (int data :
                    row) {
                System.out.printf("%d\t", data);
            }
            System.out.println();
        }

        //将稀疏数组写入map.dat
        writeSpareArr(sparseArray);
        //读map.dat并还原二维数组
        readSparseArr(sparseArray);
    }

    /**
     * 将稀疏数组遍历并存入map.dat中
     * @param sparseArray
     */
    public static void writeSpareArr(int[][] sparseArray){
        String a = null;
        String b = null;
        String c = null;
        //遍历稀疏数组
        for (int i = 0; i < sparseArray.length; i++) {
            //打印稀疏数组
            System.out.printf("%d\t%d\t%d\t", sparseArray[i][0], sparseArray[i][1], sparseArray[i][2]);
            try (RandomAccessFile raf = new RandomAccessFile("map.dat", "rw")) {
                raf.seek(i * 60); //将指针移动到每一行开始位置
                //将数组Int类型转换成字符串类型
                a = sparseArray[i][0] + "";
                b = sparseArray[i][1] + "";
                c = sparseArray[i][2] + "";
                //将字符串以UTF-8转换成字节，一个数占20个字节，便于后面取
                byte[] data = a.getBytes("utf-8");
                data = Arrays.copyOf(data, 20);
                raf.write(data);
                data = b.getBytes("utf-8");
                data = Arrays.copyOf(data, 20);
                raf.write(data);
                data = c.getBytes("utf-8");
                data = Arrays.copyOf(data, 20);
                raf.write(data);

            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println();
        }
    }

    /**
     * 从map中读取稀疏数组并还原 初始二维数组
     * @param sparseArray
     */
    public static void readSparseArr(int[][] sparseArray) {
        int[][] sparseArray1 = new int[0][]; //初始化数组
        try (FileInputStream fis = new FileInputStream("map.dat")) {
            for (int i = 0; i < sparseArray.length; i++) {
                //读行
                byte[] data = new byte[20];
                fis.read(data);
                int row = Integer.parseInt(new String(data, "utf-8").trim());
                //读列数
                data = new byte[20];
                fis.read(data);
                int col = Integer.parseInt(new String(data, "utf-8").trim());
                //读值
                data = new byte[20];
                fis.read(data);
                int val = Integer.parseInt(new String(data, "utf-8").trim());
                //因为第一行是数组行数、列数和非零个数，所以单独分支
                if (i == 0) {
                    sparseArray1 = new int[row][col];
                    System.out.print("棋子个数: " + val);
                } else {
                    /*
                    从第二行开始，将列数，行数，值分别赋给二维数组
                     */
                    sparseArray1[row][col] = val;
                }
            }
            System.out.println();
            System.out.println("**********读取文件的原数组**********");
            for (int[] row :
                    sparseArray1) {
                for (int data :
                        row) {
                    System.out.printf("%d\t", data);
                }
                System.out.println();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}