1-稀疏数组

稀疏数组

• 基本介绍:
  • 当一个数组中大部分元素为0,或者为同一个值的时候,可以使用稀疏数组来保存该数组
• 稀疏数组的处理方法:
  1. 记录数组一共几列几行,有多少不同的值
     1. 比如一个数组六行七列,一共存储了8个值,正常存储就是42个格子,但是我们可以弄一个新的数组,这个数组第一行,记录(6,7,8),代表压缩前数组是6行7列一共八个值,然后第二行(0,3,22)代表下标为(0,3)的格子存放数值22,一次类推,八个值用八行就可以存储完,那么最终的稀疏数组是9行3列,占用了27个格子,相比较原始数组,我们占用的空间就减少了
  2. 把具有不同值的元素的行列和值记录在一个小规模的数组中,从而缩小程序的规模

2. 数组的解压和压缩
3. 应用实例
   1. 使用稀疏矩阵,来保留二维数组
   2. 把稀疏矩阵存盘,并且可以恢复原始数组
   3. 思路分析
      1. 原始数组转稀疏数组
         1. 遍历原始二维数组,得到要保存的有效数据的个数sum,根据sum,我们就可以知道稀疏数组的大小
         2. 稀疏数组第一行存放原始二维数组的维数和二维数组中值的个数
         3. 根据sumj就可以创建稀疏数组sparseArr int[sum+1][3]
         4. 将二维数组的有效数据,存入稀疏数组
      2. 稀疏数组转原始数组
         1. 根据稀疏数组的行数-1,我们可以知道,原始数组存放了多少数据,根据稀疏数组第一行,可以知道数组的维数
         2. 遍历稀疏数组,将数据存放到原始数组中
   4. 代码实现

package com.hejiale.sparsearray.v1;

import java.io.*;
import java.util.Arrays;

public class SparseArray {

    public static void main(String[] args) throws Exception{
        //1. 创建原始二维数组
        //0:没有棋子 1:黑子 2:蓝子
        int[][] chessArr1 = new int[11][11];
        chessArr1[1][2] = 1;
        chessArr1[2][3] = 2;
        chessArr1[3][4] = 1;

        // 将原始数组转换为稀疏数组
        int[][] sparseArray = getSparseArray(chessArr1);
        // 将稀疏数组写入内存
        writerArr(sparseArray, "C:\\Users\\57\\Documents\\code\\DataStructures\\t1.txt");
        //从文件中读取数据,创建稀疏矩阵
        int[][] sparseArray2 = recoverArr("C:\\Users\\57\\Documents\\code\\DataStructures\\t1.txt");
        printArr(sparseArray2);
        //将稀疏数组恢复为原始数组
        int[][] chessArray = getChessArray(sparseArray2);
        printArr(chessArray);
    }


    /**
     * 将原始数组转换为稀疏数组
     * @param chessArr1 要转换的原始数组
     * @return  转换后的稀疏数组
     */
    public static int[][] getSparseArray(int[][] chessArr1) {
        int sum = 0;
        for (int[] row : chessArr1) {
            for (int i : row) {
                if (i != 0) {
                    sum++;
                }
            }
        }
        //2. 创建对应的稀疏数组
        int[][] sparseArray = new int[sum + 1][3];
        //3. 给稀疏数组第一行赋值
        sparseArray[0][0] = chessArr1.length;
        sparseArray[0][1] = chessArr1[0].length;
        sparseArray[0][2] = sum;
        //4. 将原始数组的数据存放到稀疏数组中
        for (int i = 0, x = 1; i < chessArr1.length; i++) {
            for (int j = 0; j < chessArr1[i].length; j++) {
                if (chessArr1[i][j] != 0) {
                    sparseArray[x][0] = i;
                    sparseArray[x][1] = j;
                    sparseArray[x][2] = chessArr1[i][j];
                    x++;
                }
            }
        }
        return sparseArray;
    }


    /**
     * 将稀疏数组恢复为原始数组
     * @param sparseArray 传入的稀疏数组
     * @return 恢复后的原始数组
     */
    public static int[][] getChessArray(int[][] sparseArray) {
        int[][] chessArr2 = new int[sparseArray[0][0]][sparseArray[0][1]];
        for (int i = 0, j = 1; i < sparseArray[0][2]; i++) {
            chessArr2[sparseArray[j][0]][sparseArray[j][1]] = sparseArray[j][2];
            j++;
        }
        return chessArr2;
    }

    /**
     * 将稀疏矩阵存入文件
     * @param sparseArray 存入的稀疏矩阵
     * @param pathname  存储路径
     * @throws IOException
     */
    public static void writerArr(int[][] sparseArray,String pathname) throws IOException {
        FileWriter fw = new FileWriter(new File(pathname));
        for (int[] ints : sparseArray) {
            for (int anInt : ints) {
                fw.write(anInt+"\t");
            }
            fw.write("\n");
        }
        fw.close();
    }


    /**
     * 从文件中恢复稀疏矩阵
     * @param pathname 文件地址
     * @return  返回恢复的稀疏矩阵
     * @throws Exception
     */
    public static int[][] recoverArr(String pathname) throws Exception {
        BufferedReader br = new BufferedReader(new FileReader(pathname));
        String first_line = br.readLine();
        String[] split = first_line.split("\t");
        int sum = Integer.parseInt(split[2]);//得知稀疏矩阵存储的几个值
        int[][] sparseArray3 = new int[sum+1][3];
        sparseArray3[0][0] = Integer.parseInt(split[0]);
        sparseArray3[0][1] = Integer.parseInt(split[1]);
        sparseArray3[0][2] = Integer.parseInt(split[2]);
        String line;
        int i=1;
        while((line = br.readLine())!=null){
            String[] split1 = line.split("\t");
            sparseArray3[i][0] = Integer.parseInt(split1[0]);
            sparseArray3[i][1] = Integer.parseInt(split1[1]);
            sparseArray3[i][2] = Integer.parseInt(split1[2]);
            i++;
        }
        br.close();
        return sparseArray3;
    }

    /**
     * 打印数组
     * @param arr 要打印的数组
     */
    public static void printArr(int[][] arr){
        for (int[] ints : arr) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
    }
}