个人数据结构与算法学习总结-数组与稀疏数组

数组、稀疏数组

本总结主要是以“尚硅谷Java算法教程”的学习教程为主，加上一些个人的理解
本篇主要关于数组和稀疏数组之间的装换

数组

创建一个数组用于保存棋盘信息

代码实现

        // 创建一个原始的二维数组 11 * 11
        // 0: 表示没有棋子， 1 表示 黑子 2 表蓝子
        int[][] chessArr = new int[11][11];
        chessArr[1][2] = 1;
        chessArr[2][3] = 2;
        chessArr[4][5] = 2;
        // 输出原始的二维数组
        System.out.println("原始的二维数组");
        for (int[] rows : chessArr) {
            System.out.println(Arrays.toString(rows));
        }

稀疏数组

当一个数组中大部分元素为０，或者为同一个值的数组时，可以使用稀疏数组来保存该数组。
稀疏数组的处理方法是:
1）记录数组一共有几行几列，有多少个不同的值
2） 把具有不同值的元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模
如图示：

代码实现

// 将二维数组 转 稀疏数组的思路
        // 1. 先遍历二维数组 得到非0数据的个数
        int sum = 0;
        for (int[] rows : chessArr) {
            for (int colums : rows) {
                if (colums != 0) {
                    sum += 1;
                }
            }
        }
        // 2. 创建对应的稀疏数组
        int[][] sparseArr = new int[sum + 1][3];
        sparseArr[0][0] = 11;//数组对应的行数
        sparseArr[0][1] = 11;//数组对应的列数
        sparseArr[0][2] = sum;//数组对应的不为0的个数
        int index = 1;//用于记录是第几个非零值
        // 遍历二维数组，将非0的值存放到 sparseArr中
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (chessArr[i][j] != 0) {
                    sparseArr[index][0] = i;
                    sparseArr[index][1] = j;
                    sparseArr[index][2] = chessArr[i][j];
                    index += 1;
                }
            }
        }
        //输出稀疏数组
        for (int[] rows : sparseArr) {
            System.out.println(Arrays.toString(rows));
        }

整体代码（包含数组转稀疏，稀疏转数组，将数组输入文件，从文件中读取数据）

package datastructure;

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

public class SparseArray {
    public static void main(String[] args) throws IOException {
        // 创建一个原始的二维数组 11 * 11
        // 0: 表示没有棋子， 1 表示 黑子 2 表蓝子
        int[][] chessArr = new int[11][11];
        chessArr[1][2] = 1;
        chessArr[2][3] = 2;
        chessArr[4][5] = 2;
        // 输出原始的二维数组
        System.out.println("原始的二维数组");
        for (int[] rows : chessArr) {
            System.out.println(Arrays.toString(rows));
        }

        // 将二维数组 转 稀疏数组的思路
        // 1. 先遍历二维数组 得到非0数据的个数
        int sum = 0;
        for (int[] rows : chessArr) {
            for (int colums : rows) {
                if (colums != 0) {
                    sum += 1;
                }
            }
        }
        // 2. 创建对应的稀疏数组
        int[][] sparseArr = new int[sum + 1][3];
        sparseArr[0][0] = 11;//数组对应的行数
        sparseArr[0][1] = 11;//数组对应的列数
        sparseArr[0][2] = sum;//数组对应的不为0的个数
        int index = 1;//用于记录是第几个非零值
        // 遍历二维数组，将非0的值存放到 sparseArr中
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (chessArr[i][j] != 0) {
                    sparseArr[index][0] = i;
                    sparseArr[index][1] = j;
                    sparseArr[index][2] = chessArr[i][j];
                    index += 1;
                }
            }
        }
        //输出稀疏数组
        System.out.println("稀疏数组为：");
        for (int[] rows : sparseArr) {
            System.out.println(Arrays.toString(rows));
        }
        //将稀疏数组恢复成原始的二维数组
		/*
		 *  1. 先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组，比如上面的  chessArr2 = int [11][11]
			2. 在读取稀疏数组后几行的数据，并赋给 原始的二维数组 即可.
		 */
        int[][] chessArr2 = new int[sparseArr[0][0]][sparseArr[0][1]];
        for (int i = 1; i <= sparseArr[0][2]; i++) {
            chessArr2[sparseArr[i][0]][sparseArr[i][1]] = sparseArr[i][2];
        }
        //输出二维数组
        System.out.println("二维数组为：");
        for (int[] rows : chessArr2) {
            System.out.println(Arrays.toString(rows));
        }
        //将稀疏数组保存到文件中
        File file = new File("src\\resourse\\array.txt"); //存放数组数据的文件
        FileWriter out = new FileWriter(file);  //文件写入流

        //将稀疏数组写入文件
        System.out.println("将稀疏数组写入文件中。。。");
        for (int[] rows : sparseArr) {
            for (int colums : rows) {
                out.write(Integer.toString(colums));
                out.write("\t");
            }
            out.write("\n");
        }
        out.close();//关闭流;

        //从文件中读出数据
        System.out.println("读出数据");
        BufferedReader in = new BufferedReader(new FileReader(file));
        String line;
        int row = 0;
        ArrayList arr = new ArrayList<>();
        while ((line = in.readLine()) != null) {
            row += 1;
            arr.add(line);
        }

        int[][] sparseArr2 = new int[row][3];
        int i=0;
        for (String lines : arr) {
            String[] temp = lines.split("\t");//对数据进行分块
            sparseArr2[i][0] = Integer.parseInt(temp[0]);
            sparseArr2[i][1] = Integer.parseInt(temp[1]);
            sparseArr2[i][2] = Integer.parseInt(temp[2]);
            i+=1;
        }
        in.close();

        //输出稀疏数组
        System.out.println("从文件中读取的数组为");
        for (int[] rows : sparseArr2) {
            System.out.println(Arrays.toString(rows));
        }

    }

}