学习——————稀疏数组

说说什么是程序？
网上的解释层出不穷，这里贴上百度百科的回答：

• 计算机程序是一组计算机能识别和执行的指令，运行于电子计算机上，满足人们某种需求的信息化工具。

那么大家都是怎么理解的呢？(欢迎留言交流)

• 我的理解是： 程序=数据结构+算法

数据结构：就是计算机存储、组织数据的方式。

数据结构图解:

线性结构:
1） 线性结构作为最常用的数据结构，其特点是数据元素之间存在一对一的线性关系。
比如:数学中的一元一次、一元二次方程中一个y值对应的一个x值
2) 线性结构有两种不同的存储结构，即顺序存储结构和链式存储结构。顺序存储的线性表称为顺序表，顺序表中的存储元素是连续的
3) 链式存储的线性表称为链表，链表中的存储元素不一定是连续的，元素节点中存放数据元素以及相邻元素的地址信息。
4) 线性结构常见的有：数组、队列、链表和栈

非线性结构包括：二维数组，多维数组，广义表，树结构，图结构

算法：就是解决问题的的方法和逻辑。

其实在做项目更能体会到——因为不使用框架也能完成独立的项目(框架目的为了简化开发、开发更快)所以一般项目核心会着重写好业务逻辑(service层)。

可见数据结构和算法是多么的重要,所以最近开始在B站上刷视频学习数据结构和算法，毕竟这两块还是很重要。

1.什么是稀疏数组？

说稀疏数组还是得温故知新一波数组。
什么是数组？

• 就是相同数据类型按一定顺序排列的集合元素

那你瞅瞅下面的数组看看是不是这个意思

		//字符数组
		char[] value = {'A', 'B'};
		//int数组
        int[] arr[] = {1, 2, 3, 4};

稀疏数组是这么定义的：

• 当一个数组大部分元素为0，或者是同一个值的时，可以使用稀疏数组来保存数组。
  说白了就是记录非0或者同一值元素存放到的数组中。

稀疏数组处理方法是：
1.记录数组一共有几行几列，有多少个不同的值。
2.把具有不同值的元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模

图解(二维数组):

大致过程:
第一行: 其中5、5、9分别表示该数组5行5列 有9个不同的值
第二行: 表示第一个值为22 在数组的位置是索引为0的第一行且索引为2的第二列元素
第三行: 表示第二个值为13 在数组的位置是索引为0的第一行且索引为4的第二列元素
第四行: 表示第三个值为10 在数组的位置是索引为1的第一行且索引为1的第二列元素

2.为什么使用稀疏数组？

介绍完稀疏数组那么什么时候用稀疏数组呢？
使用场景:五子棋(相当于一个二维数组)

上图是一个 14 * 14 的五子棋棋盘 这时两个棋手对弈一个人下了一个棋子,突然他们临时有事不玩了，此时 14 * 14只下了两个棋子，其余空间有点浪费。
这时候稀疏数组出场了，他说我可以帮你转化一下，两个棋手下的棋子的以及他们位置我帮你存在我这。

用稀疏数组表示（图解）:

3.怎么操作稀疏数组？

五子棋中 1 表示黑子，2 表示蓝子(由于白色在棋盘不明显，换成蓝色棋子)
具体操作步骤:

一、原始数组转稀疏数组

1. 使用数组创建14行14列的棋盘
2. 有效数据存放到二维数组中
3. 求出有效数据个数sum由上面的图解可以得知稀疏数组的行是sum+1，列固定不变为3

二、稀疏数组存储到磁盘

1. 使用IO流写入到磁盘

三、从磁盘中读取稀疏数组

1. 使用IO流读取稀疏数组

四、稀疏数组转原始数组

1. 创建原始数组 其中原始数组的行是稀疏数组第一行第一列元素的值，列是稀疏数组第一行第二列元素的值

                        **********************代码实现**********************
   

01 创建出来的原始数组:

       //创建原始数组14行14列
        int[][] chessArray = new int[14][14];
        //有效数据存放到二维数组中
        chessArray[1][3] = 1;
        chessArray[2][5] = 2;
        //求出有效数据个数
        int sum=0;
        for (int i = 0; i < chessArray.length; i++) {
            for (int j = 0; j < chessArray[i].length; j++) {
                if (chessArray[i][j] != 0) {
                    sum++;
                }
            }
        }
        //遍历查看一下
        for (int[] data:chessArray) {
            for (int ele:data) {
                System.out.printf("%d\t", ele);
            }
            System.out.println();
        }

原始数组展示

02原始数组转稀疏数组代码

 		System.out.println("稀疏数组~~~~~~~");
        //确定稀疏数组的行列数
        int[][] sparseArray = new int[sum + 1][3];
        //确定的数据存入稀疏数组(指的是行列数和有效值)
        sparseArray[0][0] = 14;
        sparseArray[0][1] = 14;
        sparseArray[0][2] = 2;
        //遍历原始数组将有效数据存入稀疏数组

        int count = 0;
        for (int i = 0; i < chessArray.length; i++) {
            for (int j = 0; j < chessArray[i].length; j++) {
                if (chessArray[i][j] != 0) {
                    count++;
                    sparseArray[count][0] = i;
                    sparseArray[count][1] = j;
                    sparseArray[count][2] = chessArray[i][j];
                }
            }
        }
		//遍历稀疏数组
        for (int[] data : sparseArray) {
            for (int ele : data) {
                System.out.printf("%d\t", ele);
            }
            System.out.println();
        }

稀疏数组展示

03将稀疏数组写入磁盘

       //将稀疏数组写入磁盘
        String pathName = "D:/sparse/data.txt";
        File file = new File(pathName);
        if (!file.exists()) {
            //目录不存在创建文件夹
            file.getParentFile().mkdirs();
        }
        //创建文件
        file.createNewFile();
        FileOutputStream fos = new FileOutputStream(file);
        for (int i = 0; i < sparseArray.length; i++) {
            for (int j = 0; j < sparseArray[i].length; j++) {
                fos.write(sparseArray[i][j]);
            }
        }
        //释放资源
        fos.close();
        System.out.println("写入成功!");

写入磁盘后的稀疏数组

04磁盘数据恢复为稀疏数组

 /**
         * 磁盘数据恢复为稀疏数组
         * 清空原先稀疏数组的所有元素
         * 使从磁盘中读取到的有效数据重写存入sparseArray中 不用再次创建一个数组
         */
        //清空sparseArray数组
        for (int i = 0; i < sparseArray.length; i++) {
            for (int j = 0; j < sparseArray[i].length; j++) {
                sparseArray[i][j]=0;
            }
        }
        //清空后的数组
        for (int i = 0; i < sparseArray.length; i++) {
            for (int j = 0; j < sparseArray[i].length; j++) {
                System.out.printf("%d\t",sparseArray[i][j]);
            }
            System.out.println();
        }
        //读取磁盘数据重新存入到sparseArray中
        for (int i = 0; i < sparseArray.length; i++) {
            for (int j = 0; j < sparseArray[i].length; j++) {
                int read = fis.read();
                sparseArray[i][j]=read;
            }
        }
        System.out.println("恢复后的稀疏数组~~~~~");

        for (int[] data : sparseArray) {
            for (int ele : data) {
                System.out.printf("%d\t", ele);
            }
            System.out.println();
        }

05稀疏数组转为原始数组

		 //稀疏数组转为原始数组
        int[][] chessArray2 = new int[sparseArray[0][0]][sparseArray[0][1]];
        //将稀疏数组数据写入原始数组中
        /**
         * 1  3  1
         * 2  5  2
         */
        for (int i = 1; i < sparseArray.length; i++) {
            chessArray2[sparseArray[i][0]][sparseArray[i][1]]=sparseArray[i][2];
        }
        System.out.println("原始数组~~~~~");
        for (int[] ints : chessArray2) {
            for (int ele : ints) {
                System.out.printf("%d\t", ele);
            }
            System.out.println();
        }

最后在验证一下:如果往最初的原始数组中再添加两个元素甚至更多，查看效果！

		//添加两个元素
		chessArray[5][6] = 1;
        chessArray[13][13] = 2;

总结:

1. 确实修改原始数组，稀疏数组也跟着变化！
   大功告成！！！