1、稀疏矩阵

1.1、简介

如果要创建一个二维数组保存的话会有无意义数据，所以我们需要创建一个能使用较小的占用空间的稀疏矩阵来存储。

稀疏矩阵的处理方法：

1. 记录数组一个共有几行几列，有多少个不同值

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

1. 第一行 6行 7列 8个有效数据

2. 后面的每一行都是一个有效值

1.2、思路

二维数组转稀疏数组的思路：

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

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

1. 根据稀疏数组的第一行创建出原始数组大小的新数组
2. 读取第二行往后的数据，赋予给新数组

1.3、代码实现

package com.yu.sparsearray;
​
import org.json.JSONArray;
import org.json.JSONException;
​
import java.io.*;
import java.nio.CharBuffer;
import java.util.Arrays;
import java.util.List;
​
/**
 * @Description: TODO
 * @Author : yu
 * Date : 3/31/2020 9:21 AM
 */
public class SparseArray {
    public static void main(String[] args) throws IOException {
        SparseArray sparseArray1 = new SparseArray();
        //创建一个原始二维数据
        //1为黑子，2位篮子、0位空值
        int[][] cherryArray = new int[11][11];
        cherryArray[1][2] =1;
        cherryArray[2][3] =2;
        //输出原始二维数组
        System.out.println("原始的二维数组");
        for (int[] ints : cherryArray) {
            for (int i : ints) {
                System.out.printf("%d\t",i);
            }
            System.out.println();
        }
        //记录有效数据的个数
        int count=0;
        //二维数组转成稀疏数组
        //1.先遍历二维数组 得到非0个数
        for (int i=0;i<11;i++){
            for (int j=0;j<11;j++){
                if (cherryArray[i][j]!=0){
                    count++;
                }
​
            }
        }
        //2.创建稀疏数组
        int[][] sparseArray = new int[count+1][3];
        //将第一行的数据添加进去
        sparseArray[0][0] = 11;
        sparseArray[0][1] = 11;
        sparseArray[0][2] = count;
        //将非0数值放进稀疏数组中
        int row=1;
        for (int i=0;i<11;i++){
            for (int j=0;j<11;j++){
                if (cherryArray[i][j]!=0){
                    sparseArray[row][0] = i;
                    sparseArray[row][1] = j;
                    sparseArray[row][2] = cherryArray[i][j];
                    row++;
                }
​
            }
        }
        //打印稀疏数组
        System.out.println("稀疏数组:");
        for (int[] ints : sparseArray) {
            for (int i : ints) {
                System.out.printf("%d\t",i);
            }
            System.out.println();
        }
        //将稀疏数组重新转换成普通二维数组
        System.out.println("二维数组");
        //根据稀疏矩阵的第一行获得代码
        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];
        }
        //遍历新数组是否已经与原始数组一致
        for (int[] ints : newArray) {
            for (int i : ints) {
                System.out.printf("%d\t",i);
            }
            System.out.println();
        }
​
    }
    //将数据保存到文件中
    public void saveFile(int[][] array) throws IOException {
        try {
            JSONArray jsonArray = new JSONArray(array);
            System.out.println(jsonArray.toString());
            File file = new File("sparseArray.json");
            if (!file.exists()){
                file.createNewFile();
            }else {
                file.delete();
            }
            Writer writer = new OutputStreamWriter(new FileOutputStream(file), "utf-8");
            writer.write(jsonArray.toString());
            writer.flush();
            writer.close();
        }catch (JSONException e){
            e.printStackTrace();
        }
​
    }
    //读取文件中的内容，转换成json,然后转换成数组
    public void getFile() throws IOException {
        File file = new File("sparseArray.json");
        Reader reader = new InputStreamReader(new FileInputStream(file), "utf-8");
        StringBuffer buffer = new StringBuffer();
        int n=0;
        while ((n=reader.read())!=-1){
            buffer.append((char)n);
        }
        reader.close();
        String jsonStr = buffer.toString();
        JSONArray jsonArray = new JSONArray(jsonStr);
        int[][] newArray = new int[jsonArray.length()][3];
        for (int j = 0;j <jsonArray.length() ; j++) {
            JSONArray a = (JSONArray)jsonArray.get(j);
            for (int i = 0; i <a.length() ; i++) {
                newArray[j][i] = (int)a.get(i);
            }
        }
        //打印稀疏矩阵
        for (int[] ints : newArray) {
            for (int i : ints) {
                System.out.printf("%d\t",i);
            }
            System.out.println();
        }
​
    }
}
​