学习笔记-稀疏数组

稀疏数组

当二维数组含有很多很多0项时，完全存储就需要消耗比较大的内存，于是我们可以将原数组改为稀疏数组进行存储，这样就节省了内存空间。

形式

是一个多行3列的二维数组。第一行用来存储原数组的行数、列数和有效数字个数。之后每一行分别存储一个有效数字的行数、列数和值。总行数为有效数字总数+1行。

代码实现

稀疏数组的创建：

1. 遍历原数组获得有效数字的个数num
2. 根据num初始化稀疏数组
3. 遍历原数组挨个赋值

package DataStructure.SparseArray;


import java.io.BufferedReader;
import java.io.FileReader;
import java.io.FileWriter;

/**
 * 稀疏数组SparseArray：用于含有多空白的二维数组压缩
 */
public class SparseArray {
    public static void main(String[] args) {
        //原数组
        int array[][] = new int[11][11];
        array[1][2] = 1;
        array[2][3] =2;
        System.out.println("---------压缩前的数组如下---------");
        for (int i = 0; i <array.length ; i++) {
            for (int j = 0; j <array[i].length ; j++) {
                System.out.printf("%d\t",array[i][j]);
            }
            System.out.println("");
        }
        //稀疏数组
        //首先获取原数组的有效值num
        int num=0;
        for (int i = 0; i <array.length ; i++) {
            for (int j = 0; j <array[i].length ; j++) {
                if(array[i][j]!=0) {
                    num++;
                }
            }
        }
        int sparseArray[][] =new int[num+1][3];
        //第一行为原数组的行，列，有效值个数
        sparseArray[0][0]=11;
        sparseArray[0][1]=11;
        sparseArray[0][2]=num;
        //以下每一行为有效数据所在行，列，值
        //记录稀疏数组的行值
        int n=1;
        for (int i = 0; i <array.length ; i++) {
            for (int j = 0; j <array[i].length ; j++) {
                if(array[i][j]!=0) {
                    sparseArray[n][0]=i;
                    sparseArray[n][1]=j;
                    sparseArray[n][2]=array[i][j];
                    n++;
                }
            }
        }
        System.out.println("-------压缩的稀疏数组----------");
        for (int i = 0; i <sparseArray.length ; i++) {
            System.out.printf("%d\t%d\t%d\t\n",sparseArray[i][0],sparseArray[i][1],sparseArray[i][2]);
        }
        try {
        	//将数组保存在文件中
            FileWriter fileWriter=new FileWriter("src/DataStructure/SparseArray/sparsearray.txt");
            for (int i = 0; i <sparseArray.length; i++) {
                fileWriter.write(sparseArray[i][0]+" ");
                fileWriter.write(sparseArray[i][1]+" ");
                fileWriter.write(sparseArray[i][2]+" ");
            }
            fileWriter.close();
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

输出结果

稀疏数组的还原：

1. 读取第一行，创建原数组
2. 遍历稀疏数组，对原数组重新赋值

package DataStructure.SparseArray;

import java.io.BufferedReader;
import java.io.FileReader;

public class ReduceSparseArray {
    public static void main(String[] args) {
        //还原
         try{
         	//文件读取
            FileReader fileReader=new FileReader("src/DataStructure/SparseArray/sparsearray.txt");
            BufferedReader bufferedReader=new BufferedReader(fileReader);
            String line;
            String str="";
            while ((line=bufferedReader.readLine())!=null){
                str +=line;
            }
            String[] strs=str.split(" ");
            int[][] sparseArray=new int[strs.length/3][3];
            int n=0;
             for (int i = 0; i <strs.length ; i+=3) {
                 sparseArray[n][0]=Integer.parseInt(strs[i]);
                 sparseArray[n][1]=Integer.parseInt(strs[i+1]);
                 sparseArray[n][2]=Integer.parseInt(strs[i+2]);
                 n++;
             }
             //原数组
             int newArray[][] =new int[sparseArray[0][0]][sparseArray[0][1]];
             for (int i = 1; i <sparseArray.length ; i++) {
                 newArray[sparseArray[i][0]][sparseArray[i][1]]=sparseArray[i][2];
             }
             System.out.println("-----------还原出的数组--------------");
             for (int i = 0; i <newArray.length ; i++) {
                 for (int j = 0; j <newArray[i].length ; j++) {
                     System.out.printf("%d\t",newArray[i][j]);
                 }
                 System.out.println("");
             }
         }catch (Exception e){
             e.printStackTrace();
         }
    }

}

输出结果

保存的文件