稀疏数组思路总结

稀疏数组

• 需求：编写的五子棋程序中，有存盘和续上盘的功能，即使用稀疏数组存储棋盘，再恢复

• 思路：

  对于二维数组中有大量相同的数字，例如棋盘中大量没有下的棋子设为0，黑子设为1，白子设为2，建立一个稀疏数组，只保存黑子，白子的位置以及二维数组的大小

  row	column	value
  二维数组的行	二维数组的列	有多少个非零数组
  行号	列号	1（表示黑子）
  行号	列号	2（白子）
  棋子在二维数组的行的位置	棋子在二维数组的行的位置	。。。（黑/白）

• 优势：11*11=121的二维数组，比如有20个棋子，只需大小为（20+1）* 3 = 63的数组

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

public class ParseArray {
    static int[][] chessArr;
    static int[][] sparseArr;

    public static void main(String[] args) {
        // 棋盘原数据
        chessArr = new int[11][11];
        chessArr[0][0] = 1;
        chessArr[3][4] = 2;
        chessArr[5][9] = 2;
        printArray(chessArr);

        // 棋盘数组转化为稀疏数组，遍历数组统计有多少个非零项，以及位置
        // 储存为行，列，值
        int sum = 0;
        int row = chessArr.length;
        int colunm = chessArr[0].length;
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < colunm; j++) {
                if (chessArr[i][j] != 0) {
                    sum++;
                }
            }
        }
        // 稀疏数组
        sparseArr = new int[sum + 1][3];
        // 第一行是原棋盘的数据
        sparseArr[0][0] = row;
        sparseArr[0][1] = colunm;
        sparseArr[0][2] = sum;

        // 将棋子储存进sparse中,遍历二维数组
        int count = 1;  // 计算稀疏数组已经存储了多少数据
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < colunm; j++) {
                if (chessArr[i][j] != 0) {
                    sparseArr[count][0] = i;
                    sparseArr[count][1] = j;
                    sparseArr[count][2] = chessArr[i][j];
                    count++;
                }
            }
        }
        // 打印稀疏数组
        printArray(sparseArr);

        // 稀疏数组转化为棋盘数据
        int[][] chessArr2 = convertChess(sparseArr);
        printArray(chessArr2);

        // 写入文件
        writeSparse2File();
        int[][] sparseArr2 = readSparseFile("sparseArray.data");
        printArray(sparseArr2);
    }

    private static int[][] convertChess(int[][] sparseArr) {
        int[][] chess = new int[sparseArr[0][0]][sparseArr[0][1]];
        int sum = sparseArr[0][2];
        // 从第二行遍历稀疏列表，读取内容还原棋盘非零数据
        for (int i = 1; i < sum + 1; i++) {
            int r = sparseArr[i][0];
            int c = sparseArr[i][1];
            int value = sparseArr[i][2];
            chess[r][c] = value;
        }
        return chess;
    }

    private static void printArray(int[][] array) {
        int row = array.length;
        int colum = array[0].length;
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < colum; j++) {
                System.out.print(array[i][j] + "\t");
            }
            System.out.println();
        }
    }

    private static int[][] readSparseFile(String path){
        try(BufferedReader reader = new BufferedReader(new FileReader(path))){
            // 读取第一行，创建稀疏数组
            String firstline = reader.readLine();
            int[] row1 = parseStr(firstline);
            int sum = row1[2];
            int[][] parseArray = new int[sum+1][3];
            parseArray[0] = row1;
            for (int i = 1; i < sum+1; i++) {
                String rowStr = reader.readLine();
                parseArray[i] = parseStr(rowStr);
            }
            return parseArray;
        }catch (Exception e){
        }
        return null;
    }
    private static int[] parseStr(String str){
        int strlength = str.length();
        str = str.substring(1, strlength-1);
        String[] split_str = str.split(", ");
        int len = split_str.length;
        int[] row = new int[len];
        for (int i = 0; i < len; i++) {
            row[i] = Integer.parseInt(split_str[i]);
        }
        return row;
    }
    private static void writeSparse2File() {
        BufferedWriter writer = null;
        int sum = sparseArr[0][2];
        try {
            writer = new BufferedWriter(new FileWriter("sparseArray.data"));
            for (int i = 0; i < sum + 1; i++) {
                int[] row = sparseArr[i];
                String Arrstr = Arrays.toString(row);
                writer.write(Arrstr);
                writer.write("\r\n");
                writer.flush();
            }
        } catch (Exception e) {
        } finally {
            try {
                if (writer != null) {
                    writer.close();
                }
            } catch (Exception e) {}
        }
    }
}

稀疏数组：
11	11	3	
0	0	1	
3	4	2	
5	9	2